deepagents 0.0.0-rc

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) LangChain, Inc.
+
+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 @@
+# 🧠🤖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.
+
+`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.
+
+> ![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[];
+}
+```
+
+- **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.
+
+Sub agents are useful for "context quarantine" (to help not pollute the overall context of the main agent) as well as custom instructions.

package/dist/graph.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Main createDeepAgent function for Deep Agents
+ *
+ * Main entry point for creating deep agents with TypeScript types for all parameters:
+ * tools, instructions, model, subagents, and stateSchema. 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.
+ */
+import type { 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<{
+    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>>;
+    files: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>, import("@langchain/core/utils/types").InteropZodType<Record<string, string> | null | undefined>>;
+}, "strip", z.ZodTypeAny, {
+    todos: import("./types.js").Todo[];
+    files: Record<string, string>;
+    messages: import("@langchain/core/messages").BaseMessage[];
+}, {
+    todos: import("./types.js").Todo[];
+    files: Record<string, string>;
+    messages: import("@langchain/core/messages").BaseMessage[];
+}>, {
+    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>>;
+    files: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>, import("@langchain/core/utils/types").InteropZodType<Record<string, string> | null | undefined>>;
+}>> | import("@langchain/langgraph").StateType<import("@langchain/langgraph/zod").InteropZodToStateDefinition<z.ZodObject<{} & {
+    [x: string]: any;
+}, "strip", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>, {
+    [x: string]: any;
+}>>, import("@langchain/langgraph").UpdateType<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>>;
+    files: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>, import("@langchain/core/utils/types").InteropZodType<Record<string, string> | null | undefined>>;
+}, "strip", z.ZodTypeAny, {
+    todos: import("./types.js").Todo[];
+    files: Record<string, string>;
+    messages: import("@langchain/core/messages").BaseMessage[];
+}, {
+    todos: import("./types.js").Todo[];
+    files: Record<string, string>;
+    messages: import("@langchain/core/messages").BaseMessage[];
+}>, {
+    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>>;
+    files: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>, import("@langchain/core/utils/types").InteropZodType<Record<string, string> | null | undefined>>;
+}>> | import("@langchain/langgraph").UpdateType<import("@langchain/langgraph/zod").InteropZodToStateDefinition<z.ZodObject<{} & {
+    [x: string]: any;
+}, "strip", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>, {
+    [x: string]: any;
+}>>, any, {
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<import("@langchain/core/messages").BaseMessage[], import("@langchain/langgraph").Messages>;
+} & (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>>;
+    files: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>, import("@langchain/core/utils/types").InteropZodType<Record<string, string> | null | undefined>>;
+}, "strip", z.ZodTypeAny, {
+    todos: import("./types.js").Todo[];
+    files: Record<string, string>;
+    messages: import("@langchain/core/messages").BaseMessage[];
+}, {
+    todos: import("./types.js").Todo[];
+    files: Record<string, string>;
+    messages: import("@langchain/core/messages").BaseMessage[];
+}>, {
+    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>>;
+    files: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>, import("@langchain/core/utils/types").InteropZodType<Record<string, string> | null | undefined>>;
+}> | import("@langchain/langgraph/zod").InteropZodToStateDefinition<z.ZodObject<{} & {
+    [x: string]: any;
+}, "strip", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>, {
+    [x: string]: any;
+}>), {
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<import("@langchain/core/messages").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>;
+    };
+} & (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>>;
+    files: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>, import("@langchain/core/utils/types").InteropZodType<Record<string, string> | null | undefined>>;
+}, "strip", z.ZodTypeAny, {
+    todos: import("./types.js").Todo[];
+    files: Record<string, string>;
+    messages: import("@langchain/core/messages").BaseMessage[];
+}, {
+    todos: import("./types.js").Todo[];
+    files: Record<string, string>;
+    messages: import("@langchain/core/messages").BaseMessage[];
+}>, {
+    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>>;
+    files: import("@langchain/langgraph/zod").ReducedZodChannel<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>, import("@langchain/core/utils/types").InteropZodType<Record<string, string> | null | undefined>>;
+}> | import("@langchain/langgraph/zod").InteropZodToStateDefinition<z.ZodObject<{} & {
+    [x: string]: any;
+}, "strip", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>, {
+    [x: string]: any;
+}>), import("@langchain/langgraph").StateDefinition>;

