zeitlich 0.2.3 → 0.2.4

package/dist/index.cjs

@@ -14,38 +14,38 @@ var z3__default = /*#__PURE__*/_interopDefault(z3);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 
 // 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),
+    name: SUBAGENT_TOOL,
+    description: buildSubagentDescription(subagents),
     schema: z3__default.default.object({
       subagent: z3__default.default.enum(names).describe("The type of subagent to launch"),
       description: z3__default.default.string().describe("A short (3-5 word) description of the task"),
@@ -53,7 +53,7 @@ function createTaskTool(subagents) {
     })
   };
 }
-function createTaskHandler(subagents) {
+function createSubagentHandler(subagents) {
   const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } = workflow.workflowInfo();
   return async (args) => {
     const config = subagents.find((s) => s.name === args.subagent);
@@ -72,15 +72,11 @@ function createTaskHandler(subagents) {
       args: [input],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
-    const childResult = typeof config.workflow === "string" ? await workflow.executeChild(config.workflow, childOpts) : await workflow.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 workflow.executeChild(config.workflow, childOpts) : await workflow.executeChild(config.workflow, childOpts);
+    const validated = config.resultSchema ? config.resultSchema.parse(data) : null;
     return {
       toolResponse,
-      data: {
-        result: validated,
-        childWorkflowId
-      }
+      data: validated
     };
   };
 }
@@ -99,9 +95,9 @@ function createToolRouter(options) {
       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) => {
@@ -452,22 +448,16 @@ var createSession = async ({
         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 {
@@ -520,8 +510,7 @@ function proxyDefaultThreadOps(options) {
   return {
     initializeThread: activities.initializeThread,
     appendHumanMessage: activities.appendHumanMessage,
-    appendToolResult: activities.appendToolResult,
-    parseToolCalls: activities.parseToolCalls
+    appendToolResult: activities.appendToolResult
   };
 }
 
@@ -1100,6 +1089,8 @@ function createThreadManager(config) {
   };
   return Object.assign(base, helpers);
 }
+
+// src/activities.ts
 function createSharedActivities(redis) {
   return {
     async appendToolResult(config) {
@@ -1118,15 +1109,6 @@ function createSharedActivities(redis) {
     async appendHumanMessage(threadId, content) {
       const thread = createThreadManager({ redis, threadId });
       await thread.appendHumanMessage(content);
-    },
-    async parseToolCalls(storedMessage) {
-      const message = messages.mapStoredMessageToChatMessage(storedMessage);
-      const toolCalls = message.tool_calls ?? [];
-      return toolCalls.map((toolCall) => ({
-        id: toolCall.id,
-        name: toolCall.name,
-        args: toolCall.args
-      }));
     }
   };
 }
@@ -1164,9 +1146,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,
@@ -1368,10 +1355,10 @@ exports.createEditHandler = createEditHandler;
 exports.createGlobHandler = createGlobHandler;
 exports.createSession = createSession;
 exports.createSharedActivities = createSharedActivities;
+exports.createSubagentTool = createSubagentTool;
 exports.createTaskCreateHandler = createTaskCreateHandler;
 exports.createTaskGetHandler = createTaskGetHandler;
 exports.createTaskListHandler = createTaskListHandler;
-exports.createTaskTool = createTaskTool;
 exports.createTaskUpdateHandler = createTaskUpdateHandler;
 exports.createThreadManager = createThreadManager;
 exports.createToolRouter = createToolRouter;