deepagents 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Oleksandr Shevtsov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+## This is an unofficial port of the [hwchase17/deepagents](https://github.com/hwchase17/deepagents) Python package to TypeScript
+
+# 🧠🤖Deep Agents
+
+Using an LLM to call tools in a loop is the simplest form of an agent.
+This architecture, however, can yield agents that are “shallow” and fail to plan and act over longer, more complex tasks.
+Applications like “Deep Research”, "Manus", and “Claude Code” have gotten around this limitation by implementing a combination of four things:
+a **planning tool**, **sub agents**, access to a **file system**, and a **detailed prompt**.
+
+<img src="deep_agents.png" alt="deep agent" width="600"/>
+
+`deepagents` is a Typescript package that implements these in a general purpose way so that you can easily create a Deep Agent for your application.
+
+**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
+npm install deepagents
+```
+
+## Usage
+
+> NB! This part of documentation is not fully migrated
+
+See [src/examples/research/agent.ts](src/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 is an option argument with three properties you can pass to `createDeepAgent` to create your own custom deep agent.
+
+### `tools` (Required)
+
+This should be a list of functions or LangChain `@tool` objects.
+The agent (and any subagents) will have access to these tools.
+
+### `instructions` (Required)
+
+This will serve as part of the prompt of the deep agent.
+Note that there is a [built in system prompt](#built-in-prompt) as well, so this is not the _entire_ prompt the agent will see.
+
+### `subagents` (Optional)
+
+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](#sub-agents)
+`subagents` should be a list of dictionaries, where each dictionary follow this schema:
+
+```js
+export interface SubAgent {
+    name: string;
+    description: string;
+    prompt: string;
+    tools?: string[];
+}
+```
+
+-   **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:
+
+```js
+import { createDeepAgent, SubAgent } from "deepagents";
+
+const researchSubAgent: SubAgent = {
+    name: "research-agent",
+    description: "Used to research more in depth questions...",
+    prompt: subResearchPrompt,
+    tools: ["internet_search"],
+};
+const agent = createDeepAgent({
+    instructions: researchInstructions,
+    subagents: [researchSubAgent],
+    tools: [internetSearch],
+});
+```
+
+### `model` (Optional)
+
+By default, `deepagents` will use local LM Studio. If you want to use a different model,
+you can pass a [LangChain model object](https://js.langchain.com/docs/integrations/chat/).
+
+## 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](src/prompts.ts). This is relatively detailed prompt that is heavily based on and inspired by [attempts](https://github.com/kn1026/cc/blob/main/claudecode.md) to [replicate](https://github.com/asgeirtj/system_prompts_leaks/blob/main/Anthropic/claude-code.md)
+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](#promptprefix--required-)
+
+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.
+
+### Planing 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.
+
+```js
+import { createDeepAgent } from "deepagents";
+
+const agent = createDeepAgent({
+    instructions: researchInstructions,
+    subagents: [critiqueSubAgent, researchSubAgent],
+    tools: [internetSearch],
+});
+
+const result = await agent.invoke({
+    messages: [new HumanMessage("what is langchain?")],
+    files: [{"README.md": "# Deep Agents\n\nThis is a README file for the deep agents example."}],
+});
+
+# 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](#subagents--optional-) with their own instructions and tools.
+
+Sub agents are useful for ["context quarantine"](https://www.dbreunig.com/2025/06/26/how-to-fix-your-context.html#context-quarantine) (to help not pollute the overall context of the main agent)
+as well as custom instructions.
+
+## Roadmap
+
+-   [ ] Allow users to customize full system prompt
+-   [ ] Code cleanliness (type hinting, docstrings, formating)
+-   [ ] Allow for more of a robust virtual filesystem
+-   [ ] Create an example of a deep coding agent built on top of this
+-   [ ] Benchmark the example of [deep research agent](src/examples/research/agent.ts)
+-   [ ] Add human-in-the-loop support for tools

package/dist/graph.d.ts

@@ -0,0 +1,46 @@
+import { StructuredTool } from "@langchain/core/tools";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+import { SubAgent } from "./subAgent.js";
+import { DeepAgentState } from "./state.js";
+export interface CreateDeepAgentOptions {
+    tools: StructuredTool[];
+    instructions: string;
+    model?: string | LanguageModelLike;
+    subagents?: SubAgent[];
+    stateSchema?: typeof DeepAgentState;
+}
+/**
+ * Create a deep agent.
+ *
+ * This agent will by default have access to a tool to write todos (write_todos),
+ * and then four file editing tools: write_file, ls, read_file, edit_file.
+ *
+ * @param options Configuration options for the deep agent
+ * @returns A LangGraph agent
+ */
+export declare function createDeepAgent(options: CreateDeepAgentOptions): import("@langchain/langgraph").CompiledStateGraph<import("@langchain/langgraph").StateType<{
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[], import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[]>;
+    todos: import("@langchain/langgraph").BinaryOperatorAggregate<import("./state.js").Todo[], import("./state.js").Todo[]>;
+    files: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
+}>, import("@langchain/langgraph").UpdateType<{
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[], import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[]>;
+    todos: import("@langchain/langgraph").BinaryOperatorAggregate<import("./state.js").Todo[], import("./state.js").Todo[]>;
+    files: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
+}>, any, {
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[], import("@langchain/langgraph").Messages>;
+} & {
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[], import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[]>;
+    todos: import("@langchain/langgraph").BinaryOperatorAggregate<import("./state.js").Todo[], import("./state.js").Todo[]>;
+    files: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
+}, {
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[], import("@langchain/langgraph").Messages>;
+    structuredResponse: {
+        (): import("@langchain/langgraph").LastValue<Record<string, any>>;
+        (annotation: import("@langchain/langgraph").SingleReducer<Record<string, any>, Record<string, any>>): import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+} & {
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[], import("@langchain/core/messages", { with: { "resolution-mode": "import" } }).BaseMessage[]>;
+    todos: import("@langchain/langgraph").BinaryOperatorAggregate<import("./state.js").Todo[], import("./state.js").Todo[]>;
+    files: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
+}, import("@langchain/langgraph").StateDefinition>;

package/dist/graph.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeepAgent = createDeepAgent;
+const prebuilt_1 = require("@langchain/langgraph/prebuilt");
+const subAgent_js_1 = require("./subAgent.js");
+const state_js_1 = require("./state.js");
+const model_js_1 = require("./model.js");
+const tools_js_1 = require("./tools.js");
+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.`;
+/**
+ * Create a deep agent.
+ *
+ * This agent will by default have access to a tool to write todos (write_todos),
+ * and then four file editing tools: write_file, ls, read_file, edit_file.
+ *
+ * @param options Configuration options for the deep agent
+ * @returns A LangGraph agent
+ */
+function createDeepAgent(options) {
+    const { tools, instructions, model, subagents = [], stateSchema = state_js_1.DeepAgentState, } = options;
+    const prompt = instructions + BASE_PROMPT;
+    const builtInTools = [tools_js_1.writeTodos, tools_js_1.writeFile, tools_js_1.readFile, tools_js_1.ls, tools_js_1.editFile];
+    //TODO: lookup for model that has better tool calling capabilities
+    const actualModel = model || (0, model_js_1.getLocalLMStudio)() || (0, model_js_1.getDefaultModel)();
+    const taskTool = (0, subAgent_js_1.createTaskTool)([...tools, ...builtInTools], instructions, subagents, actualModel, stateSchema);
+    const allTools = [taskTool, ...builtInTools, ...tools];
+    return (0, prebuilt_1.createReactAgent)({
+        llm: actualModel,
+        tools: allTools,
+        messageModifier: prompt,
+        stateSchema,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createDeepAgent } from "./graph.js";
+export { DeepAgentState, DeepAgentStateType, Todo, Files } from "./state.js";
+export { SubAgent } from "./subAgent.js";
+export { getDefaultModel } from "./model.js";
+export { writeTodos, writeFile, readFile, ls, editFile } from "./tools.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editFile = exports.ls = exports.readFile = exports.writeFile = exports.writeTodos = exports.getDefaultModel = exports.DeepAgentState = exports.createDeepAgent = void 0;
+var graph_js_1 = require("./graph.js");
+Object.defineProperty(exports, "createDeepAgent", { enumerable: true, get: function () { return graph_js_1.createDeepAgent; } });
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "DeepAgentState", { enumerable: true, get: function () { return state_js_1.DeepAgentState; } });
+var model_js_1 = require("./model.js");
+Object.defineProperty(exports, "getDefaultModel", { enumerable: true, get: function () { return model_js_1.getDefaultModel; } });
+var tools_js_1 = require("./tools.js");
+Object.defineProperty(exports, "writeTodos", { enumerable: true, get: function () { return tools_js_1.writeTodos; } });
+Object.defineProperty(exports, "writeFile", { enumerable: true, get: function () { return tools_js_1.writeFile; } });
+Object.defineProperty(exports, "readFile", { enumerable: true, get: function () { return tools_js_1.readFile; } });
+Object.defineProperty(exports, "ls", { enumerable: true, get: function () { return tools_js_1.ls; } });
+Object.defineProperty(exports, "editFile", { enumerable: true, get: function () { return tools_js_1.editFile; } });

package/dist/model.d.ts

@@ -0,0 +1,4 @@
+import { ChatAnthropic } from "@langchain/anthropic";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+export declare function getDefaultModel(): ChatAnthropic;
+export declare function getLocalLMStudio(): LanguageModelLike;

package/dist/model.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultModel = getDefaultModel;
+exports.getLocalLMStudio = getLocalLMStudio;
+const anthropic_1 = require("@langchain/anthropic");
+const openai_1 = require("@langchain/openai");
+function getDefaultModel() {
+    return new anthropic_1.ChatAnthropic({
+        modelName: "claude-3-5-sonnet-20241022",
+        maxTokens: 64000,
+        temperature: 0,
+    });
+}
+function getLocalLMStudio() {
+    process.env.OPENAI_API_KEY = "lm-studio";
+    return new openai_1.ChatOpenAI({
+        modelName: "mlx-community/llama-3.2-3b-instruct:2",
+        openAIApiKey: "lm-studio",
+        configuration: {
+            baseURL: "http://localhost:1234/v1",
+        },
+        maxTokens: 512,
+        temperature: 0.3,
+    });
+}

package/dist/prompts.d.ts

@@ -0,0 +1,5 @@
+export declare const WRITE_TODOS_DESCRIPTION = "Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.\nIt also helps the user understand the progress of the task and overall progress of their requests.\n\n## When to Use This Tool\nUse this tool proactively in these scenarios:\n\n1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions\n2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations\n3. User explicitly requests todo list - When the user directly asks you to use the todo list\n4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)\n5. After receiving new instructions - Immediately capture user requirements as todos\n6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time\n7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation\n\n## When NOT to Use This Tool\n\nSkip using this tool when:\n1. There is only a single, straightforward task\n2. The task is trivial and tracking it provides no organizational benefit\n3. The task can be completed in less than 3 trivial steps\n4. The task is purely conversational or informational\n\nNOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.\n\n## Task States and Management\n\n1. **Task States**: Use these states to track progress:\n   - pending: Task not yet started\n   - in_progress: Currently working on (limit to ONE task at a time)\n   - completed: Task finished successfully\n\n2. **Task Management**:\n   - Update task status in real-time as you work\n   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)\n   - Only have ONE task in_progress at any time\n   - Complete current tasks before starting new ones\n   - Remove tasks that are no longer relevant from the list entirely\n\n3. **Task Completion Requirements**:\n   - ONLY mark a task as completed when you have FULLY accomplished it\n   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress\n   - When blocked, create a new task describing what needs to be resolved\n   - Never mark a task as completed if:\n     - There are unresolved issues or errors\n     - Work is partial or incomplete\n     - You encountered blockers that prevent completion\n     - You couldn't find necessary resources or dependencies\n     - Quality standards haven't been met\n\n4. **Task Breakdown**:\n   - Create specific, actionable items\n   - Break complex tasks into smaller, manageable steps\n   - Use clear, descriptive task names\n\nWhen in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.";
+export declare const TASK_DESCRIPTION_PREFIX = "Launch a new agent to handle complex, multi-step tasks autonomously. \n\nAvailable agent types and the tools they have access to:\n- general-purpose: General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. (Tools: *)\n{other_agents}\n";
+export declare const TASK_DESCRIPTION_SUFFIX = "When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.\n\nWhen to use the Agent tool:\n- When you are instructed to execute custom slash commands. Use the Agent tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description=\"Check the file\", prompt=\"/check-file path/to/file.py\")\n\nWhen NOT to use the Agent tool:\n- If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more quickly\n- If you are searching for a specific term or definition within a known location, use the Glob tool instead, to find the match more quickly\n- If you are searching for content within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool, to find the match more quickly\n- Other tasks that are not related to the agent descriptions above\n\nUsage notes:\n1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses\n2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.\n3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.\n4. The agent's outputs should generally be trusted\n5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent\n6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.";
+export declare const EDIT_DESCRIPTION = "Performs exact string replacements in files. \n\nUsage:\n- You must use your Read tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. \n- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.\n- ALWAYS prefer editing existing files. NEVER write new files unless explicitly required.\n- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\n- The edit will FAIL if old_string is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all to change every instance of old_string. \n- Use replace_all for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.";
+export declare const TOOL_DESCRIPTION = "Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful. \n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.";

package/dist/prompts.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DESCRIPTION = exports.EDIT_DESCRIPTION = exports.TASK_DESCRIPTION_SUFFIX = exports.TASK_DESCRIPTION_PREFIX = exports.WRITE_TODOS_DESCRIPTION = void 0;
+exports.WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+3. User explicitly requests todo list - When the user directly asks you to use the todo list
+4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+5. After receiving new instructions - Immediately capture user requirements as todos
+6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (limit to ONE task at a time)
+   - completed: Task finished successfully
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Only have ONE task in_progress at any time
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+
+3. **Task Completion Requirements**:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - There are unresolved issues or errors
+     - Work is partial or incomplete
+     - You encountered blockers that prevent completion
+     - You couldn't find necessary resources or dependencies
+     - Quality standards haven't been met
+
+4. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+
+When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`;
+exports.TASK_DESCRIPTION_PREFIX = `Launch a new agent to handle complex, multi-step tasks autonomously. 
+
+Available agent types and the tools they have access to:
+- general-purpose: General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. (Tools: *)
+{other_agents}
+`;
+exports.TASK_DESCRIPTION_SUFFIX = `When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+When to use the Agent tool:
+- When you are instructed to execute custom slash commands. Use the Agent tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description="Check the file", prompt="/check-file path/to/file.py")
+
+When NOT to use the Agent tool:
+- If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more quickly
+- If you are searching for a specific term or definition within a known location, use the Glob tool instead, to find the match more quickly
+- If you are searching for content within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool, to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
+
+Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.`;
+exports.EDIT_DESCRIPTION = `Performs exact string replacements in files. 
+
+Usage:
+- You must use your Read tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if old_string is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all to change every instance of old_string. 
+- Use replace_all for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`;
+exports.TOOL_DESCRIPTION = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to 2000 lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- Any lines longer than 2000 characters will be truncated
+- Results are returned using cat -n format, with line numbers starting at 1
+- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful. 
+- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.`;

package/dist/state.d.ts

@@ -0,0 +1,15 @@
+import { BaseMessage } from "@langchain/core/messages";
+export interface Todo {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+}
+export interface Files {
+    [fileName: string]: string;
+}
+export declare function fileReducer(left: Files | null, right: Files | null): Files | null;
+export declare const DeepAgentState: import("@langchain/langgraph").AnnotationRoot<{
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    todos: import("@langchain/langgraph").BinaryOperatorAggregate<Todo[], Todo[]>;
+    files: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
+}>;
+export type DeepAgentStateType = typeof DeepAgentState.State;

package/dist/state.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepAgentState = void 0;
+exports.fileReducer = fileReducer;
+const langgraph_1 = require("@langchain/langgraph");
+function fileReducer(left, right) {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    return { ...left, ...right };
+}
+exports.DeepAgentState = langgraph_1.Annotation.Root({
+    messages: (0, langgraph_1.Annotation)({
+        reducer: (currentState, updateValue) => currentState.concat(updateValue),
+        default: () => [],
+    }),
+    todos: (0, langgraph_1.Annotation)({
+        reducer: (currentState, updateValue) => updateValue || currentState,
+        default: () => [],
+    }),
+    files: (0, langgraph_1.Annotation)({
+        reducer: (currentState, updateValue) => ({
+            ...currentState,
+            ...updateValue,
+        }),
+        default: () => ({}),
+    }),
+});

package/dist/subAgent.d.ts

@@ -0,0 +1,30 @@
+import { type StructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+import { DeepAgentState } from "./state.js";
+import { ToolMessage } from "@langchain/core/messages";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+export interface SubAgent {
+    name: string;
+    description: string;
+    prompt: string;
+    tools?: string[];
+}
+export declare function createTaskTool(tools: StructuredTool[], instructions: string, subagents: SubAgent[], model: LanguageModelLike, stateAnnotation?: typeof DeepAgentState): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    description: z.ZodString;
+    subagent_type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    subagent_type: string;
+}, {
+    description: string;
+    subagent_type: string;
+}>, {
+    description: string;
+    subagent_type: string;
+}, {
+    description: string;
+    subagent_type: string;
+}, string | {
+    files: any;
+    messages: ToolMessage[];
+}>;

package/dist/subAgent.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskTool = createTaskTool;
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const prebuilt_1 = require("@langchain/langgraph/prebuilt");
+const messages_1 = require("@langchain/core/messages");
+const prompts_js_1 = require("./prompts.js");
+function createTaskTool(tools, instructions, subagents, model, stateAnnotation) {
+    const agents = {
+        "general-purpose": (0, prebuilt_1.createReactAgent)({
+            llm: model,
+            tools,
+            messageModifier: instructions,
+            stateSchema: stateAnnotation,
+        }),
+    };
+    const toolsByName = tools.reduce((tools, tool) => {
+        const toolName = tool.name ?? tool.description ?? "unknown_tool";
+        tools[toolName] = tool;
+        return tools;
+    }, {});
+    for (const agent of subagents) {
+        let agentTools;
+        if (agent.tools) {
+            agentTools = agent.tools.map((t) => toolsByName[t]);
+        }
+        else {
+            agentTools = tools;
+        }
+        agents[agent.name] = (0, prebuilt_1.createReactAgent)({
+            llm: model,
+            tools: agentTools,
+            messageModifier: agent.prompt,
+            stateSchema: stateAnnotation,
+        });
+    }
+    const otherAgentsString = subagents
+        .map((agent) => `- ${agent.name}: ${agent.description}`)
+        .join("\\n");
+    return (0, tools_1.tool)(async (input, config) => {
+        const { description, subagent_type } = input;
+        const state = config?.configurable?.state;
+        if (!(subagent_type in agents)) {
+            return `Error: invoked agent of type ${subagent_type}, the only allowed types are [${Object.keys(agents)
+                .map((k) => `\`${k}\``)
+                .join(", ")}]`;
+        }
+        const subAgent = agents[subagent_type];
+        const newState = {
+            ...state,
+            messages: [new messages_1.HumanMessage({ content: description })],
+        };
+        const result = await subAgent.invoke(newState);
+        return {
+            files: result.files || {},
+            messages: [
+                new messages_1.ToolMessage({
+                    content: result.messages[result.messages.length - 1].content,
+                    tool_call_id: config?.configurable?.tool_call_id || "",
+                }),
+            ],
+        };
+    }, {
+        name: "task",
+        description: prompts_js_1.TASK_DESCRIPTION_PREFIX.replace("{other_agents}", otherAgentsString) + prompts_js_1.TASK_DESCRIPTION_SUFFIX,
+        schema: zod_1.z.object({
+            description: zod_1.z.string(),
+            subagent_type: zod_1.z.string(),
+        }),
+    });
+}

package/dist/tools.d.ts

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { Todo } from "./state.js";
+import { ToolMessage } from "@langchain/core/messages";
+export declare const writeTodos: import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    todos: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        status: z.ZodEnum<["pending", "in_progress", "completed"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "pending" | "in_progress" | "completed";
+        content: string;
+    }, {
+        status: "pending" | "in_progress" | "completed";
+        content: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    todos: {
+        status: "pending" | "in_progress" | "completed";
+        content: string;
+    }[];
+}, {
+    todos: {
+        status: "pending" | "in_progress" | "completed";
+        content: string;
+    }[];
+}>, {
+    todos: Todo[];
+}, {
+    todos: {
+        status: "pending" | "in_progress" | "completed";
+        content: string;
+    }[];
+}, {
+    todos: Todo[];
+    messages: ToolMessage[];
+}>;
+export declare const ls: import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {}, {}, string[]>;
+export declare const readFile: import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    file_path: z.ZodString;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    file_path: string;
+    offset?: number | undefined;
+    limit?: number | undefined;
+}, {
+    file_path: string;
+    offset?: number | undefined;
+    limit?: number | undefined;
+}>, {
+    file_path: string;
+    offset?: number;
+    limit?: number;
+}, {
+    file_path: string;
+    offset?: number | undefined;
+    limit?: number | undefined;
+}, string>;
+export declare const writeFile: import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    file_path: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    file_path: string;
+}, {
+    content: string;
+    file_path: string;
+}>, {
+    file_path: string;
+    content: string;
+}, {
+    content: string;
+    file_path: string;
+}, {
+    files: Record<string, string>;
+    messages: ToolMessage[];
+}>;
+export declare const editFile: import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    file_path: z.ZodString;
+    old_string: z.ZodString;
+    new_string: z.ZodString;
+    replace_all: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all?: boolean | undefined;
+}, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all?: boolean | undefined;
+}>, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all?: boolean;
+}, {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all?: boolean | undefined;
+}, string | {
+    files: Record<string, string>;
+    messages: ToolMessage[];
+}>;

package/dist/tools.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editFile = exports.writeFile = exports.readFile = exports.ls = exports.writeTodos = void 0;
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const messages_1 = require("@langchain/core/messages");
+const prompts_js_1 = require("./prompts.js");
+exports.writeTodos = (0, tools_1.tool)(async (input, config) => {
+    const state = config?.configurable?.state;
+    if (!state) {
+        throw new Error("State not available in tool execution");
+    }
+    state.todos = input.todos;
+    return {
+        todos: input.todos,
+        messages: [
+            new messages_1.ToolMessage({
+                content: `Updated todo list to ${JSON.stringify(input.todos)}`,
+                tool_call_id: config?.configurable?.tool_call_id || "",
+            }),
+        ],
+    };
+}, {
+    name: "write_todos",
+    description: prompts_js_1.WRITE_TODOS_DESCRIPTION,
+    schema: zod_1.z.object({
+        todos: zod_1.z.array(zod_1.z.object({
+            content: zod_1.z.string(),
+            status: zod_1.z.enum(["pending", "in_progress", "completed"]),
+        })),
+    }),
+});
+exports.ls = (0, tools_1.tool)(async (input, config) => {
+    const state = config?.configurable?.state;
+    const files = state?.files || {};
+    return Object.keys(files);
+}, {
+    name: "ls",
+    description: "List all files",
+    schema: zod_1.z.object({}),
+});
+exports.readFile = (0, tools_1.tool)(async (input, config) => {
+    const state = config?.configurable?.state;
+    const mockFilesystem = state?.files || {};
+    const { file_path, offset = 0, limit = 2000 } = input;
+    if (!(file_path in mockFilesystem)) {
+        return `Error: File '${file_path}' not found`;
+    }
+    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)}\\t${lineContent}`);
+    }
+    return resultLines.join("\\n");
+}, {
+    name: "read_file",
+    description: prompts_js_1.TOOL_DESCRIPTION,
+    schema: zod_1.z.object({
+        file_path: zod_1.z.string(),
+        offset: zod_1.z.number().optional(),
+        limit: zod_1.z.number().optional(),
+    }),
+});
+exports.writeFile = (0, tools_1.tool)(async (input, config) => {
+    const state = config?.configurable?.state;
+    const files = state?.files || {};
+    files[input.file_path] = input.content;
+    return {
+        files,
+        messages: [
+            new messages_1.ToolMessage({
+                content: `Updated file ${input.file_path}`,
+                tool_call_id: config?.configurable?.tool_call_id || "",
+            }),
+        ],
+    };
+}, {
+    name: "write_file",
+    description: "Write to a file.",
+    schema: zod_1.z.object({
+        file_path: zod_1.z.string(),
+        content: zod_1.z.string(),
+    }),
+});
+exports.editFile = (0, tools_1.tool)(async (input, config) => {
+    const state = config?.configurable?.state;
+    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 occurrences = (content.match(new RegExp(old_string.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&"), "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}'`;
+        }
+    }
+    const newContent = replace({
+        replaceAll: replace_all,
+        content,
+        current: old_string,
+        next: new_string,
+        filePath: file_path,
+    });
+    // Update the mock filesystem
+    mockFilesystem[file_path] = newContent;
+    return {
+        files: mockFilesystem,
+        messages: [
+            new messages_1.ToolMessage({
+                content: `Updated file ${file_path}`,
+                tool_call_id: config?.configurable?.tool_call_id || "",
+            }),
+        ],
+    };
+}, {
+    name: "edit_file",
+    description: prompts_js_1.EDIT_DESCRIPTION,
+    schema: zod_1.z.object({
+        file_path: zod_1.z.string(),
+        old_string: zod_1.z.string(),
+        new_string: zod_1.z.string(),
+        replace_all: zod_1.z.boolean().optional(),
+    }),
+});
+const replace = (options) => {
+    if (!options.replaceAll) {
+        console.log(`Replacing string in '${options.filePath}'`);
+        return options.content.replace(options.current, options.next);
+    }
+    const newContent = options.content.replaceAll(options.current, options.next);
+    const replacementCount = (options.content.match(new RegExp(options.current.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&"), "g")) || []).length;
+    console.log(`Successfully replaced ${replacementCount} instance(s) of the string in '${options.filePath}'`);
+    return newContent;
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "deepagents",
+  "version": "1.0.0",
+  "description": "General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:Shelex/deepagents-ts.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "node --import tsx src/examples/research/agent.ts",
+    "test": "jest"
+  },
+  "keywords": [
+    "langchain",
+    "langgraph",
+    "agents",
+    "llm",
+    "ai",
+    "typescript"
+  ],
+  "author": "Oleksandr Shevtsov",
+  "license": "MIT",
+  "dependencies": {
+    "@langchain/anthropic": "^0.3.25",
+    "@langchain/community": "^0.3.49",
+    "@langchain/core": "^0.3.66",
+    "@langchain/langgraph": "^0.4.2",
+    "@lmstudio/sdk": "^1.4.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^12.0.1",
+    "@types/node": "^22.17.0",
+    "jest": "^29.7.0",
+    "semantic-release": "^24.0.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.3",
+    "typescript": "^5.0.0"
+  },
+  "release": {
+    "branches": [
+      "master",
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/git",
+      "@semantic-release/github"
+    ]
+  }
+}