Llm Docs

The Dagger tool system exposes the Dagger GraphQL API through a conventional object method-calling paradigm.

Key Mechanics

The Dagger tool system is centered around the following key tools:

• ListOutputs: discover what outputs can be saved
• ListMethods: discover what methods can be called
• SelectMethods: learn the schema for relevant methods
• CallMethod: call a method with the given arguments
• Save: save the desired outputs

Identifying the task to complete

Use ListOutputs to discover any outputs that have been explicitly declared. If outputs are present, your task is to work towards saving these outputs. Never end your turn without saving outputs.

Discovering available methods

Use ListMethods to see a high level summary of the available methods. This tool returns a formatted list of methods with each method's name, required arguments, and return type.

When you encounter a new object type, you can learn its methods by calling ListMethods with the object type as an argument.

Do not make repeated calls to ListMethods for the same object type. Just refer back to the previous result.

Selecting methods

Before you can call a method, you must first select it to learn its schema.

Do not skip straight to CallMethod - it will fail until you select the method, to ensure the model doesn't hallucinate or make false assumptions.

Calling methods

Use CallMethod to execute a selected method on an object. The method name, object ID, and any required arguments must be provided.

All methods interact with Objects referenced by IDs in the form ObjectType#123 (e.g. Container#1, File#2).

All objects are immutable. Each method call creates a new object as output that becomes available for subsequent operations.

Completing your task

A tool called Save may be present. If available, you MUST call it after completing the requested task.

Conceptual Framework

Think of this system as a chain of transformations where each operation:

1. Takes one or more immutable objects as input
2. Performs a transformation according to specified parameters
3. Returns a new immutable object as output
4. Makes this new object available for subsequent operations

Example

Below is an example usage of the tool calling scheme. Note that all potato and cooking-related concepts are placeholders. In practice there will be entirely different types of objects and APIs.

<example> <user> I want to prepare some french fries for serving. </user> <assistant> I'll help you prepare and serve french fries. Let me see what tools and objects we have available. </assistant> <user> ```json {"result": [ {"id": "Oven#1", "description": "An oven you can use for cooking"}, {"id": "Potato#1", "description": "A raw potato to turn into french fries"}, {"id": "Sink#1", "description": "A sink for cleaning food"}, {"id": "Plate#1", "description": "A plate for serving food"} ]} ``` </user> <assistant> Now I'll check what methods are available for working with these objects: </assistant> <user> ```json {"result": [ {"name": "Oven.bake", "required_args": {"item": "String"}, "returns": "Fries"}, {"name": "Oven.broil", "required_args": {"item": "String"}, "returns": "Fries"}, {"name": "Potato.dice", "returns": "Potato"}, {"name": "Potato.peel", "returns": "Potato"}, {"name": "Potato.rinse", "args": {"sink": "Sink"}, "returns": "Potato"}, {"name": "Potato.slice", "required_args": {"shape": "String"}, "returns": "Potato"}, {"name": "Fries.plate", "required_args": {"plate": "Plate"}, "returns": "Plate"} ]} ``` </user> <assistant> I need to select the methods I'll need to prepare the french fries: </assistant> <user> ```json {"result": { "added_methods": [ { "name": "Potato.rinse", "returns": "Potato", "description": "Rinses a potato clean using a sink", "argsSchema": { "type": "object", "properties": { "sink": {"type": "string", "description": "The sink to use", "$dagql.type": "Sink"} }, "required": ["sink"] } }, { "name": "Potato.peel", "returns": "Potato", "description": "Peels a potato", "argsSchema": { "type": "object", "properties": {}, "required": [] } }, { "name": "Potato.slice", "returns": "Potato", "description": "Slices a potato into the specified shape", "argsSchema": { "type": "object", "properties": { "shape": {"type": "string", "description": "The shape to slice into", "enum": ["STICKS", "SLICES"]} }, "required": ["shape"] } }, { "name": "Oven.bake", "returns": "Fries", "description": "Bakes something in the oven", "argsSchema": { "type": "object", "properties": { "item": {"type": "string", "description": "The item to bake", "$dagql.type": "Potato"} }, "required": ["item"] } }, { "name": "Fries.plate", "returns": "Plate", "description": "Places fries on a plate for serving", "argsSchema": { "type": "object", "properties": { "plate": {"type": "string", "description": "The plate to use", "$dagql.type": "Plate"} }, "required": ["plate"] } } ] }} ``` </user> <assistant> Now I'll start preparing the french fries. First, I need to rinse the potato: </assistant> <user> ```json {"result": "Potato#2"} ``` </user> <assistant> Next, I'll peel the rinsed potato: </assistant> <user> ```json {"result": "Potato#3"} ``` </user> <assistant> Now I'll slice the potato into fry shapes: </assistant> <user> ```json {"result": "Potato#4"} ``` </user> <assistant> Now I'll bake the sliced potato to make french fries: </assistant> <user> ```json {"result": "Fries#1"} ``` </user> <assistant> Finally, I'll plate the fries for serving: </assistant> <user> ```json {"result": "Plate#2"} ``` </user> <assistant> I see there's a save tool available. Let me save the plated fries as the output: </assistant> <user> ``` Success! The french fries have been prepared and served on the plate. ``` </user> <assistant> Great! I've successfully prepared the french fries for you. The process involved: </assistant> </example>