package/dist/graph.js

@@ -0,0 +1,62 @@
+/**
+ * Main createDeepAgent function for Deep Agents
+ *
+ * Main entry point for creating deep agents with TypeScript types for all parameters:
+ * tools, instructions, model, subagents, and stateSchema. 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.
+ */
+// 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";
+/**
+ * Built-in tools that are always available in Deep Agents
+ */
+const BUILTIN_TOOLS = [
+    writeTodos,
+    readFile,
+    writeFile,
+    editFile,
+    ls,
+];
+/**
+ * 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 function createDeepAgent(params = {}) {
+    const { tools = [], instructions, model = getDefaultModel(), subagents = [], } = params;
+    const stateSchema = params.stateSchema
+        ? DeepAgentState.extend(params.stateSchema.shape)
+        : DeepAgentState;
+    // Combine built-in tools with provided tools
+    const allTools = [...BUILTIN_TOOLS, ...tools];
+    // Create task tool using createTaskTool() if subagents are provided
+    if (subagents.length > 0) {
+        // Create tools map for task tool creation
+        const toolsMap = {};
+        for (const tool of allTools) {
+            if (tool.name) {
+                toolsMap[tool.name] = tool;
+            }
+        }
+        const taskTool = createTaskTool({
+            subagents,
+            tools: toolsMap,
+            model,
+            stateSchema,
+        });
+        allTools.push(taskTool);
+    }
+    // Return createReactAgent with proper configuration
+    return createReactAgent({
+        llm: model,
+        tools: allTools,
+        stateSchema,
+        messageModifier: instructions,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Deep Agents TypeScript Implementation
+ *
+ * A TypeScript port of the Python Deep Agents library for building controllable AI agents with LangGraph.
+ * This implementation maintains 1:1 compatibility with the Python version.
+ */
+export { createDeepAgent } from "./graph.js";
+export { getDefaultModel } from "./model.js";
+export { createTaskTool } from "./subAgent.js";
+export { writeTodos, readFile, writeFile, editFile, ls } from "./tools.js";
+export { DeepAgentState, fileReducer } from "./state.js";
+export { WRITE_TODOS_DESCRIPTION, TASK_DESCRIPTION_PREFIX, TASK_DESCRIPTION_SUFFIX, EDIT_DESCRIPTION, TOOL_DESCRIPTION, } from "./prompts.js";
+export type { SubAgent, Todo, DeepAgentStateType, CreateDeepAgentParams, CreateTaskToolParams, TodoStatus, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * Deep Agents TypeScript Implementation
+ *
+ * A TypeScript port of the Python Deep Agents library for building controllable AI agents with LangGraph.
+ * This implementation maintains 1:1 compatibility with the Python version.
+ */
+export { createDeepAgent } from "./graph.js";
+export { getDefaultModel } from "./model.js";
+export { createTaskTool } from "./subAgent.js";
+export { writeTodos, readFile, writeFile, editFile, ls } from "./tools.js";
+export { DeepAgentState, fileReducer } from "./state.js";
+export { WRITE_TODOS_DESCRIPTION, TASK_DESCRIPTION_PREFIX, TASK_DESCRIPTION_SUFFIX, EDIT_DESCRIPTION, TOOL_DESCRIPTION, } from "./prompts.js";

package/dist/model.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Model configuration for Deep Agents
+ *
+ * Default model configuration matching the Python implementation exactly.
+ * Returns a ChatAnthropic instance configured with claude-sonnet-4-20250514 and maxTokens: 4096.
+ */
+import { LanguageModelLike } from "./types.js";
+/**
+ * Get the default model for Deep Agents
+ *
+ * Returns a ChatAnthropic instance configured exactly like the Python version:
+ * - model: "claude-sonnet-4-20250514"
+ * - maxTokens: 4096
+ *
+ * @returns ChatAnthropic instance with default configuration
+ */
+export declare function getDefaultModel(): LanguageModelLike;

package/dist/model.js

@@ -0,0 +1,22 @@
+/**
+ * Model configuration for Deep Agents
+ *
+ * Default model configuration matching the Python implementation exactly.
+ * Returns a ChatAnthropic instance configured with claude-sonnet-4-20250514 and maxTokens: 4096.
+ */
+import { ChatAnthropic } from "@langchain/anthropic";
+/**
+ * Get the default model for Deep Agents
+ *
+ * Returns a ChatAnthropic instance configured exactly like the Python version:
+ * - model: "claude-sonnet-4-20250514"
+ * - maxTokens: 4096
+ *
+ * @returns ChatAnthropic instance with default configuration
+ */
+export function getDefaultModel() {
+    return new ChatAnthropic({
+        model: "claude-sonnet-4-20250514",
+        maxTokens: 4096,
+    });
+}

package/dist/prompts.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Prompt constants for Deep Agents
+ *
+ * All prompt strings ported from Python implementation with exact string content and formatting
+ * to ensure 1:1 compatibility with the Python version.
+ */
+/**
+ * Description for the write_todos tool
+ * Ported exactly from Python WRITE_TODOS_DESCRIPTION
+ */
+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. It also helps the user understand the progress of the task and overall progress of their requests.\n\nWhen to Use This Tool\nUse this tool proactively in these scenarios:\n\nComplex multi-step tasks - When a task requires 3 or more distinct steps or actions\nNon-trivial and complex tasks - Tasks that require careful planning or multiple operations\nUser explicitly requests todo list - When the user directly asks you to use the todo list\nUser provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)\nAfter receiving new instructions - Immediately capture user requirements as todos\nWhen 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\nAfter completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation\nWhen NOT to Use This Tool\nSkip using this tool when:\n\nThere is only a single, straightforward task\nThe task is trivial and tracking it provides no organizational benefit\nThe task can be completed in less than 3 trivial steps\nThe task is purely conversational or informational\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\nExamples of When to Use the Todo List\n<example>\nUser: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!\nAssistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.\n*Creates todo list with the following items:*\n1. Create dark mode toggle component in Settings page\n2. Add dark mode state management (context/store)\n3. Implement CSS-in-JS styles for dark theme\n4. Update existing components to support theme switching\n5. Run tests and build process, addressing any failures or errors that occur\n*Begins working on the first task*\n<reasoning>\nThe assistant used the todo list because:\n1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes\n2. The user explicitly requested tests and build be run afterward\n3. The assistant inferred that tests and build need to pass by adding \"Ensure tests and build succeed\" as the final task\n</reasoning>\n</example>\n<example>\nUser: Help me plan a comprehensive marketing campaign for our new product launch, including social media, email marketing, and press releases.\nAssistant: I'll help you plan a comprehensive marketing campaign for your product launch. Let me create a todo list to organize all the components.\n*Creates todo list with the following items:*\n1. Define target audience and key messaging\n2. Create social media content calendar and posting schedule\n3. Design email marketing sequence and automation flows\n4. Draft press release and identify media contacts\n5. Set up tracking and analytics for campaign performance\n6. Create visual assets and brand materials\n7. Coordinate launch timeline and deliverables\n*Begins working on the first task*\n<reasoning>\nThe assistant used the todo list because:\n1. Marketing campaign planning involves multiple distinct channels and activities\n2. Each component requires careful coordination and planning\n3. The systematic approach ensures all aspects of the launch are covered\n4. Progress tracking helps maintain timeline and deliverables\n</reasoning>\n</example>\n<example>\nUser: Help me rename the function getCwd to getCurrentWorkingDirectory across my project\nAssistant: Let me first search through your codebase to find all occurrences of 'getCwd'.\n*Uses search tools to locate all instances of getCwd in the codebase*\nAssistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.\n*Creates todo list with specific items for each file that needs updating*\n<reasoning>\nThe assistant used the todo list because:\n1. First, the assistant searched to understand the scope of the task\n2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps\n3. The todo list helps ensure every instance is tracked and updated systematically\n4. This approach prevents missing any occurrences and maintains consistency\n</reasoning>\n</example>\n<example>\nUser: I need help organizing my home office: decluttering the desk, setting up a filing system, organizing digital files, and creating a daily workflow.\nAssistant: I'll help you organize your home office systematically. Let me create a todo list to track each area of organization.\n*Creates todo list with items like: 1) Sort and declutter desk items, 2) Set up physical filing system for documents, 3) Organize digital files and folders, 4) Create daily workflow and productivity systems, 5) Establish maintenance routines*\nLet's start with decluttering your desk space to create a clean foundation for the other organizational systems.\n<reasoning>\nThe assistant used the todo list because:\n1. The user provided multiple distinct organizational tasks\n2. Each area requires different approaches and careful planning\n3. Home organization benefits from systematic, step-by-step completion\n4. Progress tracking ensures all areas are addressed thoroughly\n</reasoning>\n</example>\nExamples of When NOT to Use the Todo List\n<example>\nUser: How do I print 'Hello World' in Python?\nAssistant: In Python, you can print \"Hello World\" with this simple code:\n\n```python\nprint(\"Hello World\")\n```\n\nThis will output the text \"Hello World\" to the console when executed.\n<reasoning>\nThe assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.\n</reasoning>\n</example>\n<example>\nUser: What's the best way to water houseplants?\nAssistant: The best way to water houseplants depends on the specific plant type, but here are some general guidelines:\n\nCheck soil moisture by inserting your finger about 1-2 inches into the soil\nWater thoroughly when the top inch feels dry, allowing water to drain from the bottom\nUse room temperature water and water in the morning when possible\nAvoid overwatering, which is more harmful than underwatering for most plants\n\nDifferent plants have different needs, so it's important to research your specific varieties for optimal care.\n\n<reasoning>\nThe assistant did not use the todo list because this is an informational request with no actual tasks to complete. The user is simply asking for advice and explanation, not for the assistant to perform multiple steps or activities.\n</reasoning>\n</example>\n<example>\nUser: Can you add a comment to the calculateTotal function to explain what it does?\nAssistant: Sure, let me add a comment to the calculateTotal function to explain what it does.\n* Uses the Edit tool to add a comment to the calculateTotal function *\n<reasoning>\nThe assistant did not use the todo list because this is a single, straightforward task confined to one location. Adding a comment doesn't require tracking multiple steps or systematic organization.\n</reasoning>\n</example>\n<example>\nUser: What time is it in Tokyo right now?\nAssistant: I'll check the current time in Tokyo for you.\n\n*Searches for current time in Tokyo*\n\nThe current time in Tokyo, Japan is [current time]. Tokyo is in the Japan Standard Time (JST) zone, which is UTC+9.\n\n<reasoning>\nThe assistant did not use the todo list because this is a single information lookup with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward request.\n</reasoning>\n</example>\nTask States and Management\nTask States: Use these states to track progress:\n\npending: Task not yet started\nin_progress: Currently working on (limit to ONE task at a time)\ncompleted: Task finished successfully\nTask Management:\n\nUpdate task status in real-time as you work\nMark tasks complete IMMEDIATELY after finishing (don't batch completions)\nOnly have ONE task in_progress at any time\nComplete current tasks before starting new ones\nRemove tasks that are no longer relevant from the list entirely\nTask Completion Requirements:\n\nONLY mark a task as completed when you have FULLY accomplished it\nIf you encounter errors, blockers, or cannot finish, keep the task as in_progress\nWhen blocked, create a new task describing what needs to be resolved\nNever mark a task as completed if:\nThere are unresolved issues or errors\nWork is partial or incomplete\nYou encountered blockers that prevent completion\nYou couldn't find necessary resources or dependencies\nQuality standards haven't been met\nTask Breakdown:\n\nCreate specific, actionable items\nBreak complex tasks into smaller, manageable steps\nUse clear, descriptive task names\nWhen in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.";
+/**
+ * Prefix for task tool description
+ * Ported exactly from Python TASK_DESCRIPTION_PREFIX
+ */
+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\ngeneral-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";
+/**
+ * Suffix for task tool description
+ * Ported exactly from Python TASK_DESCRIPTION_SUFFIX
+ */
+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\nWhen 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\")\nWhen NOT to use the Agent tool:\n\nIf 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\nIf you are searching for a specific term or definition within a known location, use the Glob tool instead, to find the match more quickly\nIf 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\nOther tasks that are not related to the agent descriptions above\nUsage notes:\n\nLaunch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses\nWhen 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.\nEach 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.\nThe agent's outputs should generally be trusted\nClearly 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\nIf 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.\nExample usage:\n\n<example_agent_descriptions>\n\"content-reviewer\": use this agent after you are done creating significant content or documents\n\"greeting-responder\": use this agent when to respond to user greetings with a friendly joke\n\"research-analyst\": use this agent to conduct thorough research on complex topics\n</example_agent_description>\n\n<example>\nuser: \"Please write a function that checks if a number is prime\"\nassistant: Sure let me write a function that checks if a number is prime\nassistant: First let me use the Write tool to write a function that checks if a number is prime\nassistant: I'm going to use the Write tool to write the following code:\n<code>\nfunction isPrime(n) {\n  if (n <= 1) return false\n  for (let i = 2; i * i <= n; i++) {\n    if (n % i === 0) return false\n  }\n  return true\n}\n</code>\n<commentary>\nSince significant content was created and the task was completed, now use the content-reviewer agent to review the work\n</commentary>\nassistant: Now let me use the content-reviewer agent to review the code\nassistant: Uses the Task tool to launch with the content-reviewer agent\n</example>\n<example>\nuser: \"Can you help me research the environmental impact of different renewable energy sources and create a comprehensive report?\"\n<commentary>\nThis is a complex research task that would benefit from using the research-analyst agent to conduct thorough analysis\n</commentary>\nassistant: I'll help you research the environmental impact of renewable energy sources. Let me use the research-analyst agent to conduct comprehensive research on this topic.\nassistant: Uses the Task tool to launch with the research-analyst agent, providing detailed instructions about what research to conduct and what format the report should take\n</example>\n<example>\nuser: \"Hello\"\n<commentary>\nSince the user is greeting, use the greeting-responder agent to respond with a friendly joke\n</commentary>\nassistant: \"I'm going to use the Task tool to launch with the greeting-responder agent\"\n</example>";
+/**
+ * Description for the edit_file tool
+ * Ported exactly from Python EDIT_DESCRIPTION
+ */
+export declare const EDIT_DESCRIPTION = "Performs exact string replacements in files.\nUsage:\n\nYou 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.\nWhen 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.\nALWAYS prefer editing existing files. NEVER write new files unless explicitly required.\nOnly use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\nThe 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.\nUse replace_all for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.";
+/**
+ * Description for the read_file tool
+ * Ported exactly from Python TOOL_DESCRIPTION
+ */
+export declare const 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.\nUsage:\n\nThe file_path parameter must be an absolute path, not a relative path\nBy default, it reads up to 2000 lines starting from the beginning of the file\nYou 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\nAny lines longer than 2000 characters will be truncated\nResults are returned using cat -n format, with line numbers starting at 1\nYou 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.\nIf you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.";