deepagents 0.0.0

package/dist/tools.js

@@ -0,0 +1,205 @@
+/**
+ * Tool functions for Deep Agents
+ *
+ * TypeScript versions of all tools using @langchain/core/tools tool() function.
+ * Uses getCurrentTaskInput() for state access and returns Command objects for state updates.
+ * Implements mock filesystem operations using state.files similar to Python version.
+ */
+import { tool } from "@langchain/core/tools";
+import { ToolMessage } from "@langchain/core/messages";
+import { Command, getCurrentTaskInput } from "@langchain/langgraph";
+import { z } from "zod";
+import { WRITE_TODOS_DESCRIPTION, EDIT_DESCRIPTION, TOOL_DESCRIPTION, } from "./prompts.js";
+/**
+ * Write todos tool - manages todo list with Command return
+ * Uses getCurrentTaskInput() instead of Python's InjectedState
+ */
+export const writeTodos = tool((input, config) => {
+    return {
+        update: {
+            todos: input.todos,
+            messages: [
+                new ToolMessage({
+                    content: `Updated todo list to ${JSON.stringify(input.todos)}`,
+                    tool_call_id: config.toolCall?.id,
+                }),
+            ],
+        },
+    };
+}, {
+    name: "write_todos",
+    description: WRITE_TODOS_DESCRIPTION,
+    schema: z.object({
+        todos: z
+            .array(z.object({
+            content: z.string().describe("Content of the todo item"),
+            status: z
+                .enum(["pending", "in_progress", "completed"])
+                .describe("Status of the todo"),
+        }))
+            .describe("List of todo items to update"),
+    }),
+});
+/**
+ * List files tool - returns list of files from state.files
+ * Equivalent to Python's ls function
+ */
+export const ls = tool(() => {
+    const state = getCurrentTaskInput();
+    const files = state.files || {};
+    return Object.keys(files);
+}, {
+    name: "ls",
+    description: "List all files in the mock filesystem",
+    schema: z.object({}),
+});
+/**
+ * Read file tool - reads from mock filesystem in state.files
+ * Matches Python read_file function behavior exactly
+ */
+export const readFile = tool((input) => {
+    const state = getCurrentTaskInput();
+    const mockFilesystem = state.files || {};
+    const { file_path, offset = 0, limit = 2000 } = input;
+    if (!(file_path in mockFilesystem)) {
+        return `Error: File '${file_path}' not found`;
+    }
+    // Get file content
+    const content = mockFilesystem[file_path];
+    // Handle empty file
+    if (!content || content.trim() === "") {
+        return "System reminder: File exists but has empty contents";
+    }
+    // Split content into lines
+    const lines = content.split("\n");
+    // Apply line offset and limit
+    const startIdx = offset;
+    const endIdx = Math.min(startIdx + limit, lines.length);
+    // Handle case where offset is beyond file length
+    if (startIdx >= lines.length) {
+        return `Error: Line offset ${offset} exceeds file length (${lines.length} lines)`;
+    }
+    // Format output with line numbers (cat -n format)
+    const resultLines = [];
+    for (let i = startIdx; i < endIdx; i++) {
+        let lineContent = lines[i];
+        // Truncate lines longer than 2000 characters
+        if (lineContent.length > 2000) {
+            lineContent = lineContent.substring(0, 2000);
+        }
+        // Line numbers start at 1, so add 1 to the index
+        const lineNumber = i + 1;
+        resultLines.push(`${lineNumber.toString().padStart(6)}	${lineContent}`);
+    }
+    return resultLines.join("\n");
+}, {
+    name: "read_file",
+    description: TOOL_DESCRIPTION,
+    schema: z.object({
+        file_path: z.string().describe("Absolute path to the file to read"),
+        offset: z
+            .number()
+            .optional()
+            .default(0)
+            .describe("Line offset to start reading from"),
+        limit: z
+            .number()
+            .optional()
+            .default(2000)
+            .describe("Maximum number of lines to read"),
+    }),
+});
+/**
+ * Write file tool - writes to mock filesystem with Command return
+ * Matches Python write_file function behavior exactly
+ */
+export const writeFile = tool((input, config) => {
+    const state = getCurrentTaskInput();
+    const files = { ...(state.files || {}) };
+    files[input.file_path] = input.content;
+    return new Command({
+        update: {
+            files: files,
+            messages: [
+                new ToolMessage({
+                    content: `Updated file ${input.file_path}`,
+                    tool_call_id: config.toolCall?.id,
+                }),
+            ],
+        },
+    });
+}, {
+    name: "write_file",
+    description: "Write content to a file in the mock filesystem",
+    schema: z.object({
+        file_path: z.string().describe("Absolute path to the file to write"),
+        content: z.string().describe("Content to write to the file"),
+    }),
+});
+/**
+ * Edit file tool - edits files in mock filesystem with Command return
+ * Matches Python edit_file function behavior exactly
+ */
+export const editFile = tool((input, config) => {
+    const state = getCurrentTaskInput();
+    const mockFilesystem = { ...(state.files || {}) };
+    const { file_path, old_string, new_string, replace_all = false } = input;
+    // Check if file exists in mock filesystem
+    if (!(file_path in mockFilesystem)) {
+        return `Error: File '${file_path}' not found`;
+    }
+    // Get current file content
+    const content = mockFilesystem[file_path];
+    // Check if old_string exists in the file
+    if (!content.includes(old_string)) {
+        return `Error: String not found in file: '${old_string}'`;
+    }
+    // If not replace_all, check for uniqueness
+    if (!replace_all) {
+        const escapedOldString = old_string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const occurrences = (content.match(new RegExp(escapedOldString, "g")) || []).length;
+        if (occurrences > 1) {
+            return `Error: String '${old_string}' appears ${occurrences} times in file. Use replace_all=True to replace all instances, or provide a more specific string with surrounding context.`;
+        }
+        else if (occurrences === 0) {
+            return `Error: String not found in file: '${old_string}'`;
+        }
+    }
+    // Perform the replacement
+    let newContent;
+    if (replace_all) {
+        const escapedOldString = old_string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        newContent = content.replace(new RegExp(escapedOldString, "g"), new_string);
+    }
+    else {
+        newContent = content.replace(old_string, new_string);
+    }
+    // Update the mock filesystem
+    mockFilesystem[file_path] = newContent;
+    return new Command({
+        update: {
+            files: mockFilesystem,
+            messages: [
+                new ToolMessage({
+                    content: `Updated file ${file_path}`,
+                    tool_call_id: config.toolCall?.id,
+                }),
+            ],
+        },
+    });
+}, {
+    name: "edit_file",
+    description: EDIT_DESCRIPTION,
+    schema: z.object({
+        file_path: z.string().describe("Absolute path to the file to edit"),
+        old_string: z
+            .string()
+            .describe("String to be replaced (must match exactly)"),
+        new_string: z.string().describe("String to replace with"),
+        replace_all: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Whether to replace all occurrences"),
+    }),
+});

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * TypeScript type definitions for Deep Agents
+ *
+ * This file contains all the TypeScript interfaces and types that correspond
+ * to the Python TypedDict and other type definitions. Defines all necessary
+ * TypeScript interfaces and types including StateSchemaType, SubAgent, Todo,
+ * and proper generic types for state schemas.
+ */
+import type { BaseLanguageModelInput, LanguageModelOutput } from "@langchain/core/language_models/base";
+import type { StructuredTool } from "@langchain/core/tools";
+import type { DeepAgentState } from "./state.js";
+import { z } from "zod";
+import { Runnable } from "@langchain/core/runnables";
+export type InferZodObjectShape<T> = T extends z.ZodObject<infer Shape> ? Shape : never;
+/**
+ * SubAgent interface matching Python's TypedDict structure
+ */
+export interface SubAgent {
+    name: string;
+    description: string;
+    prompt: string;
+    tools?: string[];
+}
+export type TodoStatus = "pending" | "in_progress" | "completed";
+export interface Todo {
+    content: string;
+    status: TodoStatus;
+}
+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>> {
+    tools?: StructuredTool[];
+    instructions?: string;
+    model?: LanguageModelLike;
+    subagents?: SubAgent[];
+    stateSchema?: StateSchema;
+}
+/**
+ * Parameters for createTaskTool function
+ */
+export interface CreateTaskToolParams<StateSchema extends z.ZodObject<any, any, any, any, any>> {
+    subagents: SubAgent[];
+    tools?: Record<string, StructuredTool>;
+    model?: LanguageModelLike;
+    stateSchema?: StateSchema;
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+/**
+ * TypeScript type definitions for Deep Agents
+ *
+ * This file contains all the TypeScript interfaces and types that correspond
+ * to the Python TypedDict and other type definitions. Defines all necessary
+ * TypeScript interfaces and types including StateSchemaType, SubAgent, Todo,
+ * and proper generic types for state schemas.
+ */
+export {};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "deepagents",
+  "version": "0.0.0",
+  "description": "Deep Agents - a library for building controllable AI agents with LangGraph",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "yarn clean && tsc",
+    "build:examples": "yarn clean && tsc -p examples.tsconfig.json",
+    "build:watch": "tsc --watch",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist dist-examples || true",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/**/*.ts examples/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts examples/**/*.ts --fix",
+    "format": "prettier --write \"src/**/*.{ts,js,json,md}\" \"examples/**/*.{ts,js,json,md}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,js,json,md}\" \"examples/**/*.{ts,js,json,md}\"",
+    "prepublishOnly": "yarn build",
+    "test": "echo \"Error: no test specified\" && exit 0",
+    "start": "node dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/langchain-ai/deepagentsjs.git"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "langgraph",
+    "langchain",
+    "typescript",
+    "llm"
+  ],
+  "author": "LangChain",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/langchain-ai/deepagentsjs/issues"
+  },
+  "homepage": "https://github.com/langchain-ai/deepagentsjs#readme",
+  "dependencies": {
+    "@langchain/anthropic": "^0.3.25",
+    "@langchain/core": "^0.3.66",
+    "@langchain/langgraph": "^0.4.2",
+    "zod": "^3.25.32"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.19.0",
+    "@langchain/tavily": "^0.1.4",
+    "@tsconfig/recommended": "^1.0.8",
+    "@types/node": "^22.13.5",
+    "dotenv": "^17.2.1",
+    "eslint": "^9.19.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-no-instanceof": "^1.0.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "globals": "^15.0.0",
+    "prettier": "^3.6.2",
+    "typescript": "^5",
+    "typescript-eslint": "^8.22.0"
+  },
+  "resolutions": {
+    "@langchain/langgraph": ">=0.2.53",
+    "@langchain/core": ">=0.3.0"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "packageManager": "yarn@1.22.22"
+}