deepagents 0.0.0 → 0.0.2

package/README.md

@@ -7,145 +7,12 @@ Using an LLM to call tools in a loop is the simplest form of an agent. This arch
 > ![TIP]
 > Looking for the Python version of this package? See [here: hwchase17/deepagents](https://github.com/hwchase17/deepagents)
 
-**Acknowledgements**: This project was primarily inspired by Claude Code, and initially was largely an attempt to see what made Claude Code general purpose, and make it even more so.
-
 ## Installation
 
 ```bash
-yarn add deepagentsjs
-```
-
-## Usage
-
-(To run the example below, you will need to install tavily: `yarn add @langchain/tavily`)
-
-```typescript
-import { TavilySearch } from "@langchain/tavily";
-import { createDeepAgent } from "deepagentsjs";
-
-// Search tool to use to do research
-const internetSearch = new TavilySearch({
-  maxResults: 5,
-  tavilyApiKey: process.env.TAVILY_API_KEY,
-});
-
-// Prompt prefix to steer the agent to be an expert researcher
-const researchInstructions = `You are an expert researcher. Your job is to conduct thorough research, and then write a polished report.
-
-You have access to a few tools.
-
-## \`internet_search\`
-
-Use this to run an internet search for a given query. You can specify the number of results, the topic, and whether raw content should be included.
-`;
-
-// Create the agent
-const agent = createDeepAgent({
-  tools: [internetSearch],
-  instructions: researchInstructions,
-});
-
-// Invoke the agent
-const result = await agent.invoke({
-  messages: [{ role: "user", content: "what is langgraph?" }]
-});
-```
-
-See `examples/research-agent.ts` for a more complex example.
-
-The agent created with `createDeepAgent` is just a LangGraph graph - so you can interact with it (streaming, human-in-the-loop, memory, studio) in the same way you would any LangGraph agent.
-
-## Creating a custom deep agent
-
-There are three parameters you can pass to `createDeepAgent` to create your own custom deep agent.
-
-### tools (Required)
-
-The first argument to `createDeepAgent` is tools. This should be a list of LangChain tools. The agent (and any subagents) will have access to these tools.
-
-### instructions (Required)
-
-The second argument to `createDeepAgent` is instructions. This will serve as part of the prompt of the deep agent. Note that there is a built in system prompt as well, so this is not the entire prompt the agent will see.
-
-### subagents (Optional)
-
-A keyword-only argument to `createDeepAgent` is subagents. This can be used to specify any custom subagents this deep agent will have access to. You can read more about why you would want to use subagents [here](https://langchain-ai.github.io/deepagents/subagents/)
-
-`subagents` should be a list of objects, where each object follows this schema:
-
-```typescript
-interface SubAgent {
-  name: string;
-  description: string;
-  prompt: string;
-  tools?: string[];
-}
+yarn add deepagents
 ```
 
-- **name**: This is the name of the subagent, and how the main agent will call the subagent
-- **description**: This is the description of the subagent that is shown to the main agent
-- **prompt**: This is the prompt used for the subagent
-- **tools**: This is the list of tools that the subagent has access to. By default will have access to all tools passed in, as well as all built-in tools.
-
-To use it looks like:
-
-```typescript
-const researchSubAgent = {
-  name: "research-agent",
-  description: "Used to research more in depth questions",
-  prompt: subResearchPrompt,
-};
-
-const subagents = [researchSubAgent];
-
-const agent = createDeepAgent({
-  tools,
-  instructions: prompt,
-  subagents
-});
-```
-
-### model (Optional)
-
-By default, `deepagents` will use "claude-sonnet-4-20250514". If you want to use a different model, you can pass a LangChain model object.
-
-## Deep Agent Details
-
-The below components are built into `deepagents` and helps make it work for deep tasks off-the-shelf.
-
-### System Prompt
-
-`deepagents` comes with a built-in system prompt. This is relatively detailed prompt that is heavily based on and inspired by attempts to replicate Claude Code's system prompt. It was made more general purpose than Claude Code's system prompt. This contains detailed instructions for how to use the built-in planning tool, file system tools, and sub agents. Note that part of this system prompt can be customized
-
-Without this default system prompt - the agent would not be nearly as successful at going as it is. The importance of prompting for creating a "deep" agent cannot be understated.
-
-### Planning Tool
-
-`deepagents` comes with a built-in planning tool. This planning tool is very simple and is based on ClaudeCode's TodoWrite tool. This tool doesn't actually do anything - it is just a way for the agent to come up with a plan, and then have that in the context to help keep it on track.
-
-### File System Tools
-
-`deepagents` comes with four built-in file system tools: `ls`, `edit_file`, `read_file`, `write_file`. These do not actually use a file system - rather, they mock out a file system using LangGraph's State object. This means you can easily run many of these agents on the same machine without worrying that they will edit the same underlying files.
-
-Right now the "file system" will only be one level deep (no sub directories).
-
-These files can be passed in (and also retrieved) by using the `files` key in the LangGraph State object.
-
-```typescript
-const agent = createDeepAgent({ ... });
-
-const result = await agent.invoke({
-  messages: [...],
-  // Pass in files to the agent using this key
-  // files: {"foo.txt": "foo", ...}
-});
-
-// Access any files afterwards like this
-result.files;
-```
-
-### Sub Agents
-
-`deepagents` comes with the built-in ability to call sub agents (based on Claude Code). It has access to a general-purpose subagent at all times - this is a subagent with the same instructions as the main agent and all the tools that is has access to. You can also specify custom sub agents with their own instructions and tools.
+## Learn more
 
-Sub agents are useful for "context quarantine" (to help not pollute the overall context of the main agent) as well as custom instructions.
+For more information, check out our docs: [https://docs.langchain.com/labs/deep-agents/overview](https://docs.langchain.com/labs/deep-agents/overview)

package/dist/graph.d.ts

@@ -6,16 +6,17 @@
  * provided tools, creates task tool using createTaskTool(), and returns createReactAgent
  * with proper configuration. Ensures exact parameter matching and behavior with Python version.
  */
-import "@langchain/anthropic/zod";
-import type { CreateDeepAgentParams } from "./types.js";
+import { InteropZodObject } from "@langchain/core/utils/types";
+import type { AnyAnnotationRoot, CreateDeepAgentParams } from "./types.js";
 import { z } from "zod";
 /**
  * Create a Deep Agent with TypeScript types for all parameters.
  * Combines built-in tools with provided tools, creates task tool using createTaskTool(),
  * and returns createReactAgent with proper configuration.
  * Ensures exact parameter matching and behavior with Python version.
+ *
  */
-export declare function createDeepAgent<StateSchema extends z.ZodObject<any, any, any, any, any>>(params?: CreateDeepAgentParams<StateSchema>): import("@langchain/langgraph").CompiledStateGraph<import("@langchain/langgraph").StateType<import("@langchain/langgraph/zod").InteropZodToStateDefinition<z.ZodObject<{
+export declare function createDeepAgent<StateSchema extends z.ZodObject<any, any, any, any, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params?: CreateDeepAgentParams<StateSchema, ContextSchema>): import("@langchain/langgraph").CompiledStateGraph<import("@langchain/langgraph").StateType<import("@langchain/langgraph/zod").InteropZodToStateDefinition<z.ZodObject<{
     messages: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<import("@langchain/core/messages").BaseMessage[], z.ZodTypeDef, import("@langchain/core/messages").BaseMessage[]>, import("@langchain/core/utils/types").InteropZodType<import("@langchain/langgraph").Messages>>;
 } & {
     todos: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<import("./types.js").Todo[], z.ZodTypeDef, import("./types.js").Todo[]>, import("@langchain/core/utils/types").InteropZodType<import("./types.js").Todo[] | null | undefined>>;
@@ -124,4 +125,4 @@ export declare function createDeepAgent<StateSchema extends z.ZodObject<any, any
     [x: string]: any;
 }>, {
     [x: string]: any;
-}>), import("@langchain/langgraph").StateDefinition>;
+}>), import("@langchain/langgraph").StateDefinition, unknown>;

