zeitlich 0.2.21 → 0.2.23

package/dist/workflow.cjs

@@ -85,7 +85,12 @@ function createToolRouter(options) {
           result: { error: errorStr, suppressed: true }
         };
     }
-    throw workflow.ApplicationFailure.fromError(error, { nonRetryable: true });
+    return {
+      content: JSON.stringify({
+        error: "The tool encountered an error. Please try again or use a different approach."
+      }),
+      result: { error: errorStr, suppressed: true }
+    };
   }
   async function runPostHooks(toolCall, tool, toolResult, effectiveArgs, turn, durationMs) {
     if (tool?.hooks?.onPostToolUse) {
@@ -94,7 +99,8 @@ function createToolRouter(options) {
         result: toolResult.data,
         threadId: options.threadId,
         turn,
-        durationMs
+        durationMs,
+        ...toolResult.metadata && { metadata: toolResult.metadata }
       });
     }
     if (options.hooks?.onPostToolUse) {
@@ -127,6 +133,7 @@ function createToolRouter(options) {
     let result;
     let content;
     let resultAppended = false;
+    let metadata;
     try {
       if (tool) {
         const routerContext = {
@@ -142,6 +149,7 @@ function createToolRouter(options) {
         result = response.data;
         content = response.toolResponse;
         resultAppended = response.resultAppended === true;
+        metadata = response.metadata;
       } else {
         result = { error: `Unknown tool: ${toolCall.name}` };
         content = JSON.stringify(result, null, 2);
@@ -174,7 +182,8 @@ function createToolRouter(options) {
     const toolResult = {
       toolCallId: toolCall.id,
       name: toolCall.name,
-      data: result
+      data: result,
+      ...metadata && { metadata }
     };
     await runPostHooks(
       toolCall,
@@ -278,7 +287,8 @@ function createToolRouter(options) {
         return {
           toolCallId: toolCall.id,
           name: toolCall.name,
-          data: response.data
+          data: response.data,
+          ...response.metadata && { metadata: response.metadata }
         };
       };
       if (options.parallel) {
@@ -322,7 +332,7 @@ function getShortId(length = 12) {
 var SUBAGENT_TOOL_NAME = "Subagent";
 function buildSubagentDescription(subagents) {
   const subagentList = subagents.map((s) => {
-    const continuation = s.allowThreadContinuation ? "\n*(Supports thread continuation \u2014 pass a threadId to resume a previous conversation)*" : "";
+    const continuation = s.thread && s.thread !== "new" ? "\n*(Supports thread continuation \u2014 pass a threadId to resume a previous conversation)*" : "";
     return `## ${s.agentName}
 ${s.description}${continuation}`;
   }).join("\n\n");
@@ -338,7 +348,7 @@ function createSubagentTool(subagents) {
   }
   const names = subagents.map((s) => s.agentName);
   const hasThreadContinuation = subagents.some(
-    (s) => s.allowThreadContinuation
+    (s) => s.thread && s.thread !== "new"
   );
   const baseFields = {
     subagent: z14__default.default.enum(names).describe("The type of subagent to launch"),
@@ -357,9 +367,25 @@ function createSubagentTool(subagents) {
     schema
   };
 }
+var childResultSignal = workflow.defineSignal("childResult");
+var destroySandboxSignal = workflow.defineSignal("destroySandbox");
+
+// src/lib/subagent/handler.ts
+function resolveSandboxConfig(config) {
+  if (!config || config === "none") return { source: "none" };
+  if (config === "inherit") return { source: "inherit" };
+  if (config === "own") return { source: "own" };
+  return { source: "own", shutdown: config.shutdown };
+}
 function createSubagentHandler(subagents) {
   const { taskQueue: parentTaskQueue } = workflow.workflowInfo();
-  return async (args, context) => {
+  const childResults = /* @__PURE__ */ new Map();
+  const pendingDestroys = /* @__PURE__ */ new Map();
+  const threadSandboxes = /* @__PURE__ */ new Map();
+  workflow.setHandler(childResultSignal, ({ childWorkflowId, result }) => {
+    childResults.set(childWorkflowId, result);
+  });
+  const handler = async (args, context) => {
     const config = subagents.find((s) => s.agentName === args.subagent);
     if (!config) {
       throw new Error(
@@ -368,29 +394,77 @@ function createSubagentHandler(subagents) {
     }
     const childWorkflowId = `${args.subagent}-${getShortId()}`;
     const { sandboxId: parentSandboxId } = context;
-    const inheritSandbox = config.sandbox !== "own" && !!parentSandboxId;
+    const sandboxCfg = resolveSandboxConfig(config.sandbox);
+    if (sandboxCfg.source === "inherit" && !parentSandboxId) {
+      throw new Error(
+        `Subagent "${config.agentName}" is configured with sandbox: "inherit" but the parent has no sandbox`
+      );
+    }
+    const threadMode = config.thread ?? "new";
+    const allowsContinuation = threadMode !== "new";
+    const continuationThreadId = args.threadId && allowsContinuation ? args.threadId : void 0;
+    let thread;
+    if (continuationThreadId) {
+      thread = { mode: threadMode, threadId: continuationThreadId };
+    }
+    let sandbox;
+    if (sandboxCfg.source === "inherit" && parentSandboxId) {
+      sandbox = { mode: "inherit", sandboxId: parentSandboxId };
+    } else if (sandboxCfg.source === "own") {
+      const prevSbId = continuationThreadId ? threadSandboxes.get(continuationThreadId) : void 0;
+      if (prevSbId) {
+        sandbox = { mode: "fork", sandboxId: prevSbId };
+      }
+    }
     const workflowInput = {
-      ...args.threadId && args.threadId !== null && config.allowThreadContinuation && {
-        previousThreadId: args.threadId
-      },
-      ...inheritSandbox && { sandboxId: parentSandboxId }
+      ...thread && { thread },
+      ...sandbox && { sandbox },
+      ...sandboxCfg.shutdown && { sandboxShutdown: sandboxCfg.shutdown }
     };
+    const resolvedContext = config.context === void 0 ? void 0 : typeof config.context === "function" ? config.context() : config.context;
     const childOpts = {
       workflowId: childWorkflowId,
-      args: config.context === void 0 ? [args.prompt, workflowInput] : [args.prompt, workflowInput, config.context],
+      args: resolvedContext === void 0 ? [args.prompt, workflowInput] : [args.prompt, workflowInput, resolvedContext],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
+    const childHandle = await workflow.startChild(config.workflow, childOpts);
+    const usesOwnSandbox = sandboxCfg.source === "own" || allowsContinuation && sandboxCfg.source !== "inherit";
+    if (usesOwnSandbox) {
+      pendingDestroys.set(childWorkflowId, childHandle);
+    }
+    await Promise.race([
+      workflow.condition(() => childResults.has(childWorkflowId)),
+      childHandle.result()
+    ]);
+    if (!childResults.has(childWorkflowId)) {
+      await workflow.condition(() => childResults.has(childWorkflowId));
+    }
+    const childResult = childResults.get(childWorkflowId);
+    childResults.delete(childWorkflowId);
+    if (!childResult) {
+      return {
+        toolResponse: "Subagent workflow did not signal a result",
+        data: null
+      };
+    }
     const {
       toolResponse,
       data,
       usage,
-      threadId: childThreadId
-    } = typeof config.workflow === "string" ? await workflow.executeChild(config.workflow, childOpts) : await workflow.executeChild(config.workflow, childOpts);
+      threadId: childThreadId,
+      sandboxId: childSandboxId,
+      metadata
+    } = childResult;
+    if (allowsContinuation && childSandboxId && childThreadId) {
+      threadSandboxes.set(childThreadId, childSandboxId);
+    }
     if (!toolResponse) {
       return {
         toolResponse: "Subagent workflow returned no response",
         data: null,
-        ...usage && { usage }
+        ...usage && { usage },
+        ...childSandboxId && { sandboxId: childSandboxId },
+        ...metadata && { metadata }
       };
     }
     const validated = config.resultSchema ? config.resultSchema.safeParse(data) : null;
@@ -398,11 +472,13 @@ function createSubagentHandler(subagents) {
       return {
         toolResponse: `Subagent workflow returned invalid data: ${validated.error.message}`,
         data: null,
-        ...usage && { usage }
+        ...usage && { usage },
+        ...childSandboxId && { sandboxId: childSandboxId },
+        ...metadata && { metadata }
       };
     }
     let finalToolResponse = toolResponse;
-    if (config.allowThreadContinuation && childThreadId) {
+    if (allowsContinuation && childThreadId) {
       finalToolResponse = typeof toolResponse === "string" ? `${toolResponse}
 
 [${config.agentName} Thread ID: ${childThreadId}]` : toolResponse;
@@ -410,9 +486,22 @@ function createSubagentHandler(subagents) {
     return {
       toolResponse: finalToolResponse,
       data: validated ? validated.data : data,
-      ...usage && { usage }
+      ...usage && { usage },
+      ...childSandboxId && { sandboxId: childSandboxId },
+      ...metadata && { metadata }
     };
   };
+  const destroySubagentSandboxes = async () => {
+    const handles = [...pendingDestroys.values()];
+    pendingDestroys.clear();
+    await Promise.all(
+      handles.map(async (handle) => {
+        await handle.signal(destroySandboxSignal);
+        await handle.result();
+      })
+    );
+  };
+  return { handler, destroySubagentSandboxes };
 }
 
 // src/lib/subagent/register.ts
@@ -426,12 +515,13 @@ function buildSubagentRegistration(subagents) {
     if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
   }
   const resolveSubagentName = (args) => args.subagent;
-  return {
+  const { handler, destroySubagentSandboxes } = createSubagentHandler(subagents);
+  const registration = {
     name: SUBAGENT_TOOL_NAME,
     enabled: () => getEnabled().length > 0,
     description: () => createSubagentTool(getEnabled()).description,
     schema: () => createSubagentTool(getEnabled()).schema,
-    handler: createSubagentHandler(subagents),
+    handler,
     ...subagentHooksMap.size > 0 && {
       hooks: {
         onPreToolUse: async (ctx) => {
@@ -449,6 +539,7 @@ function buildSubagentRegistration(subagents) {
       }
     }
   };
+  return { registration, destroySubagentSandboxes };
 }
 var READ_SKILL_TOOL_NAME = "ReadSkill";
 function buildReadSkillDescription(skills) {
@@ -501,8 +592,7 @@ function buildSkillRegistration(skills) {
     handler: createReadSkillHandler(skills)
   };
 }
-var createSession = async ({
-  threadId: providedThreadId,
+async function createSession({
   agentName,
   maxTurns = 50,
   metadata = {},
@@ -515,24 +605,42 @@ var createSession = async ({
   processToolsInParallel = true,
   hooks = {},
   appendSystemPrompt = true,
-  continueThread = false,
   waitForInputTimeout = "48h",
-  sandbox: sandboxOps,
-  sandboxId: inheritedSandboxId
-}) => {
-  const sourceThreadId = continueThread ? providedThreadId : void 0;
-  const threadId = continueThread && providedThreadId ? getShortId() : providedThreadId ?? getShortId();
+  sandboxOps,
+  thread: threadInit,
+  sandbox: sandboxInit,
+  sandboxShutdown = "destroy"
+}) {
+  const threadMode = threadInit?.mode ?? "new";
+  let threadId;
+  let sourceThreadId;
+  switch (threadMode) {
+    case "new":
+      threadId = threadInit?.mode === "new" && threadInit.threadId ? threadInit.threadId : getShortId();
+      break;
+    case "continue":
+      threadId = threadInit.threadId;
+      break;
+    case "fork":
+      sourceThreadId = threadInit.threadId;
+      threadId = getShortId();
+      break;
+  }
   const {
     appendToolResult,
     appendHumanMessage,
     initializeThread,
     appendSystemMessage,
     forkThread
-  } = threadOps ?? proxyDefaultThreadOps();
+  } = threadOps;
   const plugins = [];
+  let destroySubagentSandboxes;
   if (subagents) {
-    const reg = buildSubagentRegistration(subagents);
-    if (reg) plugins.push(reg);
+    const result = buildSubagentRegistration(subagents);
+    if (result) {
+      plugins.push(result.registration);
+      destroySubagentSandboxes = result.destroySubagentSandboxes;
+    }
   }
   if (skills) {
     const reg = buildSkillRegistration(skills);
@@ -580,11 +688,41 @@ var createSession = async ({
           stateManager.run();
         }
       );
-      let sandboxId = inheritedSandboxId;
-      const ownsSandbox = !sandboxId && !!sandboxOps;
-      if (ownsSandbox) {
-        const result = await sandboxOps.createSandbox({ id: threadId });
+      const sandboxMode = sandboxInit?.mode;
+      let sandboxId;
+      let sandboxOwned = false;
+      if (sandboxMode === "inherit") {
+        sandboxId = sandboxInit.sandboxId;
+        if (!sandboxOps) {
+          throw workflow.ApplicationFailure.create({
+            message: "sandboxId provided but no sandboxOps \u2014 cannot manage sandbox lifecycle",
+            nonRetryable: true
+          });
+        }
+      } else if (sandboxMode === "continue") {
+        if (!sandboxOps) {
+          throw workflow.ApplicationFailure.create({
+            message: "No sandboxOps provided \u2014 cannot continue sandbox",
+            nonRetryable: true
+          });
+        }
+        sandboxId = sandboxInit.sandboxId;
+        sandboxOwned = true;
+      } else if (sandboxMode === "fork") {
+        if (!sandboxOps) {
+          throw workflow.ApplicationFailure.create({
+            message: "No sandboxOps provided \u2014 cannot fork sandbox",
+            nonRetryable: true
+          });
+        }
+        sandboxId = await sandboxOps.forkSandbox(
+          sandboxInit.sandboxId
+        );
+        sandboxOwned = true;
+      } else if (sandboxOps) {
+        const result = await sandboxOps.createSandbox();
         sandboxId = result.sandboxId;
+        sandboxOwned = true;
         if (result.stateUpdate) {
           stateManager.mergeUpdate(result.stateUpdate);
         }
@@ -597,9 +735,9 @@ var createSession = async ({
         });
       }
       const systemPrompt = stateManager.getSystemPrompt();
-      if (continueThread && sourceThreadId) {
+      if (threadMode === "fork" && sourceThreadId) {
         await forkThread(sourceThreadId, threadId);
-      } else {
+      } else if (threadMode === "continue") ; else {
         if (appendSystemPrompt) {
           if (!systemPrompt || systemPrompt.trim() === "") {
             throw workflow.ApplicationFailure.create({
@@ -634,7 +772,8 @@ var createSession = async ({
               threadId,
               finalMessage: message,
               exitReason,
-              usage: stateManager.getTotalUsage()
+              usage: stateManager.getTotalUsage(),
+              sandboxId
             };
           }
           const parsedToolCalls = [];
@@ -685,55 +824,40 @@ var createSession = async ({
         throw workflow.ApplicationFailure.fromError(error);
       } finally {
         await callSessionEnd(exitReason, stateManager.getTurns());
-        if (ownsSandbox && sandboxId && sandboxOps) {
-          await sandboxOps.destroySandbox(sandboxId);
+        if (sandboxOwned && sandboxId && sandboxOps) {
+          switch (sandboxShutdown) {
+            case "destroy":
+              await sandboxOps.destroySandbox(sandboxId);
+              break;
+            case "pause":
+            case "pause-until-parent-close":
+              await sandboxOps.pauseSandbox(sandboxId);
+              break;
+          }
+        }
+        if (destroySubagentSandboxes) {
+          await destroySubagentSandboxes();
         }
       }
       return {
         threadId,
         finalMessage: null,
         exitReason,
-        usage: stateManager.getTotalUsage()
+        usage: stateManager.getTotalUsage(),
+        sandboxId
       };
     }
   };
-};
-function proxyDefaultThreadOps(options) {
-  return workflow.proxyActivities(
-    options ?? {
-      startToCloseTimeout: "10s",
-      retry: {
-        maximumAttempts: 6,
-        initialInterval: "5s",
-        maximumInterval: "15m",
-        backoffCoefficient: 4
-      }
-    }
-  );
-}
-function proxySandboxOps(options) {
-  return workflow.proxyActivities(
-    options ?? {
-      startToCloseTimeout: "30s",
-      retry: {
-        maximumAttempts: 3,
-        initialInterval: "2s",
-        maximumInterval: "30s",
-        backoffCoefficient: 2
-      }
-    }
-  );
 }
 
 // src/lib/workflow.ts
 function defineWorkflow(config, fn) {
   const workflow = async (input, workflowInput = {}) => {
     const sessionInput = {
-      ...workflowInput.previousThreadId && {
-        threadId: workflowInput.previousThreadId,
-        continueThread: true
-      },
-      ...workflowInput.sandboxId && { sandboxId: workflowInput.sandboxId }
+      agentName: config.name,
+      sandboxShutdown: config.sandboxShutdown ?? "destroy",
+      ...workflowInput.thread && { thread: workflowInput.thread },
+      ...workflowInput.sandbox && { sandbox: workflowInput.sandbox }
     };
     return fn(input, sessionInput);
   };
@@ -914,22 +1038,58 @@ function defineSubagent(definition, overrides) {
     ...overrides
   };
 }
-
-// src/lib/subagent/workflow.ts
 function defineSubagentWorkflow(config, fn) {
-  const workflow = async (prompt, workflowInput, context) => {
+  const workflow$1 = async (prompt, workflowInput, context) => {
+    const effectiveShutdown = workflowInput.sandboxShutdown ?? config.sandboxShutdown ?? "destroy";
     const sessionInput = {
       agentName: config.name,
-      ...workflowInput.previousThreadId && {
-        threadId: workflowInput.previousThreadId,
-        continueThread: true
-      },
-      ...workflowInput.sandboxId && { sandboxId: workflowInput.sandboxId }
+      sandboxShutdown: effectiveShutdown,
+      ...workflowInput.thread && { thread: workflowInput.thread },
+      ...workflowInput.sandbox && { sandbox: workflowInput.sandbox }
     };
-    return fn(prompt, sessionInput, context ?? {});
+    const { destroySandbox, ...result } = await fn(
+      prompt,
+      sessionInput,
+      context ?? {}
+    );
+    if (effectiveShutdown === "pause-until-parent-close") {
+      if (!destroySandbox) {
+        throw workflow.ApplicationFailure.create({
+          message: `Subagent "${config.name}" has sandboxShutdown="pause-until-parent-close" but fn did not return a destroySandbox callback`,
+          nonRetryable: true
+        });
+      }
+      if (!result.sandboxId) {
+        throw workflow.ApplicationFailure.create({
+          message: `Subagent "${config.name}" has sandboxShutdown="pause-until-parent-close" but fn did not return a sandboxId`,
+          nonRetryable: true
+        });
+      }
+    }
+    const { parent } = workflow.workflowInfo();
+    if (!parent) {
+      throw workflow.ApplicationFailure.create({
+        message: "Subagent workflow called without a parent workflow",
+        nonRetryable: true
+      });
+    }
+    const parentHandle = workflow.getExternalWorkflowHandle(parent.workflowId);
+    await parentHandle.signal(childResultSignal, {
+      childWorkflowId: workflow.workflowInfo().workflowId,
+      result
+    });
+    if (destroySandbox) {
+      let destroyRequested = false;
+      workflow.setHandler(destroySandboxSignal, () => {
+        destroyRequested = true;
+      });
+      await workflow.condition(() => destroyRequested);
+      await destroySandbox();
+    }
+    return result;
   };
-  Object.defineProperty(workflow, "name", { value: config.name });
-  return Object.assign(workflow, {
+  Object.defineProperty(workflow$1, "name", { value: config.name });
+  return Object.assign(workflow$1, {
     agentName: config.name,
     description: config.description,
     ...config.resultSchema !== void 0 && {
@@ -1520,8 +1680,6 @@ exports.hasFileWithMimeType = hasFileWithMimeType;
 exports.hasNoOtherToolCalls = hasNoOtherToolCalls;
 exports.isTerminalStatus = isTerminalStatus;
 exports.parseSkillFile = parseSkillFile;
-exports.proxyDefaultThreadOps = proxyDefaultThreadOps;
-exports.proxySandboxOps = proxySandboxOps;
 exports.readFileTool = readFileTool;
 exports.taskCreateTool = taskCreateTool;
 exports.taskGetTool = taskGetTool;