zeitlich 0.2.41 → 0.2.43

package/dist/workflow.cjs

@@ -9,6 +9,16 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var z14__default = /*#__PURE__*/_interopDefault(z14);
 
 // src/lib/session/session.ts
+
+// src/lib/session/types.ts
+function resolveSessionLifecycle(init, shutdown) {
+  const resolvedInit = init ?? { mode: "new" };
+  const resolvedShutdown = shutdown ?? "destroy";
+  return {
+    mode: resolvedInit.mode,
+    shutdown: resolvedShutdown
+  };
+}
 function createToolRouter(options) {
   const { appendToolResult } = options;
   const toolMap = /* @__PURE__ */ new Map();
@@ -437,6 +447,37 @@ function createSubagentTool(subagents) {
     schema
   };
 }
+
+// src/lib/subagent/types.ts
+function isSurvivalShutdown(s) {
+  return s === "pause" || s === "pause-until-parent-close" || s === "keep" || s === "keep-until-parent-close";
+}
+function resolveSubagentLifecycle(cfg, isLazyCreator) {
+  if (cfg.source !== "own") {
+    return {
+      shutdownOverride: cfg.shutdown,
+      mustSurvive: false
+    };
+  }
+  if (cfg.continuation === "snapshot") {
+    return {
+      shutdownOverride: "snapshot",
+      mustSurvive: false
+    };
+  }
+  const isLazy = cfg.init === "once";
+  const mustSurvive = isLazyCreator || cfg.continuation === "continue" || isLazy && cfg.continuation === "fork";
+  if (!mustSurvive) {
+    return { shutdownOverride: cfg.shutdown, mustSurvive: false };
+  }
+  if (isSurvivalShutdown(cfg.shutdown)) {
+    return { shutdownOverride: cfg.shutdown, mustSurvive };
+  }
+  return {
+    shutdownOverride: isLazyCreator ? "pause-until-parent-close" : "pause",
+    mustSurvive
+  };
+}
 var childSandboxReadySignal = workflow.defineSignal("childSandboxReady");
 
 // src/lib/subagent/handler.ts