package/dist/graph.js

@@ -6,12 +6,28 @@
  * provided tools, creates task tool using createTaskTool(), and returns createReactAgent
  * with proper configuration. Ensures exact parameter matching and behavior with Python version.
  */
-import "@langchain/anthropic/zod";
+// import "@langchain/anthropic/zod";
 import { createReactAgent } from "@langchain/langgraph/prebuilt";
 import { createTaskTool } from "./subAgent.js";
 import { getDefaultModel } from "./model.js";
 import { writeTodos, readFile, writeFile, editFile, ls } from "./tools.js";
 import { DeepAgentState } from "./state.js";
+import { createInterruptHook } from "./interrupt.js";
+/**
+ * Base prompt that provides instructions about available tools
+ * Ported from Python implementation to ensure consistent behavior
+ */
+const BASE_PROMPT = `You have access to a number of standard tools
+
+## \`write_todos\`
+
+You have access to the \`write_todos\` tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
+These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
+
+It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
+## \`task\`
+
+- When doing web search, prefer to use the \`task\` tool in order to reduce context usage.`;
 /**
  * Built-in tools that are always available in Deep Agents
  */
@@ -27,14 +43,19 @@ const BUILTIN_TOOLS = [
  * Combines built-in tools with provided tools, creates task tool using createTaskTool(),
  * and returns createReactAgent with proper configuration.
  * Ensures exact parameter matching and behavior with Python version.
+ *
  */
 export function createDeepAgent(params = {}) {
-    const { tools = [], instructions, model = getDefaultModel(), subagents = [], } = params;
+    const { tools = [], instructions, model = getDefaultModel(), subagents = [], postModelHook, contextSchema, interruptConfig = {}, builtinTools, } = params;
     const stateSchema = params.stateSchema
         ? DeepAgentState.extend(params.stateSchema.shape)
         : DeepAgentState;
+    // Filter built-in tools if builtinTools parameter is provided
+    const selectedBuiltinTools = builtinTools
+        ? BUILTIN_TOOLS.filter((tool) => builtinTools.some((bt) => bt === tool.name))
+        : BUILTIN_TOOLS;
     // Combine built-in tools with provided tools
-    const allTools = [...BUILTIN_TOOLS, ...tools];
+    const allTools = [...selectedBuiltinTools, ...tools];
     // Create task tool using createTaskTool() if subagents are provided
     if (subagents.length > 0) {
         // Create tools map for task tool creation
@@ -52,11 +73,32 @@ export function createDeepAgent(params = {}) {
         });
         allTools.push(taskTool);
     }
+    // Combine instructions with base prompt like Python implementation
+    const finalInstructions = instructions
+        ? instructions + BASE_PROMPT
+        : BASE_PROMPT;
+    // Should never be the case that both are specified
+    if (postModelHook && Object.keys(interruptConfig).length > 0) {
+        throw new Error("Cannot specify both postModelHook and interruptConfig together. " +
+            "Use either interruptConfig for tool interrupts or postModelHook for custom post-processing.");
+    }
+    let selectedPostModelHook;
+    if (postModelHook !== undefined) {
+        selectedPostModelHook = postModelHook;
+    }
+    else if (Object.keys(interruptConfig).length > 0) {
+        selectedPostModelHook = createInterruptHook(interruptConfig);
+    }
+    else {
+        selectedPostModelHook = undefined;
+    }
     // Return createReactAgent with proper configuration
     return createReactAgent({
         llm: model,
         tools: allTools,
         stateSchema,
-        messageModifier: instructions,
+        messageModifier: finalInstructions,
+        contextSchema,
+        postModelHook: selectedPostModelHook,
     });
 }

