zeitlich 0.2.3 → 0.2.5

package/dist/workflow.js

@@ -2,38 +2,38 @@ import { defineQuery, proxyActivities, setHandler, uuid4, workflowInfo, executeC
 import z3, { z } from 'zod';
 
 // src/lib/session.ts
-var TASK_TOOL = "Task";
-function buildTaskDescription(subagents) {
-  const subagentList = subagents.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
-  return `Launch a new agent to handle complex, multi-step tasks autonomously.
+var SUBAGENT_TOOL = "Subagent";
+function buildSubagentDescription(subagents) {
+  const subagentList = subagents.map((s) => `- **${s.agentName}**: ${s.description}`).join("\n");
+  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);
+  const names = subagents.map((s) => s.agentName);
   return {
-    name: TASK_TOOL,
-    description: buildTaskDescription(subagents),
+    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"),
@@ -41,16 +41,16 @@ function createTaskTool(subagents) {
     })
   };
 }
-function createTaskHandler(subagents) {
-  const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } = workflowInfo();
+function createSubagentHandler(subagents) {
+  const { taskQueue: parentTaskQueue } = workflowInfo();
   return async (args) => {
-    const config = subagents.find((s) => s.name === args.subagent);
+    const config = subagents.find((s) => s.agentName === args.subagent);
     if (!config) {
       throw new Error(
-        `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.name).join(", ")}`
+        `Unknown subagent: ${args.subagent}. Available: ${subagents.map((s) => s.agentName).join(", ")}`
       );
     }
-    const childWorkflowId = `${parentWorkflowId}-${args.subagent}-${uuid4()}`;
+    const childWorkflowId = `${args.subagent}-${uuid4()}`;
     const input = {
       prompt: args.prompt,
       ...config.context && { context: config.context }
@@ -60,15 +60,11 @@ 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
     };
   };
 }
@@ -82,31 +78,36 @@ function createToolRouter(options) {
   }
   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),
-      ...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) ?? {};
+    const enabledSubagents = options.subagents.filter(
+      (s) => s.enabled !== false
+    );
+    if (enabledSubagents.length > 0) {
+      const subagentHooksMap = /* @__PURE__ */ new Map();
+      for (const s of enabledSubagents) {
+        if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
+      }
+      const resolveSubagentName = (args) => args.subagent;
+      toolMap.set("Subagent", {
+        ...createSubagentTool(enabledSubagents),
+        handler: createSubagentHandler(enabledSubagents),
+        ...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) ?? {};
+            }
           }
         }
-      }
-    });
+      });
+    }
   }
   async function processToolCall(toolCall, turn, handlerContext) {
     const startTime = Date.now();
@@ -387,11 +388,19 @@ var createSession = async ({
   subagents,
   tools = {},
   processToolsInParallel = true,
-  hooks = {}
+  hooks = {},
+  appendSystemPrompt = true,
+  systemPrompt
 }) => {
+  const {
+    appendToolResult,
+    appendHumanMessage,
+    initializeThread,
+    appendSystemMessage
+  } = threadOps ?? proxyDefaultThreadOps();
   const toolRouter = createToolRouter({
     tools,
-    appendToolResult: threadOps.appendToolResult,
+    appendToolResult,
     threadId,
     hooks,
     subagents,
@@ -418,35 +427,32 @@ var createSession = async ({
         });
       }
       stateManager.setTools(toolRouter.getToolDefinitions());
-      await threadOps.initializeThread(threadId);
-      await threadOps.appendHumanMessage(threadId, await buildContextMessage());
+      await initializeThread(threadId);
+      if (appendSystemPrompt && systemPrompt && systemPrompt.trim() !== "") {
+        await appendSystemMessage(threadId, systemPrompt);
+      }
+      await 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 threadOps.parseToolCalls(message);
           const parsedToolCalls = [];
           for (const tc of rawToolCalls) {
             try {
               parsedToolCalls.push(toolRouter.parseToolCall(tc));
             } catch (error) {
-              await threadOps.appendToolResult({
+              await appendToolResult({
                 threadId,
                 toolCallId: tc.id ?? "",
                 toolName: tc.name,
@@ -494,7 +500,7 @@ function proxyDefaultThreadOps(options) {
     initializeThread: activities.initializeThread,
     appendHumanMessage: activities.appendHumanMessage,
     appendToolResult: activities.appendToolResult,
-    parseToolCalls: activities.parseToolCalls
+    appendSystemMessage: activities.appendSystemMessage
   };
 }
 
@@ -961,6 +967,6 @@ Use this tool to:
   strict: true
 };
 
-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 };
+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 };
 //# sourceMappingURL=workflow.js.map
 //# sourceMappingURL=workflow.js.map