zeitlich 0.2.0 → 0.2.2

package/dist/index.js

@@ -1,7 +1,7 @@
-import { defineQuery, proxyActivities, setHandler, workflowInfo, uuid4, executeChild } from '@temporalio/workflow';
-import z4, { z } from 'zod';
+import { defineQuery, proxyActivities, setHandler, uuid4, workflowInfo, executeChild } from '@temporalio/workflow';
+import z5, { z } from 'zod';
 import { SimplePlugin } from '@temporalio/plugin';
-import { mapStoredMessageToChatMessage, mapStoredMessagesToChatMessages, AIMessage, SystemMessage, ToolMessage, HumanMessage } from '@langchain/core/messages';
+import { SystemMessage, ToolMessage, AIMessage, HumanMessage, mapStoredMessageToChatMessage, mapStoredMessagesToChatMessages } from '@langchain/core/messages';
 import crypto from 'crypto';
 import { Context } from '@temporalio/activity';
 import { Bash } from 'just-bash';
@@ -39,10 +39,10 @@ function createTaskTool(subagents) {
   return {
     name: TASK_TOOL,
     description: buildTaskDescription(subagents),
-    schema: z4.object({
-      subagent: z4.enum(names).describe("The type of subagent to launch"),
-      description: z4.string().describe("A short (3-5 word) description of the task"),
-      prompt: z4.string().describe("The task for the agent to perform")
+    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")
     })
   };
 }
@@ -56,16 +56,21 @@ function createTaskHandler(subagents) {
       );
     }
     const childWorkflowId = `${parentWorkflowId}-${args.subagent}-${uuid4()}`;