package/dist/interrupt.d.ts

@@ -0,0 +1,2 @@
+import type { DeepAgentStateType, ToolInterruptConfig } from "./types.js";
+export declare function createInterruptHook(toolConfigs: ToolInterruptConfig, messagePrefix?: string): (state: DeepAgentStateType) => Promise<Partial<DeepAgentStateType> | void>;

package/dist/interrupt.js

@@ -0,0 +1,103 @@
+import { interrupt } from "@langchain/langgraph";
+import { isAIMessage, AIMessage, ToolMessage } from "@langchain/core/messages";
+export function createInterruptHook(toolConfigs, messagePrefix = "Tool execution requires approval") {
+    /**
+     * Create a post model hook that handles interrupts using native LangGraph schemas.
+     *
+     * Args:
+     *   toolConfigs: Record mapping tool names to HumanInterruptConfig objects
+     *   messagePrefix: Optional message prefix for interrupt descriptions
+     */
+    Object.entries(toolConfigs).forEach(([tool, interruptConfig]) => {
+        if (interruptConfig &&
+            typeof interruptConfig === "object" &&
+            interruptConfig.allow_ignore) {
+            throw new Error(`For ${tool} we get allow_ignore = true - we currently don't support ignore.`);
+        }
+    });
+    return async function interruptHook(state) {
+        const messages = state.messages || [];
+        if (!messages.length) {
+            return;
+        }
+        const lastMessage = messages[messages.length - 1];
+        if (!isAIMessage(lastMessage) ||
+            !lastMessage.tool_calls ||
+            !lastMessage.tool_calls.length) {
+            return;
+        }
+        const interruptToolCalls = [];
+        const autoApprovedToolCalls = [];
+        for (const toolCall of lastMessage.tool_calls) {
+            const toolName = toolCall.name;
+            if (toolName in toolConfigs) {
+                interruptToolCalls.push(toolCall);
+            }
+            else {
+                autoApprovedToolCalls.push(toolCall);
+            }
+        }
+        if (!interruptToolCalls.length) {
+            return;
+        }
+        const approvedToolCalls = [...autoApprovedToolCalls];
+        if (interruptToolCalls.length > 1) {
+            throw new Error("Right now, interrupt hook only works when one tool requires interrupts");
+        }
+        const toolCall = interruptToolCalls[0];
+        const toolName = toolCall.name;
+        const toolArgs = toolCall.args;
+        const description = `${messagePrefix}\n\nTool: ${toolName}\nArgs: ${JSON.stringify(toolArgs, null, 2)}`;
+        const toolConfig = toolConfigs[toolName];
+        const defaultToolConfig = {
+            allow_accept: true,
+            allow_edit: true,
+            allow_respond: true,
+            allow_ignore: false,
+        };
+        const request = {
+            action_request: {
+                action: toolName,
+                args: toolArgs,
+            },
+            config: typeof toolConfig === "object" ? toolConfig : defaultToolConfig,
+            description: description,
+        };
+        const res = await interrupt([request]);
+        const responses = Array.isArray(res) ? res : [res];
+        if (responses.length !== 1) {
+            throw new Error(`Expected a list of one response, got ${responses}`);
+        }
+        const response = responses[0];
+        if (response.type === "accept") {
+            approvedToolCalls.push(toolCall);
+        }
+        else if (response.type === "edit") {
+            const edited = response.args;
+            const newToolCall = {
+                name: edited.action,
+                args: edited.args,
+                id: toolCall.id,
+            };
+            approvedToolCalls.push(newToolCall);
+        }
+        else if (response.type === "response") {
+            if (!toolCall.id) {
+                throw new Error("Tool call must have an ID for response type");
+            }
+            const responseMessage = new ToolMessage({
+                tool_call_id: toolCall.id,
+                content: response.args,
+            });
+            return { messages: [responseMessage] };
+        }
+        else {
+            throw new Error(`Unknown response type: ${response.type}`);
+        }
+        const updatedLastMessage = new AIMessage({
+            ...lastMessage,
+            tool_calls: approvedToolCalls,
+        });
+        return { messages: [updatedLastMessage] };
+    };
+}

