deepagents 0.0.1 → 0.0.2

package/dist/graph.d.ts

@@ -6,15 +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 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>>;
@@ -123,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

@@ -12,6 +12,7 @@ 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
@@ -42,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
@@ -71,11 +77,28 @@ export function createDeepAgent(params = {}) {
     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: 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/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.1",
+  "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": {