zeitlich 0.2.2 → 0.2.4

package/dist/index.js

@@ -1,52 +1,52 @@
 import { defineQuery, proxyActivities, setHandler, uuid4, workflowInfo, executeChild } from '@temporalio/workflow';
-import z5, { z } from 'zod';
+import z3, { z } from 'zod';
 import { SimplePlugin } from '@temporalio/plugin';
-import { SystemMessage, ToolMessage, AIMessage, HumanMessage, mapStoredMessageToChatMessage, mapStoredMessagesToChatMessages } from '@langchain/core/messages';
+import { mapStoredMessagesToChatMessages, AIMessage, ToolMessage, HumanMessage } from '@langchain/core/messages';
 import crypto from 'crypto';
 import { Context } from '@temporalio/activity';
 import { Bash } from 'just-bash';
 
 // src/lib/session.ts
-var TASK_TOOL = "Task";
-function buildTaskDescription(subagents) {
+var SUBAGENT_TOOL = "Subagent";
+function buildSubagentDescription(subagents) {
   const subagentList = subagents.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
-  return `Launch a new agent to handle complex, multi-step tasks autonomously.
+  return `Launch a new agent to handle complex tasks autonomously.
 
-The ${TASK_TOOL} tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
+The ${SUBAGENT_TOOL} tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
 
 Available agent types:
 
 ${subagentList}
 
-When using the ${TASK_TOOL} tool, you must specify a subagent parameter to select which agent type to use.
+When using the ${SUBAGENT_TOOL} tool, you must specify a subagent parameter to select which agent type to use.
 
 Usage notes:
 
 - Always include a short description (3-5 words) summarizing what the agent will do
 - Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
-- 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.
+- When the agent is done, it will return a single message back to you.
 - Each invocation starts fresh - provide a detailed task description with all necessary context.
 - Provide clear, detailed prompts so the agent can work autonomously and return exactly the information you need.
 - The agent's outputs should generally be trusted
 - Clearly tell the agent what type of work you expect since it is not aware of the user's intent
 - 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.`;
 }
-function createTaskTool(subagents) {
+function createSubagentTool(subagents) {
   if (subagents.length === 0) {
     throw new Error("createTaskTool requires at least one subagent");
   }
   const names = subagents.map((s) => s.name);
   return {
-    name: TASK_TOOL,
-    description: buildTaskDescription(subagents),
-    schema: z5.object({
-      subagent: z5.enum(names).describe("The type of subagent to launch"),
-      description: z5.string().describe("A short (3-5 word) description of the task"),
-      prompt: z5.string().describe("The task for the agent to perform")
+    name: SUBAGENT_TOOL,
+    description: buildSubagentDescription(subagents),
+    schema: z3.object({
+      subagent: z3.enum(names).describe("The type of subagent to launch"),
+      description: z3.string().describe("A short (3-5 word) description of the task"),
+      prompt: z3.string().describe("The task for the agent to perform")
     })
   };
 }
-function createTaskHandler(subagents) {
+function createSubagentHandler(subagents) {
   const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } = workflowInfo();
   return async (args) => {
     const config = subagents.find((s) => s.name === args.subagent);
@@ -65,128 +65,32 @@ function createTaskHandler(subagents) {
       args: [input],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
-    const childResult = typeof config.workflow === "string" ? await executeChild(config.workflow, childOpts) : await executeChild(config.workflow, childOpts);
-    const validated = config.resultSchema ? config.resultSchema.parse(childResult) : childResult;
-    const toolResponse = typeof validated === "string" ? validated : JSON.stringify(validated, null, 2);
+    const { toolResponse, data } = typeof config.workflow === "string" ? await executeChild(config.workflow, childOpts) : await executeChild(config.workflow, childOpts);
+    const validated = config.resultSchema ? config.resultSchema.parse(data) : null;
     return {
       toolResponse,
-      data: {
-        result: validated,
-        childWorkflowId
-      }
+      data: validated
     };
   };
 }
-var createBashToolDescription = ({
-  fileTree
-}) => `Execute shell commands in a bash environment.
-
-Use this tool to:
-- Run shell commands (ls, cat, grep, find, etc.)
-- Execute scripts and chain commands with pipes (|) or logical operators (&&, ||)
-- Inspect files and directories
-
-Current file tree:
-${fileTree}`;
-var bashTool = {
-  name: "Bash",
-  description: `Execute shell commands in a sandboxed bash environment.
-
-Use this tool to:
-- Run shell commands (ls, cat, grep, find, etc.)
-- Execute scripts and chain commands with pipes (|) or logical operators (&&, ||)
-- Inspect files and directories
-`,
-  schema: z5.object({
-    command: z5.string().describe(
-      "The bash command to execute. Can include pipes (|), redirects (>, >>), logical operators (&&, ||), and shell features like command substitution $(...)."
-    )
-  }),
-  strict: true
-};
-var taskCreateTool = {
-  name: "TaskCreate",
-  description: `Use this tool to create a structured task list for the control test. 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:
-  
-  - Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-  - Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-  - User explicitly requests todo list - When the user directly asks you to use the todo list
-  - User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-  - After receiving new instructions - Immediately capture user requirements as tasks
-  - When you start working on a task - Mark it as in_progress BEFORE beginning work
-  - 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:
-  - There is only a single, straightforward task
-  - The task is trivial and tracking it provides no organizational benefit
-  - The task can be completed in less than 3 trivial steps
-  - 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 Fields
-  
-  - **subject**: A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")
-  - **description**: Detailed description of what needs to be done, including context and acceptance criteria
-  - **activeForm**: Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.
-  
-  **IMPORTANT**: Always provide activeForm when creating tasks. The subject should be imperative ("Run tests") while activeForm should be present continuous ("Running tests"). All tasks are created with status \`pending\`.
-  
-  ## Tips
-  
-  - Create tasks with clear, specific subjects that describe the outcome
-  - Include enough detail in the description for another agent to understand and complete the task
-  - After creating tasks, use TaskUpdate to set up dependencies (blocks/blockedBy) if needed
-  - Check TaskList first to avoid creating duplicate tasks`,
-  schema: z5.object({
-    subject: z5.string().describe(
-      'A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")'
-    ),
-    description: z5.string().describe(
-      "Detailed description of what needs to be done, including context and acceptance criteria"
-    ),
-    activeForm: z5.string().describe(
-      'Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.'
-    ),
-    metadata: z5.record(z5.string(), z5.string()).describe("Arbitrary key-value pairs for tracking")
-  })
-};
 
 // src/lib/tool-router.ts
-var buildIntoolDefinitions = {
-  [bashTool.name]: bashTool,
-  [taskCreateTool.name]: taskCreateTool
-};
 function createToolRouter(options) {
-  const { appendToolResult } = proxyActivities({
-    startToCloseTimeout: "2m",
-    retry: {
-      maximumAttempts: 3,
-      initialInterval: "5s",
-      maximumInterval: "15m",
-      backoffCoefficient: 4
-    }
-  });
+  const { appendToolResult } = options;
   const toolMap = /* @__PURE__ */ new Map();
   for (const [_key, tool] of Object.entries(options.tools)) {
     toolMap.set(tool.name, tool);
   }
+  const isEnabled = (tool) => tool.enabled !== false;
   if (options.subagents) {
     const subagentHooksMap = /* @__PURE__ */ new Map();
     for (const s of options.subagents) {
       if (s.hooks) subagentHooksMap.set(s.name, s.hooks);
     }
     const resolveSubagentName = (args) => args.subagent;
-    toolMap.set("Task", {
-      ...createTaskTool(options.subagents),
-      handler: createTaskHandler(options.subagents),
+    toolMap.set("Subagent", {
+      ...createSubagentTool(options.subagents),
+      handler: createSubagentHandler(options.subagents),
       ...subagentHooksMap.size > 0 && {
         hooks: {
           onPreToolUse: async (ctx) => {
@@ -205,24 +109,6 @@ function createToolRouter(options) {
       }
     });
   }
-  if (options.buildInTools) {
-    for (const [key, value] of Object.entries(options.buildInTools)) {
-      if (key === bashTool.name) {
-        toolMap.set(key, {
-          ...buildIntoolDefinitions[key],
-          description: createBashToolDescription({
-            fileTree: options.fileTree
-          }),
-          handler: value
-        });
-      } else {
-        toolMap.set(key, {
-          ...buildIntoolDefinitions[key],
-          handler: value
-        });
-      }
-    }
-  }
   async function processToolCall(toolCall, turn, handlerContext) {
     const startTime = Date.now();
     const tool = toolMap.get(toolCall.name);
@@ -238,6 +124,7 @@ function createToolRouter(options) {
         await appendToolResult({
           threadId: options.threadId,
           toolCallId: toolCall.id,
+          toolName: toolCall.name,
           content: JSON.stringify({
             skipped: true,
             reason: "Skipped by PreToolUse hook"
@@ -259,6 +146,7 @@ function createToolRouter(options) {
         await appendToolResult({
           threadId: options.threadId,
           toolCallId: toolCall.id,
+          toolName: toolCall.name,
           content: JSON.stringify({
             skipped: true,
             reason: "Skipped by tool PreToolUse hook"
@@ -272,14 +160,22 @@ function createToolRouter(options) {
     }
     let result;
     let content;
+    let resultAppended = false;
     try {
       if (tool) {
+        const enrichedContext = {
+          ...handlerContext ?? {},
+          threadId: options.threadId,
+          toolCallId: toolCall.id,
+          toolName: toolCall.name
+        };
         const response = await tool.handler(
           effectiveArgs,
-          handlerContext ?? {}
+          enrichedContext
         );
         result = response.data;
         content = response.toolResponse;
+        resultAppended = response.resultAppended === true;
       } else {
         result = { error: `Unknown tool: ${toolCall.name}` };
         content = JSON.stringify(result, null, 2);
@@ -325,11 +221,14 @@ function createToolRouter(options) {
         throw error;
       }
     }
-    await appendToolResult({
-      threadId: options.threadId,
-      toolCallId: toolCall.id,
-      content
-    });
+    if (!resultAppended) {
+      await appendToolResult({
+        threadId: options.threadId,
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        content
+      });
+    }
     const toolResult = {
       toolCallId: toolCall.id,
       name: toolCall.name,
@@ -359,11 +258,11 @@ function createToolRouter(options) {
   return {
     // --- Methods from registry ---
     hasTools() {
-      return toolMap.size > 0;
+      return Array.from(toolMap.values()).some(isEnabled);
     },
     parseToolCall(toolCall) {
       const tool = toolMap.get(toolCall.name);
-      if (!tool) {
+      if (!tool || !isEnabled(tool)) {
         throw new Error(`Tool ${toolCall.name} not found`);
       }
       const parsedArgs = tool.schema.parse(toolCall.args);
@@ -374,13 +273,14 @@ function createToolRouter(options) {
       };
     },
     hasTool(name) {
-      return toolMap.has(name);
+      const tool = toolMap.get(name);
+      return tool !== void 0 && isEnabled(tool);
     },
     getToolNames() {
-      return Array.from(toolMap.keys());
+      return Array.from(toolMap.entries()).filter(([, tool]) => isEnabled(tool)).map(([name]) => name);
     },
     getToolDefinitions() {
-      return Array.from(toolMap).map(([name, tool]) => ({
+      return Array.from(toolMap).filter(([, tool]) => isEnabled(tool)).map(([name, tool]) => ({
         name,
         description: tool.description,
         schema: tool.schema,
@@ -419,19 +319,28 @@ function createToolRouter(options) {
       }
       const handlerContext = context?.handlerContext ?? {};
       const processOne = async (toolCall) => {
+        const enrichedContext = {
+          ...handlerContext ?? {},
+          threadId: options.threadId,
+          toolCallId: toolCall.id,
+          toolName: toolCall.name
+        };
         const response = await handler(
           toolCall.args,
-          handlerContext
+          enrichedContext
         );
-        await appendToolResult({
-          threadId: options.threadId,
-          toolCallId: toolCall.id,
-          content: response.toolResponse
-        });
+        if (!response.resultAppended) {
+          await appendToolResult({
+            threadId: options.threadId,
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: response.toolResponse
+          });
+        }
         return {
           toolCallId: toolCall.id,
           name: toolCall.name,
-          data: response.data ?? null
+          data: response.data
         };
       };
       if (options.parallel) {
@@ -457,6 +366,21 @@ function createToolRouter(options) {
     }
   };
 }
+function withAutoAppend(threadHandler, handler) {
+  return async (args, context) => {
+    const response = await handler(args, context);
+    const threadId = context.threadId;
+    const toolCallId = context.toolCallId;
+    const toolName = context.toolName;
+    await threadHandler({
+      threadId,
+      toolCallId,
+      toolName,
+      content: response.toolResponse
+    });
+    return { toolResponse: "", data: response.data, resultAppended: true };
+  };
+}
 function defineTool(tool) {
   return tool;
 }
@@ -468,51 +392,24 @@ function hasNoOtherToolCalls(toolCalls, excludeName) {
 }
 
 // src/lib/session.ts
-async function resolvePrompt(prompt) {
-  if (typeof prompt === "function") {
-    return prompt();
-  }
-  return prompt;
-}
 var createSession = async ({
   threadId,
   agentName,
   maxTurns = 50,
   metadata = {},
   runAgent,
-  baseSystemPrompt,
-  instructionsPrompt,
+  threadOps,
   buildContextMessage,
-  buildFileTree = async () => "",
   subagents,
   tools = {},
   processToolsInParallel = true,
-  buildInTools = {},
   hooks = {}
 }) => {
-  const {
-    initializeThread,
-    appendHumanMessage,
-    parseToolCalls,
-    appendToolResult,
-    appendSystemMessage
-  } = proxyActivities({
-    startToCloseTimeout: "30m",
-    retry: {
-      maximumAttempts: 6,
-      initialInterval: "5s",
-      maximumInterval: "15m",
-      backoffCoefficient: 4
-    },
-    heartbeatTimeout: "5m"
-  });
-  const fileTree = await buildFileTree();
   const toolRouter = createToolRouter({
     tools,
+    appendToolResult: threadOps.appendToolResult,
     threadId,
     hooks,
-    buildInTools,
-    fileTree,
     subagents,
     parallel: processToolsInParallel
   });
@@ -537,83 +434,41 @@ var createSession = async ({
         });
       }
       stateManager.setTools(toolRouter.getToolDefinitions());
-      await initializeThread(threadId);
-      await appendSystemMessage(
-        threadId,
-        [
-          await resolvePrompt(baseSystemPrompt),
-          await resolvePrompt(instructionsPrompt)
-        ].join("\n")
-      );
-      await appendHumanMessage(threadId, await buildContextMessage());
+      await threadOps.initializeThread(threadId);
+      await threadOps.appendHumanMessage(threadId, await buildContextMessage());
       let exitReason = "completed";
       try {
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
-          const { message, stopReason } = await runAgent({
+          const { message, rawToolCalls } = await runAgent({
             threadId,
             agentName,
             metadata
           });
-          if (stopReason === "end_turn") {
-            stateManager.complete();
-            exitReason = "completed";
-            return message;
-          }
-          if (!toolRouter.hasTools()) {
+          if (!toolRouter.hasTools() || rawToolCalls.length === 0) {
             stateManager.complete();
             exitReason = "completed";
             return message;
           }
-          const rawToolCalls = await parseToolCalls(message);
           const parsedToolCalls = [];
-          for (const tc of rawToolCalls.filter(
-            (tc2) => tc2.name !== "Task"
-          )) {
+          for (const tc of rawToolCalls) {
             try {
               parsedToolCalls.push(toolRouter.parseToolCall(tc));
             } catch (error) {
-              await appendToolResult({
+              await threadOps.appendToolResult({
                 threadId,
                 toolCallId: tc.id ?? "",
+                toolName: tc.name,
                 content: JSON.stringify({
                   error: `Invalid tool call for "${tc.name}": ${error instanceof Error ? error.message : String(error)}`
                 })
               });
             }
           }
-          const taskToolCalls = [];
-          if (subagents && subagents.length > 0) {
-            for (const tc of rawToolCalls.filter(
-              (tc2) => tc2.name === "Task"
-            )) {
-              try {
-                const parsedArgs = createTaskTool(subagents).schema.parse(
-                  tc.args
-                );
-                taskToolCalls.push({
-                  id: tc.id ?? "",
-                  name: tc.name,
-                  args: parsedArgs
-                });
-              } catch (error) {
-                await appendToolResult({
-                  threadId,
-                  toolCallId: tc.id ?? "",
-                  content: JSON.stringify({
-                    error: `Invalid tool call for "Task": ${error instanceof Error ? error.message : String(error)}`
-                  })
-                });
-              }
-            }
-          }
-          await toolRouter.processToolCalls(
-            [...parsedToolCalls, ...taskToolCalls],
-            {
-              turn: currentTurn
-            }
-          );
+          await toolRouter.processToolCalls(parsedToolCalls, {
+            turn: currentTurn
+          });
           if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
             exitReason = "waiting_for_input";
             break;
@@ -632,6 +487,25 @@ var createSession = async ({
     }
   };
 };
+function proxyDefaultThreadOps(options) {
+  const activities = proxyActivities(
+    options ?? {
+      startToCloseTimeout: "30m",
+      retry: {
+        maximumAttempts: 6,
+        initialInterval: "5s",
+        maximumInterval: "15m",
+        backoffCoefficient: 4
+      },
+      heartbeatTimeout: "5m"
+    }
+  );
+  return {
+    initializeThread: activities.initializeThread,
+    appendHumanMessage: activities.appendHumanMessage,
+    appendToolResult: activities.appendToolResult
+  };
+}
 
 // src/lib/types.ts
 function isTerminalStatus(status) {
@@ -768,18 +642,18 @@ Usage notes:
 * Use multiSelect: true to allow multiple answers to be selected for a question
 * If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
 `,
-  schema: z5.object({
-    questions: z5.array(
-      z5.object({
-        question: z5.string().describe("The full question text to display"),
-        header: z5.string().describe("Short label for the question (max 12 characters)"),
-        options: z5.array(
-          z5.object({
-            label: z5.string(),
-            description: z5.string()
+  schema: z3.object({
+    questions: z3.array(
+      z3.object({
+        question: z3.string().describe("The full question text to display"),
+        header: z3.string().describe("Short label for the question (max 12 characters)"),
+        options: z3.array(
+          z3.object({
+            label: z3.string(),
+            description: z3.string()
           })
         ).min(0).max(4).describe("Array of 0-4 choices, each with label and description"),
-        multiSelect: z5.boolean().describe("If true, users can select multiple options")
+        multiSelect: z3.boolean().describe("If true, users can select multiple options")
       })
     )
   }),
@@ -857,7 +731,7 @@ var writeTool = {
   description: `Create or overwrite a file with new content.
 
 Usage:
-- Provide the absolute virtual path to the file
+- Provide the absolute path to the file
 - The file will be created if it doesn't exist
 - If the file exists, it will be completely overwritten
 
@@ -867,7 +741,7 @@ IMPORTANT:
 - Path must be absolute (e.g., "/docs/readme.md", not "docs/readme.md")
 `,
   schema: z.object({
-    file_path: z.string().describe("The absolute virtual path to the file to write"),
+    file_path: z.string().describe("The absolute path to the file to write"),
     content: z.string().describe("The content to write to the file")
   }),
   strict: true
@@ -900,6 +774,60 @@ IMPORTANT:
   }),
   strict: true
 };
+var taskCreateTool = {
+  name: "TaskCreate",
+  description: `Use this tool to create a structured task list for the control test. 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:
+  
+  - Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+  - Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+  - User explicitly requests todo list - When the user directly asks you to use the todo list
+  - User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+  - After receiving new instructions - Immediately capture user requirements as tasks
+  - When you start working on a task - Mark it as in_progress BEFORE beginning work
+  - 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:
+  - There is only a single, straightforward task
+  - The task is trivial and tracking it provides no organizational benefit
+  - The task can be completed in less than 3 trivial steps
+  - 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 Fields
+  
+  - **subject**: A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")
+  - **description**: Detailed description of what needs to be done, including context and acceptance criteria
+  - **activeForm**: Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.
+  
+  **IMPORTANT**: Always provide activeForm when creating tasks. The subject should be imperative ("Run tests") while activeForm should be present continuous ("Running tests"). All tasks are created with status \`pending\`.
+  
+  ## Tips
+  
+  - Create tasks with clear, specific subjects that describe the outcome
+  - Include enough detail in the description for another agent to understand and complete the task
+  - After creating tasks, use TaskUpdate to set up dependencies (blocks/blockedBy) if needed
+  - Check TaskList first to avoid creating duplicate tasks`,
+  schema: z3.object({
+    subject: z3.string().describe(
+      'A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")'
+    ),
+    description: z3.string().describe(
+      "Detailed description of what needs to be done, including context and acceptance criteria"
+    ),
+    activeForm: z3.string().describe(
+      'Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.'
+    ),
+    metadata: z3.record(z3.string(), z3.string()).describe("Arbitrary key-value pairs for tracking")
+  })
+};
 function createTaskCreateHandler(stateManager) {
   return (args) => {
     const task = {
@@ -922,8 +850,8 @@ function createTaskCreateHandler(stateManager) {
 var taskGetTool = {
   name: "TaskGet",
   description: `Retrieve full task details including dependencies.`,
-  schema: z5.object({
-    taskId: z5.string().describe("The ID of the task to get")
+  schema: z3.object({
+    taskId: z3.string().describe("The ID of the task to get")
   })
 };
 
@@ -946,12 +874,12 @@ function createTaskGetHandler(stateManager) {
 var taskListTool = {
   name: "TaskList",
   description: `List all tasks with current state.`,
-  schema: z5.object({})
+  schema: z3.object({})
 };
 
 // src/tools/task-list/handler.ts
 function createTaskListHandler(stateManager) {
-  return (_args) => {
+  return () => {
     const taskList = stateManager.getTasks();
     return {
       toolResponse: JSON.stringify(taskList, null, 2),
@@ -962,11 +890,11 @@ function createTaskListHandler(stateManager) {
 var taskUpdateTool = {
   name: "TaskUpdate",
   description: `Update status, add blockers, modify details.`,
-  schema: z5.object({
-    taskId: z5.string().describe("The ID of the task to get"),
-    status: z5.enum(["pending", "in_progress", "completed"]).describe("The status of the task"),
-    addBlockedBy: z5.array(z5.string()).describe("The IDs of the tasks that are blocking this task"),
-    addBlocks: z5.array(z5.string()).describe("The IDs of the tasks that this task is blocking")
+  schema: z3.object({
+    taskId: z3.string().describe("The ID of the task to get"),
+    status: z3.enum(["pending", "in_progress", "completed"]).describe("The status of the task"),
+    addBlockedBy: z3.array(z3.string()).describe("The IDs of the tasks that are blocking this task"),
+    addBlocks: z3.array(z3.string()).describe("The IDs of the tasks that this task is blocking")
   })
 };
 
@@ -1014,6 +942,33 @@ function createTaskUpdateHandler(stateManager) {
     };
   };
 }
+var createBashToolDescription = ({
+  fileTree
+}) => `Execute shell commands in a bash environment.
+
+Use this tool to:
+- Run shell commands (ls, cat, grep, find, etc.)
+- Execute scripts and chain commands with pipes (|) or logical operators (&&, ||)
+- Inspect files and directories
+
+Current file tree:
+${fileTree}`;
+var bashTool = {
+  name: "Bash",
+  description: `Execute shell commands in a sandboxed bash environment.
+
+Use this tool to:
+- Run shell commands (ls, cat, grep, find, etc.)
+- Execute scripts and chain commands with pipes (|) or logical operators (&&, ||)
+- Inspect files and directories
+`,
+  schema: z3.object({
+    command: z3.string().describe(
+      "The bash command to execute. Can include pipes (|), redirects (>, >>), logical operators (&&, ||), and shell features like command substitution $(...)."
+    )
+  }),
+  strict: true
+};
 
 // node_modules/uuid/dist/esm-node/stringify.js
 var byteToHex = [];
@@ -1062,25 +1017,33 @@ function getThreadKey(threadId, key) {
   return `thread:${threadId}:${key}`;
 }
 function createThreadManager(config) {
-  const { redis, threadId, key = "messages" } = config;
+  const {
+    redis,
+    threadId,
+    key = "messages",
+    serialize = (m) => JSON.stringify(m),
+    deserialize = (raw) => JSON.parse(raw)
+  } = config;
   const redisKey = getThreadKey(threadId, key);
-  return {
+  const base = {
     async initialize() {
       await redis.del(redisKey);
     },
     async load() {
       const data = await redis.lrange(redisKey, 0, -1);
-      return data.map((item) => JSON.parse(item));
+      return data.map(deserialize);
     },
     async append(messages) {
       if (messages.length > 0) {
-        await redis.rpush(redisKey, ...messages.map((m) => JSON.stringify(m)));
+        await redis.rpush(redisKey, ...messages.map(serialize));
         await redis.expire(redisKey, THREAD_TTL_SECONDS);
       }
     },
     async delete() {
       await redis.del(redisKey);
-    },
+    }
+  };
+  const helpers = {
     createHumanMessage(content) {
       return new HumanMessage({
         id: v4_default(),
@@ -1100,40 +1063,29 @@ function createThreadManager(config) {
     },
     createToolMessage(content, toolCallId) {
       return new ToolMessage({
-        // Cast needed due to langchain type compatibility
         content,
         tool_call_id: toolCallId
       }).toDict();
     },
-    createSystemMessage(content) {
-      return new SystemMessage({
-        content
-      }).toDict();
-    },
-    async appendSystemMessage(content) {
-      const message = this.createSystemMessage(content);
-      await this.append([message]);
-    },
     async appendHumanMessage(content) {
-      const message = this.createHumanMessage(content);
-      await this.append([message]);
+      const message = helpers.createHumanMessage(content);
+      await base.append([message]);
     },
     async appendToolMessage(content, toolCallId) {
-      const message = this.createToolMessage(content, toolCallId);
-      await this.append([message]);
+      const message = helpers.createToolMessage(content, toolCallId);
+      await base.append([message]);
     },
     async appendAIMessage(content) {
-      const message = this.createAIMessage(content);
-      await this.append([message]);
+      const message = helpers.createAIMessage(content);
+      await base.append([message]);
     }
   };
+  return Object.assign(base, helpers);
 }
+
+// src/activities.ts
 function createSharedActivities(redis) {
   return {
-    async appendSystemMessage(threadId, content) {
-      const thread = createThreadManager({ redis, threadId });
-      await thread.appendSystemMessage(content);
-    },
     async appendToolResult(config) {
       const { threadId, toolCallId, content } = config;
       const thread = createThreadManager({ redis, threadId });
@@ -1150,15 +1102,6 @@ function createSharedActivities(redis) {
     async appendHumanMessage(threadId, content) {
       const thread = createThreadManager({ redis, threadId });
       await thread.appendHumanMessage(content);
-    },
-    async parseToolCalls(storedMessage) {
-      const message = mapStoredMessageToChatMessage(storedMessage);
-      const toolCalls = message.tool_calls ?? [];
-      return toolCalls.map((toolCall) => ({
-        id: toolCall.id,
-        name: toolCall.name,
-        args: toolCall.args
-      }));
     }
   };
 }
@@ -1196,9 +1139,14 @@ async function invokeModel({
     }
   );
   await thread.append([response.toDict()]);
+  const toolCalls = response.tool_calls ?? [];
   return {
     message: response.toDict(),
-    stopReason: response.response_metadata?.stop_reason ?? null,
+    rawToolCalls: toolCalls.map((tc) => ({
+      id: tc.id,
+      name: tc.name,
+      args: tc.args
+    })),
     usage: {
       input_tokens: response.usage_metadata?.input_tokens,
       output_tokens: response.usage_metadata?.output_tokens,
@@ -1206,7 +1154,7 @@ async function invokeModel({
     }
   };
 }
-var handleAskUserQuestionToolResult = async (args) => {
+var createAskUserQuestionHandler = () => async (args) => {
   const messages = args.questions.map(
     ({ question, header, options, multiSelect }) => new AIMessage({
       content: question,
@@ -1219,99 +1167,79 @@ var handleAskUserQuestionToolResult = async (args) => {
   );
   return { toolResponse: "Question submitted", data: { chatMessages: messages } };
 };
-async function globHandler(_args, fs) {
-  new Bash({ fs });
-  return Promise.resolve({
-    toolResponse: "Hello, world!",
-    data: { files: [] }
-  });
+function createGlobHandler(fs) {
+  return async (_args) => {
+    new Bash({ fs });
+    return {
+      toolResponse: "Hello, world!",
+      data: { files: [] }
+    };
+  };
 }
 
 // src/tools/edit/handler.ts
 function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-async function editHandler(args, fs) {
-  const { file_path, old_string, new_string, replace_all = false } = args;
-  if (old_string === new_string) {
-    return {
-      toolResponse: `Error: old_string and new_string must be different.`,
-      data: {
-        path: file_path,
-        success: false,
-        replacements: 0
-      }
-    };
-  }
-  try {
-    const exists = await fs.exists(file_path);
-    if (!exists) {
+function createEditHandler(fs) {
+  return async (args) => {
+    const { file_path, old_string, new_string, replace_all = false } = args;
+    if (old_string === new_string) {
       return {
-        toolResponse: `Error: File "${file_path}" does not exist.`,
-        data: {
-          path: file_path,
-          success: false,
-          replacements: 0
-        }
+        toolResponse: `Error: old_string and new_string must be different.`,
+        data: { path: file_path, success: false, replacements: 0 }
       };
     }
-    const content = await fs.readFile(file_path);
-    if (!content.includes(old_string)) {
+    try {
+      const exists = await fs.exists(file_path);
+      if (!exists) {
+        return {
+          toolResponse: `Error: File "${file_path}" does not exist.`,
+          data: { path: file_path, success: false, replacements: 0 }
+        };
+      }
+      const content = await fs.readFile(file_path);
+      if (!content.includes(old_string)) {
+        return {
+          toolResponse: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
+          data: { path: file_path, success: false, replacements: 0 }
+        };
+      }
+      const escapedOldString = escapeRegExp(old_string);
+      const globalRegex = new RegExp(escapedOldString, "g");
+      const occurrences = (content.match(globalRegex) || []).length;
+      if (!replace_all && occurrences > 1) {
+        return {
+          toolResponse: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
+          data: { path: file_path, success: false, replacements: 0 }
+        };
+      }
+      let newContent;
+      let replacements;
+      if (replace_all) {
+        newContent = content.split(old_string).join(new_string);
+        replacements = occurrences;
+      } else {
+        const index = content.indexOf(old_string);
+        newContent = content.slice(0, index) + new_string + content.slice(index + old_string.length);
+        replacements = 1;
+      }
+      await fs.writeFile(file_path, newContent);
+      const summary = replace_all ? `Replaced ${replacements} occurrence(s)` : `Replaced 1 occurrence`;
       return {
-        toolResponse: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
-        data: {
-          path: file_path,
-          success: false,
-          replacements: 0
-        }
+        toolResponse: `${summary} in ${file_path}`,
+        data: { path: file_path, success: true, replacements }
       };
-    }
-    const escapedOldString = escapeRegExp(old_string);
-    const globalRegex = new RegExp(escapedOldString, "g");
-    const occurrences = (content.match(globalRegex) || []).length;
-    if (!replace_all && occurrences > 1) {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
       return {
-        toolResponse: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
-        data: {
-          path: file_path,
-          success: false,
-          replacements: 0
-        }
+        toolResponse: `Error editing file "${file_path}": ${message}`,
+        data: { path: file_path, success: false, replacements: 0 }
       };
     }
-    let newContent;
-    let replacements;
-    if (replace_all) {
-      newContent = content.split(old_string).join(new_string);
-      replacements = occurrences;
-    } else {
-      const index = content.indexOf(old_string);
-      newContent = content.slice(0, index) + new_string + content.slice(index + old_string.length);
-      replacements = 1;
-    }
-    await fs.writeFile(file_path, newContent);
-    const summary = replace_all ? `Replaced ${replacements} occurrence(s)` : `Replaced 1 occurrence`;
-    return {
-      toolResponse: `${summary} in ${file_path}`,
-      data: {
-        path: file_path,
-        success: true,
-        replacements
-      }
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return {
-      toolResponse: `Error editing file "${file_path}": ${message}`,
-      data: {
-        path: file_path,
-        success: false,
-        replacements: 0
-      }
-    };
-  }
+  };
 }
-var handleBashTool = (bashOptions) => async (args, _context) => {
+var createBashHandler = (bashOptions) => async (args, _context) => {
   const { command } = args;
   const mergedOptions = {
     ...bashOptions,
@@ -1408,6 +1336,6 @@ var toTree = async (fs, opts = {}) => {
   return base + subtree;
 };
 
-export { AGENT_HANDLER_NAMES, ZeitlichPlugin, askUserQuestionTool, bashTool, createAgentStateManager, createSession, createSharedActivities, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskTool, createTaskUpdateHandler, createThreadManager, createToolRouter, defineSubagent, defineTool, editHandler, editTool, getStateQuery, globHandler, globTool, grepTool, handleAskUserQuestionToolResult, handleBashTool, hasNoOtherToolCalls, invokeModel, isTerminalStatus, readTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, writeTool };
+export { AGENT_HANDLER_NAMES, ZeitlichPlugin, askUserQuestionTool, bashTool, createAgentStateManager, createAskUserQuestionHandler, createBashHandler, createBashToolDescription, createEditHandler, createGlobHandler, createSession, createSharedActivities, createSubagentTool, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createToolRouter, defineSubagent, defineTool, editTool, getStateQuery, globTool, grepTool, hasNoOtherToolCalls, invokeModel, isTerminalStatus, proxyDefaultThreadOps, readTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, withAutoAppend, writeTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map