zeitlich 0.2.6 → 0.2.8

package/dist/workflow.js

@@ -1,5 +1,5 @@
-import { defineQuery, proxyActivities, setHandler, uuid4, workflowInfo, executeChild } from '@temporalio/workflow';
-import z3, { z } from 'zod';
+import { setHandler, defineUpdate, condition, proxyActivities, defineQuery, uuid4, workflowInfo, executeChild } from '@temporalio/workflow';
+import z13, { z } from 'zod';
 
 // src/lib/session.ts
 var SUBAGENT_TOOL = "Subagent";
@@ -34,10 +34,10 @@ function createSubagentTool(subagents) {
   return {
     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")
+    schema: z13.object({
+      subagent: z13.enum(names).describe("The type of subagent to launch"),
+      description: z13.string().describe("A short (3-5 word) description of the task"),
+      prompt: z13.string().describe("The task for the agent to perform")
     })
   };
 }
@@ -60,11 +60,12 @@ function createSubagentHandler(subagents) {
       args: [input],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
-    const { toolResponse, data } = typeof config.workflow === "string" ? await executeChild(config.workflow, childOpts) : await executeChild(config.workflow, childOpts);
+    const { toolResponse, data, usage } = 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: validated
+      data: validated,
+      ...usage && { usage }
     };
   };
 }