package/dist/subAgent.d.ts

@@ -22,20 +22,20 @@ export declare function createTaskTool<StateSchema extends z.ZodObject<any, any,
     model: LanguageModelLike;
     stateSchema: StateSchema;
 }): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
-    agent_name: z.ZodString;
-    task: z.ZodString;
+    description: z.ZodString;
+    subagent_type: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    agent_name: string;
-    task: string;
+    description: string;
+    subagent_type: string;
 }, {
-    agent_name: string;
-    task: string;
+    description: string;
+    subagent_type: string;
 }>, {
-    agent_name: string;
-    task: string;
+    description: string;
+    subagent_type: string;
 }, {
-    agent_name: string;
-    task: string;
+    description: string;
+    subagent_type: string;
 }, string | Command<unknown, {
     messages: ToolMessage[];
 }, string>>;

package/dist/subAgent.js

@@ -13,6 +13,7 @@ import { createReactAgent } from "@langchain/langgraph/prebuilt";
 import { z } from "zod";
 import { getDefaultModel } from "./model.js";
 import { writeTodos, readFile, writeFile, editFile, ls } from "./tools.js";
+import { TASK_DESCRIPTION_PREFIX, TASK_DESCRIPTION_SUFFIX } from "./prompts.js";
 /**
  * Built-in tools map for tool resolution by name
  */