-    const childResult = await executeChild(config.workflowType, {
+    const input = {
+      prompt: args.prompt,
+      ...config.context && { context: config.context }
+    };
+    const childOpts = {
       workflowId: childWorkflowId,
-      args: [{ prompt: args.prompt }],
+      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 content = typeof validated === "string" ? validated : JSON.stringify(validated, null, 2);
+    const toolResponse = typeof validated === "string" ? validated : JSON.stringify(validated, null, 2);
     return {
-      content,
-      result: {
+      toolResponse,
+      data: {
         result: validated,
         childWorkflowId
       }
@@ -74,12 +79,28 @@ function createTaskHandler(subagents) {
 }
 var createBashToolDescription = ({
   fileTree
-}) => `tool to execute bash commands, the file tree is: ${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: "tool to execute bash commands",
-  schema: z4.object({
-    command: z4.string().describe("stringified command to be executed inside the 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
 };
@@ -124,17 +145,17 @@ var taskCreateTool = {
   - 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: z4.object({
-    subject: z4.string().describe(
+  schema: z5.object({
+    subject: z5.string().describe(
       'A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")'
     ),
-    description: z4.string().describe(
+    description: z5.string().describe(
       "Detailed description of what needs to be done, including context and acceptance criteria"
     ),
-    activeForm: z4.string().describe(
+    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: z4.record(z4.string(), z4.string()).describe("Arbitrary key-value pairs for tracking")
+    metadata: z5.record(z5.string(), z5.string()).describe("Arbitrary key-value pairs for tracking")
   })
 };
 
@@ -158,9 +179,30 @@ function createToolRouter(options) {
     toolMap.set(tool.name, tool);
   }
   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)
+      handler: createTaskHandler(options.subagents),
+      ...subagentHooksMap.size > 0 && {
+        hooks: {
+          onPreToolUse: async (ctx) => {
+            const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
+            return hooks?.onPreExecution?.(ctx) ?? {};
+          },
+          onPostToolUse: async (ctx) => {
+            const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
+            await hooks?.onPostExecution?.(ctx);
+          },
+          onPostToolUseFailure: async (ctx) => {
+            const hooks = subagentHooksMap.get(resolveSubagentName(ctx.args));
+            return hooks?.onExecutionFailure?.(ctx) ?? {};
+          }
+        }
+      }
     });
   }
   if (options.buildInTools) {
@@ -183,6 +225,8 @@ function createToolRouter(options) {
   }
   async function processToolCall(toolCall, turn, handlerContext) {
     const startTime = Date.now();
+    const tool = toolMap.get(toolCall.name);
+    const toolHooks = tool?.hooks;
     let effectiveArgs = toolCall.args;
     if (options.hooks?.onPreToolUse) {
       const preResult = await options.hooks.onPreToolUse({
@@ -205,7 +249,27 @@ function createToolRouter(options) {
         effectiveArgs = preResult.modifiedArgs;
       }
     }
-    const tool = toolMap.get(toolCall.name);
+    if (toolHooks?.onPreToolUse) {
+      const preResult = await toolHooks.onPreToolUse({
+        args: effectiveArgs,
+        threadId: options.threadId,
+        turn
+      });
+      if (preResult?.skip) {
+        await appendToolResult({
+          threadId: options.threadId,
+          toolCallId: toolCall.id,
+          content: JSON.stringify({
+            skipped: true,
+            reason: "Skipped by tool PreToolUse hook"
+          })
+        });
+        return null;
+      }
+      if (preResult?.modifiedArgs !== void 0) {
+        effectiveArgs = preResult.modifiedArgs;
+      }
+    }
     let result;
     let content;
     try {
@@ -214,30 +278,50 @@ function createToolRouter(options) {
           effectiveArgs,
           handlerContext ?? {}
         );
-        result = response.result;
-        content = response.content;
+        result = response.data;
+        content = response.toolResponse;
       } else {
         result = { error: `Unknown tool: ${toolCall.name}` };
         content = JSON.stringify(result, null, 2);
       }
     } catch (error) {
-      if (options.hooks?.onPostToolUseFailure) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      let recovered = false;
+      if (toolHooks?.onPostToolUseFailure) {
+        const failureResult = await toolHooks.onPostToolUseFailure({
+          args: effectiveArgs,
+          error: err,
+          threadId: options.threadId,
+          turn
+        });
+        if (failureResult?.fallbackContent !== void 0) {
+          content = failureResult.fallbackContent;
+          result = { error: String(error), recovered: true };
+          recovered = true;
+        } else if (failureResult?.suppress) {
+          content = JSON.stringify({ error: String(error), suppressed: true });
+          result = { error: String(error), suppressed: true };
+          recovered = true;
+        }
+      }
+      if (!recovered && options.hooks?.onPostToolUseFailure) {
         const failureResult = await options.hooks.onPostToolUseFailure({
           toolCall,
-          error: error instanceof Error ? error : new Error(String(error)),
+          error: err,
           threadId: options.threadId,
           turn
         });
         if (failureResult?.fallbackContent !== void 0) {
           content = failureResult.fallbackContent;
           result = { error: String(error), recovered: true };
+          recovered = true;
         } else if (failureResult?.suppress) {
           content = JSON.stringify({ error: String(error), suppressed: true });
           result = { error: String(error), suppressed: true };
-        } else {
-          throw error;
+          recovered = true;
         }
-      } else {
+      }
+      if (!recovered) {
         throw error;
       }
     }
@@ -249,10 +333,19 @@ function createToolRouter(options) {
     const toolResult = {
       toolCallId: toolCall.id,
       name: toolCall.name,
-      result
+      data: result
     };
+    const durationMs = Date.now() - startTime;
+    if (toolHooks?.onPostToolUse) {
+      await toolHooks.onPostToolUse({
+        args: effectiveArgs,
+        result,
+        threadId: options.threadId,
+        turn,
+        durationMs
+      });
+    }
     if (options.hooks?.onPostToolUse) {
-      const durationMs = Date.now() - startTime;
       await options.hooks.onPostToolUse({
         toolCall,
         result: toolResult,
@@ -333,12 +426,12 @@ function createToolRouter(options) {
         await appendToolResult({
           threadId: options.threadId,
           toolCallId: toolCall.id,
-          content: response.content
+          content: response.toolResponse
         });
         return {
           toolCallId: toolCall.id,
           name: toolCall.name,
-          result: response.result
+          data: response.data ?? null
         };
       };
       if (options.parallel) {
@@ -364,6 +457,12 @@ function createToolRouter(options) {
     }
   };
 }
+function defineTool(tool) {
+  return tool;
+}
+function defineSubagent(config) {
+  return config;
+}
 function hasNoOtherToolCalls(toolCalls, excludeName) {
   return toolCalls.filter((tc) => tc.name !== excludeName).length === 0;
 }
@@ -468,17 +567,47 @@ var createSession = async ({
             return message;
           }
           const rawToolCalls = await parseToolCalls(message);
-          const parsedToolCalls = rawToolCalls.filter((tc) => tc.name !== "Task").map((tc) => toolRouter.parseToolCall(tc));
-          const taskToolCalls = subagents && subagents.length > 0 ? rawToolCalls.filter((tc) => tc.name === "Task").map((tc) => {
-            const parsedArgs = createTaskTool(subagents).schema.parse(
-              tc.args
-            );
-            return {
-              id: tc.id ?? "",
-              name: tc.name,
-              args: parsedArgs
-            };
-          }) : [];
+          const parsedToolCalls = [];
+          for (const tc of rawToolCalls.filter(
+            (tc2) => tc2.name !== "Task"
+          )) {
+            try {
+              parsedToolCalls.push(toolRouter.parseToolCall(tc));
+            } catch (error) {
+              await appendToolResult({
+                threadId,
+                toolCallId: tc.id ?? "",
+                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],
             {
@@ -508,8 +637,6 @@ var createSession = async ({
 function isTerminalStatus(status) {
   return status === "COMPLETED" || status === "FAILED" || status === "CANCELLED";
 }
-
-// src/lib/state-manager.ts
 var getStateQuery = defineQuery("getState");
 function createAgentStateManager(initialState) {
   let status = initialState?.status ?? "RUNNING";
@@ -604,7 +731,13 @@ function createAgentStateManager(initialState) {
       version++;
     },
     setTools(newTools) {
-      tools = newTools;
+      tools = newTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        schema: z.toJSONSchema(tool.schema),
+        strict: tool.strict,
+        max_uses: tool.max_uses
+      }));
     },
     deleteTask(id) {
       const deleted = tasks.delete(id);
@@ -635,18 +768,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: z4.object({
-    questions: z4.array(
-      z4.object({
-        question: z4.string().describe("The full question text to display"),
-        header: z4.string().describe("Short label for the question (max 12 characters)"),
-        options: z4.array(
-          z4.object({
-            label: z4.string(),
-            description: z4.string()
+  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()
           })
         ).min(0).max(4).describe("Array of 0-4 choices, each with label and description"),
-        multiSelect: z4.boolean().describe("If true, users can select multiple options")
+        multiSelect: z5.boolean().describe("If true, users can select multiple options")
       })
     )
   }),
@@ -767,15 +900,10 @@ IMPORTANT:
   }),
   strict: true
 };
-
-// src/tools/task-create/handler.ts
-function createTaskCreateHandler({
-  stateManager,
-  idGenerator
-}) {
+function createTaskCreateHandler(stateManager) {
   return (args) => {
     const task = {
-      id: idGenerator(),
+      id: uuid4(),
       subject: args.subject,
       description: args.description,
       activeForm: args.activeForm,
@@ -786,16 +914,16 @@ function createTaskCreateHandler({
     };
     stateManager.setTask(task);
     return {
-      content: JSON.stringify(task, null, 2),
-      result: task
+      toolResponse: JSON.stringify(task, null, 2),
+      data: task
     };
   };
 }
 var taskGetTool = {
   name: "TaskGet",
   description: `Retrieve full task details including dependencies.`,
-  schema: z4.object({
-    taskId: z4.string().describe("The ID of the task to get")
+  schema: z5.object({
+    taskId: z5.string().describe("The ID of the task to get")
   })
 };
 
@@ -805,20 +933,20 @@ function createTaskGetHandler(stateManager) {
     const task = stateManager.getTask(args.taskId) ?? null;
     if (!task) {
       return {
-        content: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
-        result: null
+        toolResponse: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        data: null
       };
     }
     return {
-      content: JSON.stringify(task, null, 2),
-      result: task
+      toolResponse: JSON.stringify(task, null, 2),
+      data: task
     };
   };
 }
 var taskListTool = {
   name: "TaskList",
   description: `List all tasks with current state.`,
-  schema: z4.object({})
+  schema: z5.object({})
 };
 
 // src/tools/task-list/handler.ts
@@ -826,19 +954,19 @@ function createTaskListHandler(stateManager) {
   return (_args) => {
     const taskList = stateManager.getTasks();
     return {
-      content: JSON.stringify(taskList, null, 2),
-      result: taskList
+      toolResponse: JSON.stringify(taskList, null, 2),
+      data: taskList
     };
   };
 }
 var taskUpdateTool = {
   name: "TaskUpdate",
   description: `Update status, add blockers, modify details.`,
-  schema: z4.object({
-    taskId: z4.string().describe("The ID of the task to get"),
-    status: z4.enum(["pending", "in_progress", "completed"]).describe("The status of the task"),
-    addBlockedBy: z4.array(z4.string()).describe("The IDs of the tasks that are blocking this task"),
-    addBlocks: z4.array(z4.string()).describe("The IDs of the tasks that this task is blocking")
+  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")
   })
 };
 
@@ -848,8 +976,8 @@ function createTaskUpdateHandler(stateManager) {
     const task = stateManager.getTask(args.taskId);
     if (!task) {
       return {
-        content: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
-        result: null
+        toolResponse: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        data: null
       };
     }
     if (args.status) {
@@ -881,8 +1009,8 @@ function createTaskUpdateHandler(stateManager) {
     }
     stateManager.setTask(task);
     return {
-      content: JSON.stringify(task, null, 2),
-      result: task
+      toolResponse: JSON.stringify(task, null, 2),
+      data: task
     };
   };
 }
@@ -1089,13 +1217,13 @@ var handleAskUserQuestionToolResult = async (args) => {
       }
     }).toDict()
   );
-  return { content: "Question submitted", result: { chatMessages: messages } };
+  return { toolResponse: "Question submitted", data: { chatMessages: messages } };
 };
 async function globHandler(_args, fs) {
   new Bash({ fs });
   return Promise.resolve({
-    content: "Hello, world!",
-    result: { files: [] }
+    toolResponse: "Hello, world!",
+    data: { files: [] }
   });
 }
 
@@ -1107,8 +1235,8 @@ async function editHandler(args, fs) {
   const { file_path, old_string, new_string, replace_all = false } = args;
   if (old_string === new_string) {
     return {
-      content: `Error: old_string and new_string must be different.`,
-      result: {
+      toolResponse: `Error: old_string and new_string must be different.`,
+      data: {
         path: file_path,
         success: false,
         replacements: 0
@@ -1119,8 +1247,8 @@ async function editHandler(args, fs) {
     const exists = await fs.exists(file_path);
     if (!exists) {
       return {
-        content: `Error: File "${file_path}" does not exist.`,
-        result: {
+        toolResponse: `Error: File "${file_path}" does not exist.`,
+        data: {
           path: file_path,
           success: false,
           replacements: 0
@@ -1130,8 +1258,8 @@ async function editHandler(args, fs) {
     const content = await fs.readFile(file_path);
     if (!content.includes(old_string)) {
       return {
-        content: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
-        result: {
+        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
@@ -1143,8 +1271,8 @@ async function editHandler(args, fs) {
     const occurrences = (content.match(globalRegex) || []).length;
     if (!replace_all && occurrences > 1) {
       return {
-        content: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
-        result: {
+        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
@@ -1164,8 +1292,8 @@ async function editHandler(args, fs) {
     await fs.writeFile(file_path, newContent);
     const summary = replace_all ? `Replaced ${replacements} occurrence(s)` : `Replaced 1 occurrence`;
     return {
-      content: `${summary} in ${file_path}`,
-      result: {
+      toolResponse: `${summary} in ${file_path}`,
+      data: {
         path: file_path,
         success: true,
         replacements
@@ -1174,8 +1302,8 @@ async function editHandler(args, fs) {
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     return {
-      content: `Error editing file "${file_path}": ${message}`,
-      result: {
+      toolResponse: `Error editing file "${file_path}": ${message}`,
+      data: {
         path: file_path,
         success: false,
         replacements: 0
@@ -1183,28 +1311,35 @@ async function editHandler(args, fs) {
     };
   }
 }
-var handleBashTool = (fs) => async (args, _context) => {
+var handleBashTool = (bashOptions) => async (args, _context) => {
   const { command } = args;
-  const bashOptions = fs ? { fs } : {};
-  const bash = new Bash(bashOptions);
+  const mergedOptions = {
+    ...bashOptions,
+    executionLimits: {
+      maxStringLength: 52428800,
+      // 50MB default
+      ...bashOptions.executionLimits
+    }
+  };
+  const bash = new Bash(mergedOptions);
   try {
     const { exitCode, stderr, stdout } = await bash.exec(command);
     const bashExecOut = { exitCode, stderr, stdout };
     return {
-      content: `Exit code: ${exitCode}
+      toolResponse: `Exit code: ${exitCode}
 
 stdout:
 ${stdout}
 
 stderr:
 ${stderr}`,
-      result: bashExecOut
+      data: bashExecOut
     };
   } catch (error) {
     const err = error instanceof Error ? error : new Error("Unknown error");
     return {
-      content: `Error executing bash command: ${err.message}`,
-      result: null
+      toolResponse: `Error executing bash command: ${err.message}`,
+      data: null
     };
   }
 };
@@ -1273,6 +1408,6 @@ var toTree = async (fs, opts = {}) => {
   return base + subtree;
 };
 
-export { AGENT_HANDLER_NAMES, ZeitlichPlugin, askUserQuestionTool, bashTool, createAgentStateManager, createSession, createSharedActivities, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskTool, createTaskUpdateHandler, createToolRouter, editHandler, editTool, globHandler, globTool, grepTool, handleAskUserQuestionToolResult, handleBashTool, hasNoOtherToolCalls, invokeModel, isTerminalStatus, readTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, writeTool };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map