@@ -76,20 +77,17 @@ function createToolRouter(options) {
   for (const [_key, tool] of Object.entries(options.tools)) {
     toolMap.set(tool.name, tool);
   }
-  const isEnabled = (tool) => tool.enabled !== false;
+  const isEnabled = (tool) => tool.enabled?.() ?? true;
   if (options.subagents) {
-    const enabledSubagents = options.subagents.filter(
-      (s) => s.enabled !== false
-    );
-    if (enabledSubagents.length > 0) {
+    if (options.subagents.length > 0) {
       const subagentHooksMap = /* @__PURE__ */ new Map();
-      for (const s of enabledSubagents) {
+      for (const s of options.subagents) {
         if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
       }
       const resolveSubagentName = (args) => args.subagent;
       toolMap.set("Subagent", {
-        ...createSubagentTool(enabledSubagents),
-        handler: createSubagentHandler(enabledSubagents),
+        ...createSubagentTool(options.subagents),
+        handler: createSubagentHandler(options.subagents),
         ...subagentHooksMap.size > 0 && {
           hooks: {
             onPreToolUse: async (ctx) => {
@@ -380,6 +378,7 @@ function hasNoOtherToolCalls(toolCalls, excludeName) {
 var createSession = async ({
   threadId,
   agentName,
+  description,
   maxTurns = 50,
   metadata = {},
   runAgent,
@@ -390,7 +389,8 @@ var createSession = async ({
   processToolsInParallel = true,
   hooks = {},
   appendSystemPrompt = true,
-  systemPrompt
+  systemPrompt,
+  waitForInputTimeout = "48h"
 }) => {
   const {
     appendToolResult,
@@ -418,7 +418,28 @@ var createSession = async ({
     }
   };
   return {
-    runSession: async ({ stateManager }) => {
+    runSession: async ({
+      stateManager
+    }) => {
+      setHandler(
+        defineUpdate(`add${agentName}Message`),
+        async (message) => {
+          if (hooks.onPreHumanMessageAppend) {
+            await hooks.onPreHumanMessageAppend({
+              message,
+              threadId
+            });
+          }
+          await appendHumanMessage(threadId, message);
+          if (hooks.onPostHumanMessageAppend) {
+            await hooks.onPostHumanMessageAppend({
+              message,
+              threadId
+            });
+          }
+          stateManager.run();
+        }
+      );
       if (hooks.onSessionStart) {
         await hooks.onSessionStart({
           threadId,
@@ -426,7 +447,6 @@ var createSession = async ({
           metadata
         });
       }
-      stateManager.setTools(toolRouter.getToolDefinitions());
       await initializeThread(threadId);
       if (appendSystemPrompt && systemPrompt && systemPrompt.trim() !== "") {
         await appendSystemMessage(threadId, systemPrompt);
@@ -437,15 +457,25 @@ var createSession = async ({
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
-          const { message, rawToolCalls } = await runAgent({
+          stateManager.setTools(toolRouter.getToolDefinitions());
+          const { message, rawToolCalls, usage } = await runAgent({
             threadId,
             agentName,
-            metadata
+            metadata,
+            systemPrompt,
+            description
           });
+          if (usage) {
+            stateManager.updateUsage(usage);
+          }
           if (!toolRouter.hasTools() || rawToolCalls.length === 0) {
             stateManager.complete();
             exitReason = "completed";
-            return message;
+            return {
+              finalMessage: message,
+              exitReason,
+              usage: stateManager.getTotalUsage()
+            };
           }
           const parsedToolCalls = [];
           for (const tc of rawToolCalls) {
@@ -462,12 +492,27 @@ var createSession = async ({
               });
             }
           }
-          await toolRouter.processToolCalls(parsedToolCalls, {
-            turn: currentTurn
-          });
+          const toolCallResults = await toolRouter.processToolCalls(
+            parsedToolCalls,
+            {
+              turn: currentTurn
+            }
+          );
+          for (const result of toolCallResults) {
+            if (result.usage) {
+              stateManager.updateUsage(result.usage);
+            }
+          }
           if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
-            exitReason = "waiting_for_input";
-            break;
+            const conditionMet = await condition(
+              () => stateManager.getStatus() === "RUNNING",
+              waitForInputTimeout
+            );
+            if (!conditionMet) {
+              stateManager.cancel();
+              await condition(() => false, "2s");
+              break;
+            }
           }
         }
         if (stateManager.getTurns() >= maxTurns && stateManager.isRunning()) {
@@ -479,7 +524,11 @@ var createSession = async ({
       } finally {
         await callSessionEnd(exitReason, stateManager.getTurns());
       }
-      return null;
+      return {
+        finalMessage: null,
+        exitReason,
+        usage: stateManager.getTotalUsage()
+      };
     }
   };
 };
@@ -508,12 +557,19 @@ function proxyDefaultThreadOps(options) {
 function isTerminalStatus(status) {
   return status === "COMPLETED" || status === "FAILED" || status === "CANCELLED";
 }
-var getStateQuery = defineQuery("getState");
-function createAgentStateManager(initialState) {
+function createAgentStateManager({
+  initialState,
+  agentConfig
+}) {
   let status = initialState?.status ?? "RUNNING";
   let version = initialState?.version ?? 0;
   let turns = initialState?.turns ?? 0;
   let tools = initialState?.tools ?? [];
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCachedWriteTokens = 0;
+  let totalCachedReadTokens = 0;
+  let totalReasonTokens = 0;
   const tasks = new Map(initialState?.tasks);
   const {
     status: _,
@@ -533,9 +589,21 @@ function createAgentStateManager(initialState) {
       ...customState
     };
   }
-  setHandler(getStateQuery, () => {
+  setHandler(defineQuery(`get${agentConfig.agentName}State`), () => {
     return buildState();
   });
+  setHandler(
+    defineUpdate(
+      `waitFor${agentConfig.agentName}StateChange`
+    ),
+    async (lastKnownVersion) => {
+      await condition(
+        () => version > lastKnownVersion || isTerminalStatus(status),
+        "55s"
+      );
+      return buildState();
+    }
+  );
   return {
     getStatus() {
       return status;
@@ -616,6 +684,23 @@ function createAgentStateManager(initialState) {
         version++;
       }
       return deleted;
+    },
+    updateUsage(usage) {
+      totalInputTokens += usage.inputTokens ?? 0;
+      totalOutputTokens += usage.outputTokens ?? 0;
+      totalCachedWriteTokens += usage.cachedWriteTokens ?? 0;
+      totalCachedReadTokens += usage.cachedReadTokens ?? 0;
+      totalReasonTokens += usage.reasonTokens ?? 0;
+    },
+    getTotalUsage() {
+      return {
+        totalInputTokens,
+        totalOutputTokens,
+        totalCachedWriteTokens,
+        totalCachedReadTokens,
+        totalReasonTokens,
+        turns
+      };
     }
   };
 }
@@ -624,38 +709,6 @@ var AGENT_HANDLER_NAMES = {
   waitForStateChange: "waitForStateChange",
   addMessage: "addMessage"
 };
-var askUserQuestionTool = {
-  name: "AskUserQuestion",
-  description: `Use this tool when you need to ask the user questions during execution. This allows you to:
-
-1. Gather user preferences or requirements
-2. Clarify ambiguous instructions
-3. Get decisions on implementation choices as you work
-4. Offer choices to the user about what direction to take.
-
-Usage notes:
-
-* Users will always be able to select "Other" to provide custom text input
-* 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: 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: z3.boolean().describe("If true, users can select multiple options")
-      })
-    )
-  }),
-  strict: true
-};
 var globTool = {
   name: "Glob",
   description: `Search for files matching a glob pattern within the available file system.
@@ -812,17 +865,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: z3.object({
-    subject: z3.string().describe(
+  schema: z13.object({
+    subject: z13.string().describe(
       'A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")'
     ),
-    description: z3.string().describe(
+    description: z13.string().describe(
       "Detailed description of what needs to be done, including context and acceptance criteria"
     ),
-    activeForm: z3.string().describe(
+    activeForm: z13.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")
+    metadata: z13.record(z13.string(), z13.string()).describe("Arbitrary key-value pairs for tracking")
   })
 };
 function createTaskCreateHandler(stateManager) {
@@ -847,8 +900,8 @@ function createTaskCreateHandler(stateManager) {
 var taskGetTool = {
   name: "TaskGet",
   description: `Retrieve full task details including dependencies.`,
-  schema: z3.object({
-    taskId: z3.string().describe("The ID of the task to get")
+  schema: z13.object({
+    taskId: z13.string().describe("The ID of the task to get")
   })
 };
 
@@ -871,7 +924,7 @@ function createTaskGetHandler(stateManager) {
 var taskListTool = {
   name: "TaskList",
   description: `List all tasks with current state.`,
-  schema: z3.object({})
+  schema: z13.object({})
 };
 
 // src/tools/task-list/handler.ts
@@ -887,11 +940,11 @@ function createTaskListHandler(stateManager) {
 var taskUpdateTool = {
   name: "TaskUpdate",
   description: `Update status, add blockers, modify details.`,
-  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")
+  schema: z13.object({
+    taskId: z13.string().describe("The ID of the task to get"),
+    status: z13.enum(["pending", "in_progress", "completed"]).describe("The status of the task"),
+    addBlockedBy: z13.array(z13.string()).describe("The IDs of the tasks that are blocking this task"),
+    addBlocks: z13.array(z13.string()).describe("The IDs of the tasks that this task is blocking")
   })
 };
 
@@ -959,14 +1012,54 @@ Use this tool to:
 - Execute scripts and chain commands with pipes (|) or logical operators (&&, ||)
 - Inspect files and directories
 `,
-  schema: z3.object({
-    command: z3.string().describe(
+  schema: z13.object({
+    command: z13.string().describe(
       "The bash command to execute. Can include pipes (|), redirects (>, >>), logical operators (&&, ||), and shell features like command substitution $(...)."
     )
   }),
   strict: true
 };
+var askUserQuestionTool = {
+  name: "AskUserQuestion",
+  description: `Use this tool when you need to ask the user questions during execution. This allows you to:
+
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+
+* Users will always be able to select "Other" to provide custom text input
+* 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: z13.object({
+    questions: z13.array(
+      z13.object({
+        question: z13.string().describe("The full question text to display"),
+        header: z13.string().describe("Short label for the question (max 12 characters)"),
+        options: z13.array(
+          z13.object({
+            label: z13.string(),
+            description: z13.string()
+          })
+        ).min(0).max(4).describe("Array of 0-4 choices, each with label and description"),
+        multiSelect: z13.boolean().describe("If true, users can select multiple options")
+      })
+    )
+  }),
+  strict: true
+};
+
+// src/tools/ask-user-question/handler.ts
+var createAskUserQuestionHandler = () => (args) => {
+  return {
+    toolResponse: "Question submitted",
+    data: { questions: args.questions }
+  };
+};
 
-export { AGENT_HANDLER_NAMES, askUserQuestionTool, bashTool, createAgentStateManager, createBashToolDescription, createSession, createSubagentTool, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createToolRouter, defineSubagent, defineTool, editTool, globTool, grepTool, hasNoOtherToolCalls, isTerminalStatus, proxyDefaultThreadOps, readTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeTool };
+export { AGENT_HANDLER_NAMES, askUserQuestionTool, bashTool, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createSession, createSubagentTool, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createToolRouter, defineSubagent, defineTool, editTool, globTool, grepTool, hasNoOtherToolCalls, isTerminalStatus, proxyDefaultThreadOps, readTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, writeTool };
 //# sourceMappingURL=workflow.js.map
 //# sourceMappingURL=workflow.js.map