@@ -30,20 +31,11 @@ const BUILTIN_TOOLS = {
  */
 export function createTaskTool(inputs) {
     const { subagents, tools = {}, model = getDefaultModel(), stateSchema, } = inputs;
-    // Create agents map from subagents array
-    const agentsMap = new Map();
-    for (const subagent of subagents) {
-        agentsMap.set(subagent.name, subagent);
-    }
     // Combine built-in tools with provided tools for tool resolution
     const allTools = { ...BUILTIN_TOOLS, ...tools };
-    return tool(async (input, config) => {
-        const { agent_name, task } = input;
-        // Get the subagent configuration
-        const subagent = agentsMap.get(agent_name);
-        if (!subagent) {
-            return `Error: Agent '${agent_name}' not found. Available agents: ${Array.from(agentsMap.keys()).join(", ")}`;
-        }
+    // Pre-create all agents like Python does
+    const agentsMap = new Map();
+    for (const subagent of subagents) {
         // Resolve tools by name for this subagent
         const subagentTools = [];
         if (subagent.tools) {
@@ -54,37 +46,53 @@ export function createTaskTool(inputs) {
                 }
                 else {
                     // eslint-disable-next-line no-console
-                    console.warn(`Warning: Tool '${toolName}' not found for agent '${agent_name}'`);
+                    console.warn(`Warning: Tool '${toolName}' not found for agent '${subagent.name}'`);
                 }
             }
         }
+        else {
+            // If no tools specified, use all tools like Python does
+            subagentTools.push(...Object.values(allTools));
+        }
+        // Create react agent for the subagent (pre-create like Python)
+        const reactAgent = createReactAgent({
+            llm: model,
+            tools: subagentTools,
+            stateSchema,
+            messageModifier: subagent.prompt,
+        });
+        agentsMap.set(subagent.name, reactAgent);
+    }
+    return tool(async (input, config) => {
+        const { description, subagent_type } = input;
+        // Get the pre-created agent
+        const reactAgent = agentsMap.get(subagent_type);
+        if (!reactAgent) {
+            return `Error: Agent '${subagent_type}' not found. Available agents: ${Array.from(agentsMap.keys()).join(", ")}`;
+        }
         try {
-            // Create react agent for the subagent
-            const reactAgent = createReactAgent({
-                llm: model,
-                tools: subagentTools,
-                stateSchema,
-                messageModifier: subagent.prompt,
-            });
             // Get current state for context
             const currentState = getCurrentTaskInput();
-            // Execute the subagent with the task
-            const result = await reactAgent.invoke({
+            // Modify state messages like Python does
+            const modifiedState = {
                 ...currentState,
                 messages: [
                     {
                         role: "user",
-                        content: task,
+                        content: description,
                     },
                 ],
-            }, config);
+            };
+            // Execute the subagent with the task
+            const result = await reactAgent.invoke(modifiedState, config);
             // Use Command for state updates and navigation between agents
+            // Return the result using Command to properly handle subgraph state
             return new Command({
                 update: {
-                    ...result,
+                    files: result.files || {},
                     messages: [
                         new ToolMessage({
-                            content: `Completed task '${task}' using agent '${agent_name}'. Result: ${JSON.stringify(result.messages?.slice(-1)[0]?.content || "Task completed")}`,
+                            content: result.messages?.slice(-1)[0]?.content || "Task completed",
                             tool_call_id: config.toolCall?.id,
                         }),
                     ],
@@ -98,7 +106,7 @@ export function createTaskTool(inputs) {
                 update: {
                     messages: [
                         new ToolMessage({
-                            content: `Error executing task '${task}' with agent '${agent_name}': ${errorMessage}`,
+                            content: `Error executing task '${description}' with agent '${subagent_type}': ${errorMessage}`,
                             tool_call_id: config.toolCall?.id,
                         }),
                     ],
@@ -107,14 +115,14 @@ export function createTaskTool(inputs) {
         }
     }, {
         name: "task",
-        description: `Execute a task using a specialized sub-agent. Available agents: ${subagents.map((a) => `${a.name} - ${a.description}`).join("; ")}`,
+        description: TASK_DESCRIPTION_PREFIX.replace("{other_agents}", subagents.map((a) => `- ${a.name}: ${a.description}`).join("\n")) + TASK_DESCRIPTION_SUFFIX,
         schema: z.object({
-            agent_name: z
-                .string()
-                .describe(`Name of the agent to use. Available: ${subagents.map((a) => a.name).join(", ")}`),
-            task: z
+            description: z
                 .string()
                 .describe("The task to execute with the selected agent"),
+            subagent_type: z
+                .string()
+                .describe(`Name of the agent to use. Available: ${subagents.map((a) => a.name).join(", ")}`),
         }),
     });
 }

package/dist/tools.d.ts

@@ -43,15 +43,13 @@ export declare const writeTodos: import("@langchain/core/tools").DynamicStructur
         status: "pending" | "in_progress" | "completed";
         content: string;
     }[];
-}, {
-    update: {
-        todos: {
-            status: "pending" | "in_progress" | "completed";
-            content: string;
-        }[];
-        messages: ToolMessage[];
-    };
-}>;
+}, Command<unknown, {
+    todos: {
+        status: "pending" | "in_progress" | "completed";
+        content: string;
+    }[];
+    messages: ToolMessage[];
+}, string>>;
 /**
  * List files tool - returns list of files from state.files
  * Equivalent to Python's ls function

package/dist/tools.js

@@ -15,7 +15,7 @@ import { WRITE_TODOS_DESCRIPTION, EDIT_DESCRIPTION, TOOL_DESCRIPTION, } from "./
  * Uses getCurrentTaskInput() instead of Python's InjectedState
  */
 export const writeTodos = tool((input, config) => {
-    return {
+    return new Command({
         update: {
             todos: input.todos,
             messages: [
@@ -25,7 +25,7 @@ export const writeTodos = tool((input, config) => {
                 }),
             ],
         },
-    };
+    });
 }, {
     name: "write_todos",
     description: WRITE_TODOS_DESCRIPTION,

package/dist/types.d.ts

@@ -11,6 +11,10 @@ import type { StructuredTool } from "@langchain/core/tools";
 import type { DeepAgentState } from "./state.js";
 import { z } from "zod";
 import { Runnable } from "@langchain/core/runnables";
+import { AnnotationRoot } from "@langchain/langgraph";
+import { InteropZodObject } from "@langchain/core/utils/types";
+import type { HumanInterruptConfig } from "@langchain/langgraph/prebuilt";
+export type AnyAnnotationRoot = AnnotationRoot<any>;
 export type InferZodObjectShape<T> = T extends z.ZodObject<infer Shape> ? Shape : never;
 /**
  * SubAgent interface matching Python's TypedDict structure
@@ -28,19 +32,19 @@ export interface Todo {
 }
 export type DeepAgentStateType = z.infer<typeof DeepAgentState>;
 export type LanguageModelLike = Runnable<BaseLanguageModelInput, LanguageModelOutput>;
-/**
- * Parameters for createDeepAgent function with TypeScript types
- */
-export interface CreateDeepAgentParams<StateSchema extends z.ZodObject<any, any, any, any, any>> {
+export type PostModelHook = (state: DeepAgentStateType, model: LanguageModelLike) => Promise<Partial<DeepAgentStateType> | void>;
+export type ToolInterruptConfig = Record<string, HumanInterruptConfig | boolean>;
+export interface CreateDeepAgentParams<StateSchema extends z.ZodObject<any, any, any, any, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> {
     tools?: StructuredTool[];
     instructions?: string;
     model?: LanguageModelLike;
     subagents?: SubAgent[];
     stateSchema?: StateSchema;
+    contextSchema?: ContextSchema;
+    postModelHook?: PostModelHook;
+    interruptConfig?: ToolInterruptConfig;
+    builtinTools?: string[];
 }
-/**
- * Parameters for createTaskTool function
- */
 export interface CreateTaskToolParams<StateSchema extends z.ZodObject<any, any, any, any, any>> {
     subagents: SubAgent[];
     tools?: Record<string, StructuredTool>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepagents",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "Deep Agents - a library for building controllable AI agents with LangGraph",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -41,7 +41,7 @@
   "dependencies": {
     "@langchain/anthropic": "^0.3.25",
     "@langchain/core": "^0.3.66",
-    "@langchain/langgraph": "^0.4.2",
+    "@langchain/langgraph": "^0.4.6",
     "zod": "^3.25.32"
   },
   "devDependencies": {