@@ -462,10 +503,18 @@ function resolveSandboxConfig(config) {
 }
 function createSubagentHandler(subagents) {
   const { taskQueue: parentTaskQueue } = workflow.workflowInfo();
-  const agentSandboxOps = /* @__PURE__ */ new Map();
+  const agentDestroyOps = /* @__PURE__ */ new Map();
+  const agentDeleteSnapshotOps = /* @__PURE__ */ new Map();
   for (const cfg of subagents) {
-    if (cfg.sandbox && cfg.sandbox !== "none") {
-      agentSandboxOps.set(cfg.agentName, cfg.sandbox.proxy(cfg.agentName));
+    const cfgSandbox = cfg.sandbox;
+    if (!cfgSandbox || cfgSandbox === "none") continue;
+    if (cfgSandbox.continuation === "snapshot") {
+      const proxy = cfgSandbox.proxy(cfg.agentName);
+      agentDestroyOps.set(cfg.agentName, proxy);
+      agentDeleteSnapshotOps.set(cfg.agentName, proxy);
+    } else {
+      const proxy = cfgSandbox.proxy(cfg.agentName);
+      agentDestroyOps.set(cfg.agentName, proxy);
     }
   }
   const pendingDestroys = /* @__PURE__ */ new Map();
@@ -504,7 +553,7 @@ function createSubagentHandler(subagents) {
     const childWorkflowId = `${args.subagent}-${getShortId()}`;
     const { sandboxId: parentSandboxId } = context;
     const sandboxCfg = resolveSandboxConfig(config.sandbox);
-    if (sandboxCfg.source !== "none" && !agentSandboxOps.has(config.agentName)) {
+    if (sandboxCfg.source !== "none" && !agentDestroyOps.has(config.agentName)) {
       throw workflow.ApplicationFailure.create({
         message: `Subagent "${config.agentName}" uses a sandbox but no \`sandbox.proxy\` is configured on its SubagentConfig`,
         nonRetryable: true
@@ -572,7 +621,6 @@ function createSubagentHandler(subagents) {
       if (baseSnap) {
         sandbox = { mode: "from-snapshot", snapshot: baseSnap };
       }
-      sandboxShutdownOverride = "snapshot";
     } else if (sandboxCfg.source === "own") {
       const isLazy = sandboxCfg.init === "once";
       let baseSandboxId;
@@ -608,12 +656,10 @@ function createSubagentHandler(subagents) {
           sandboxId: baseSandboxId
         };
       }
-      const userShutdown = sandboxCfg.shutdown;
-      const alreadySurvives = userShutdown === "pause-until-parent-close" || userShutdown === "keep-until-parent-close" || userShutdown === "pause" || userShutdown === "keep";
-      const mustSurvive = isLazyCreator || sandboxCfg.continuation === "continue" || isLazy && sandboxCfg.continuation === "fork";
-      if (mustSurvive && !alreadySurvives) {
-        sandboxShutdownOverride = isLazyCreator ? "pause-until-parent-close" : "pause";
-      }
+    }
+    {
+      const lifecycle = resolveSubagentLifecycle(sandboxCfg, isLazyCreator);
+      sandboxShutdownOverride = lifecycle.shutdownOverride;
     }
     const workflowInput = {
       ...thread && { thread },
@@ -758,7 +804,7 @@ function createSubagentHandler(subagents) {
     pendingDestroys.clear();
     await Promise.all(
       entries.map(async ({ agentName, sandboxId }) => {
-        const ops = agentSandboxOps.get(agentName);
+        const ops = agentDestroyOps.get(agentName);
         if (!ops) {
           workflow.log.warn(
             "Skipping sandbox destroy \u2014 no sandbox.proxy registered for agent",
@@ -788,7 +834,7 @@ function createSubagentHandler(subagents) {
     persistentBaseSnapshot.clear();
     await Promise.all(
       tagged.map(async ({ agentName, snapshot }) => {
-        const ops = agentSandboxOps.get(agentName);
+        const ops = agentDeleteSnapshotOps.get(agentName);
         if (!ops) {
           workflow.log.warn(
             "Skipping snapshot delete \u2014 no sandbox.proxy registered for agent",
@@ -940,29 +986,31 @@ function collectSkillFiles(skills) {
   }
   return files;
 }
-async function createSession({
-  agentName,
-  maxTurns = 50,
-  metadata = {},
-  runAgent,
-  threadOps,
-  buildContextMessage,
-  subagents,
-  skills,
-  tools = {},
-  processToolsInParallel = true,
-  hooks = {},
-  appendSystemPrompt = true,
-  threadKey,
-  sandboxOps,
-  thread: threadInit,
-  sandbox: sandboxInit,
-  sandboxShutdown = "destroy",
-  onSandboxReady,
-  onSessionExit,
-  virtualFs: virtualFsConfig,
-  virtualFsOps
-}) {
+async function createSession(config) {
+  const {
+    agentName,
+    maxTurns = 50,
+    metadata = {},
+    runAgent,
+    threadOps,
+    buildContextMessage,
+    subagents,
+    skills,
+    tools = {},
+    processToolsInParallel = true,
+    hooks = {},
+    appendSystemPrompt = true,
+    threadKey,
+    sandboxOps,
+    thread: threadInit,
+    sandbox: sandboxInit,
+    sandboxShutdown,
+    onSandboxReady,
+    onSessionExit,
+    virtualFs: virtualFsConfig,
+    virtualFsOps
+  } = config;
+  const wideOps = () => sandboxOps;
   const threadMode = threadInit?.mode ?? "new";
   let threadId;
   let sourceThreadId;
@@ -1046,7 +1094,12 @@ async function createSession({
           stateManager.run();
         }
       );
-      const sandboxMode = sandboxInit?.mode;
+      const lifecycle = resolveSessionLifecycle(
+        sandboxInit,
+        sandboxShutdown
+      );
+      const sandboxMode = lifecycle.mode;
+      const resolvedShutdown = lifecycle.shutdown;
       let sandboxId;
       let sandboxOwned = false;
       let baseSnapshot;
@@ -1069,8 +1122,8 @@ async function createSession({
           });
         }
         sandboxId = sandboxInit.sandboxId;
-        if (sandboxShutdown === "pause-until-parent-close") {
-          await sandboxOps.resumeSandbox(sandboxId);
+        if (resolvedShutdown === "pause-until-parent-close") {
+          await wideOps().resumeSandbox(sandboxId);
         }
         sandboxOwned = true;
       } else if (sandboxMode === "fork") {
@@ -1081,7 +1134,7 @@ async function createSession({
           });
         }
         const forkInit = sandboxInit;
-        sandboxId = await sandboxOps.forkSandbox(
+        sandboxId = await wideOps().forkSandbox(
           forkInit.sandboxId,
           forkInit.options
         );
@@ -1094,7 +1147,7 @@ async function createSession({
           });
         }
         const restoreInit = sandboxInit;
-        sandboxId = await sandboxOps.restoreSandbox(
+        sandboxId = await wideOps().restoreSandbox(
           restoreInit.snapshot,
           restoreInit.options
         );
@@ -1110,8 +1163,8 @@ async function createSession({
           freshlyCreated = true;
         }
       }
-      if (sandboxId && sandboxOwned && freshlyCreated && sandboxShutdown === "snapshot" && sandboxOps) {
-        baseSnapshot = await sandboxOps.snapshotSandbox(sandboxId);
+      if (sandboxId && sandboxOwned && freshlyCreated && resolvedShutdown === "snapshot" && sandboxOps) {
+        baseSnapshot = await wideOps().snapshotSandbox(sandboxId);
       }
       if (sandboxId && sandboxOwned && onSandboxReady) {
         onSandboxReady({
@@ -1285,6 +1338,9 @@ async function createSession({
             threadId,
             maxTurns
           });
+        } else if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
+          exitReason = "waiting_for_input";
+          workflow.log.info("session waiting for input", { agentName, threadId });
         }
       } catch (error) {
         exitReason = "failed";
@@ -1312,19 +1368,19 @@ async function createSession({
         }
         await callSessionEnd(exitReason, stateManager.getTurns());
         if (sandboxOwned && sandboxId && sandboxOps) {
-          switch (sandboxShutdown) {
+          switch (resolvedShutdown) {
             case "destroy":
               await sandboxOps.destroySandbox(sandboxId);
               break;
             case "pause":
             case "pause-until-parent-close":
-              await sandboxOps.pauseSandbox(sandboxId);
+              await wideOps().pauseSandbox(sandboxId);
               break;
             case "keep":
             case "keep-until-parent-close":
               break;
             case "snapshot":
-              exitSnapshot = await sandboxOps.snapshotSandbox(sandboxId);
+              exitSnapshot = await wideOps().snapshotSandbox(sandboxId);
               await sandboxOps.destroySandbox(sandboxId);
               break;
           }
@@ -1646,14 +1702,14 @@ function defineSubagentWorkflow(config, fn) {
     };
     const result = await fn(prompt, sessionInput, context ?? {});
     return {
-      ...result,
       ...capturedThreadId !== void 0 && { threadId: capturedThreadId },
       ...capturedSandboxId !== void 0 && { sandboxId: capturedSandboxId },
       ...capturedSnapshot !== void 0 && { snapshot: capturedSnapshot },
       ...capturedBaseSnapshot !== void 0 && {
         baseSnapshot: capturedBaseSnapshot
       },
-      ...capturedUsage !== void 0 && { usage: capturedUsage }
+      ...capturedUsage !== void 0 && { usage: capturedUsage },
+      ...result
     };
   };
   Object.defineProperty(workflow$1, "name", { value: config.name });