zeitlich 0.2.2 → 0.2.3

package/dist/workflow.js

@@ -1,5 +1,5 @@
 import { defineQuery, proxyActivities, setHandler, uuid4, workflowInfo, executeChild } from '@temporalio/workflow';
-import z5, { z } from 'zod';
+import z3, { z } from 'zod';
 
 // src/lib/session.ts
 var TASK_TOOL = "Task";
@@ -34,10 +34,10 @@ function createTaskTool(subagents) {
   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")
+    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")
     })
   };
 }
@@ -72,107 +72,15 @@ function createTaskHandler(subagents) {
     };
   };
 }
-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) {
@@ -200,24 +108,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);
@@ -233,6 +123,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"
@@ -254,6 +145,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"
@@ -267,14 +159,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);
@@ -320,11 +220,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,
@@ -354,11 +257,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);
@@ -369,13 +272,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,
@@ -414,19 +318,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) {
@@ -463,51 +376,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
   });
@@ -532,15 +418,8 @@ 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) {
@@ -561,54 +440,25 @@ var createSession = async ({
             exitReason = "completed";
             return message;
           }
-          const rawToolCalls = await parseToolCalls(message);
+          const rawToolCalls = await threadOps.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;
@@ -627,6 +477,26 @@ 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,
+    parseToolCalls: activities.parseToolCalls
+  };
+}
 
 // src/lib/types.ts
 function isTerminalStatus(status) {
@@ -763,18 +633,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")
       })
     )
   }),
@@ -852,7 +722,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
 
@@ -862,7 +732,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
@@ -895,6 +765,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 = {
@@ -917,8 +841,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")
   })
 };
 
@@ -941,12 +865,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),
@@ -957,11 +881,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")
   })
 };
 
@@ -1009,7 +933,34 @@ 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
+};
 
-export { AGENT_HANDLER_NAMES, askUserQuestionTool, bashTool, createAgentStateManager, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskTool, createTaskUpdateHandler, createToolRouter, defineSubagent, defineTool, editTool, globTool, grepTool, hasNoOtherToolCalls, isTerminalStatus, readTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeTool };
+export { AGENT_HANDLER_NAMES, askUserQuestionTool, bashTool, createAgentStateManager, createBashToolDescription, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskTool, createTaskUpdateHandler, createToolRouter, defineSubagent, defineTool, editTool, globTool, grepTool, hasNoOtherToolCalls, isTerminalStatus, proxyDefaultThreadOps, readTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeTool };
 //# sourceMappingURL=workflow.js.map
 //# sourceMappingURL=workflow.js.map