zeitlich 0.2.32 → 0.2.34

package/dist/index.cjs

@@ -396,23 +396,50 @@ function createSubagentTool(subagents) {
   };
 }
 var childResultSignal = workflow.defineSignal("childResult");
+var childSandboxReadySignal = workflow.defineSignal("childSandboxReady");
 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 };
+  if (!config || config === "none") {
+    return { source: "none", init: "per-call", continuation: "fork" };
+  }
+  if (config.source === "inherit") {
+    return {
+      source: "inherit",
+      init: "per-call",
+      continuation: config.continuation,
+      shutdown: config.shutdown
+    };
+  }
+  return {
+    source: "own",
+    init: config.init ?? "per-call",
+    continuation: config.continuation,
+    shutdown: config.shutdown
+  };
 }
 function createSubagentHandler(subagents) {
   const { taskQueue: parentTaskQueue } = workflow.workflowInfo();
   const childResults = /* @__PURE__ */ new Map();
   const pendingDestroys = /* @__PURE__ */ new Map();
   const threadSandboxes = /* @__PURE__ */ new Map();
+  const persistentSandboxes = /* @__PURE__ */ new Map();
+  const persistentSandboxCreating = /* @__PURE__ */ new Set();
+  const lazyCreatorAgent = /* @__PURE__ */ new Map();
   workflow.setHandler(childResultSignal, ({ childWorkflowId, result }) => {
     childResults.set(childWorkflowId, result);
   });
+  workflow.setHandler(
+    childSandboxReadySignal,
+    ({ childWorkflowId, sandboxId }) => {
+      const agentName = lazyCreatorAgent.get(childWorkflowId);
+      if (agentName && !persistentSandboxes.has(agentName)) {
+        persistentSandboxes.set(agentName, sandboxId);
+        lazyCreatorAgent.delete(childWorkflowId);
+      }
+    }
+  );
   const handler = async (args, context) => {
     const config = subagents.find((s) => s.agentName === args.subagent);
     if (!config) {
@@ -439,21 +466,48 @@ function createSubagentHandler(subagents) {
       };
     }
     let sandbox;
+    let sandboxShutdownOverride;
+    let isLazyCreator = false;
     if (sandboxCfg.source === "inherit" && parentSandboxId) {
-      sandbox = {
-        mode: "inherit",
-        sandboxId: parentSandboxId
-      };
+      if (sandboxCfg.continuation === "fork") {
+        sandbox = { mode: "fork", sandboxId: parentSandboxId };
+      } else {
+        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 isLazy = sandboxCfg.init === "once";
+      let baseSandboxId;
+      if (isLazy) {
+        baseSandboxId = persistentSandboxes.get(config.agentName);
+        if (!baseSandboxId) {
+          if (persistentSandboxCreating.has(config.agentName)) {
+            await workflow.condition(() => persistentSandboxes.has(config.agentName));
+            baseSandboxId = persistentSandboxes.get(config.agentName);
+          } else {
+            persistentSandboxCreating.add(config.agentName);
+            isLazyCreator = true;
+          }
+        }
+      } else if (continuationThreadId) {
+        baseSandboxId = threadSandboxes.get(continuationThreadId);
+      }
+      if (baseSandboxId) {
+        sandbox = {
+          mode: sandboxCfg.continuation === "continue" ? "continue" : "fork",
+          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 workflowInput = {
       ...thread && { thread },
       ...sandbox && { sandbox },
-      ...sandboxCfg.shutdown && { sandboxShutdown: sandboxCfg.shutdown }
+      sandboxShutdown: sandboxShutdownOverride ?? sandboxCfg.shutdown ?? void 0
     };
     const resolvedContext = config.context === void 0 ? void 0 : typeof config.context === "function" ? config.context() : config.context;
     const childOpts = {
@@ -461,6 +515,9 @@ function createSubagentHandler(subagents) {
       args: resolvedContext === void 0 ? [args.prompt, workflowInput] : [args.prompt, workflowInput, resolvedContext],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
+    if (isLazyCreator) {
+      lazyCreatorAgent.set(childWorkflowId, config.agentName);
+    }
     workflow.log.info("subagent spawned", {
       subagent: config.agentName,
       childWorkflowId,
@@ -468,10 +525,10 @@ function createSubagentHandler(subagents) {
       sandboxSource: sandboxCfg.source
     });
     const childHandle = await workflow.startChild(config.workflow, childOpts);
-    const effectiveShutdown = sandboxCfg.shutdown ?? "destroy";
-    const shouldDeferDestroy = effectiveShutdown === "pause-until-parent-close" && (sandboxCfg.source === "own" || allowsContinuation && sandboxCfg.source !== "inherit");
-    if (shouldDeferDestroy) {
-      pendingDestroys.set(childWorkflowId, childHandle);
+    const effectiveShutdown = sandboxShutdownOverride ?? sandboxCfg.shutdown ?? "destroy";
+    if (effectiveShutdown === "pause-until-parent-close" || effectiveShutdown === "keep-until-parent-close") {
+      const key = isLazyCreator ? `persistent:${config.agentName}` : childWorkflowId;
+      pendingDestroys.set(key, childHandle);
     }
     await Promise.race([
       workflow.condition(() => childResults.has(childWorkflowId)),
@@ -505,8 +562,16 @@ function createSubagentHandler(subagents) {
       sandboxId: childSandboxId,
       metadata
     } = childResult;
-    if (allowsContinuation && childSandboxId && childThreadId) {
-      threadSandboxes.set(childThreadId, childSandboxId);
+    if (childSandboxId) {
+      if (sandboxCfg.source === "own" && sandboxCfg.init === "once" && !persistentSandboxes.has(config.agentName)) {
+        persistentSandboxes.set(config.agentName, childSandboxId);
+      } else if (allowsContinuation && childThreadId) {
+        threadSandboxes.set(childThreadId, childSandboxId);
+      }
+    }
+    if (isLazyCreator) {
+      persistentSandboxCreating.delete(config.agentName);
+      lazyCreatorAgent.delete(childWorkflowId);
     }
     if (!toolResponse) {
       return {
@@ -712,6 +777,7 @@ async function createSession({
   thread: threadInit,
   sandbox: sandboxInit,
   sandboxShutdown = "destroy",
+  onSandboxReady,
   virtualFs: virtualFsConfig,
   virtualFsOps
 }) {
@@ -814,6 +880,9 @@ async function createSession({
           });
         }
         sandboxId = sandboxInit.sandboxId;
+        if (sandboxShutdown === "pause-until-parent-close") {
+          await sandboxOps.resumeSandbox(sandboxId);
+        }
         sandboxOwned = true;
       } else if (sandboxMode === "fork") {
         if (!sandboxOps) {
@@ -836,6 +905,9 @@ async function createSession({
           sandboxOwned = true;
         }
       }
+      if (sandboxId && onSandboxReady) {
+        onSandboxReady(sandboxId);
+      }
       if (virtualFsConfig) {
         if (!virtualFsOps) {
           throw workflow.ApplicationFailure.create({
@@ -1305,39 +1377,45 @@ function defineSubagent(definition, overrides) {
 function defineSubagentWorkflow(config, fn) {
   const workflow$1 = async (prompt, workflowInput, context) => {
     const effectiveShutdown = workflowInput.sandboxShutdown ?? config.sandboxShutdown ?? "destroy";
+    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);
     const sessionInput = {
       agentName: config.name,
       sandboxShutdown: effectiveShutdown,
       ...workflowInput.thread && { thread: workflowInput.thread },
-      ...workflowInput.sandbox && { sandbox: workflowInput.sandbox }
+      ...workflowInput.sandbox && { sandbox: workflowInput.sandbox },
+      onSandboxReady: (sandboxId) => {
+        void parentHandle.signal(childSandboxReadySignal, {
+          childWorkflowId: workflow.workflowInfo().workflowId,
+          sandboxId
+        });
+      }
     };
     const { destroySandbox, ...result } = await fn(
       prompt,
       sessionInput,
       context ?? {}
     );
-    if (effectiveShutdown === "pause-until-parent-close") {
+    if (effectiveShutdown === "pause-until-parent-close" || effectiveShutdown === "keep-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`,
+          message: `Subagent "${config.name}" has sandboxShutdown="${effectiveShutdown}" 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`,
+          message: `Subagent "${config.name}" has sandboxShutdown="${effectiveShutdown}" 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
@@ -1416,6 +1494,23 @@ function composeHooks(...fns) {
     return lastResult;
   };
 }
+function proxyRunAgent(scope, options) {
+  const resolvedScope = scope ?? workflow.workflowInfo().workflowType;
+  const name = `run${resolvedScope.charAt(0).toUpperCase()}${resolvedScope.slice(1)}`;
+  const acts = workflow.proxyActivities(
+    options ?? {
+      startToCloseTimeout: "10m",
+      heartbeatTimeout: "1m",
+      retry: {
+        maximumAttempts: 3,
+        initialInterval: "10s",
+        maximumInterval: "2m",
+        backoffCoefficient: 3
+      }
+    }
+  );
+  return acts[name];
+}
 var SandboxNotSupportedError = class extends common.ApplicationFailure {
   constructor(operation) {
     super(
@@ -2172,6 +2267,14 @@ function createThreadManager(config) {
     }
   };
 }
+function getActivityContext() {
+  try {
+    const ctx = activity.Context.current();
+    return { heartbeat: () => ctx.heartbeat(), signal: ctx.cancellationSignal };
+  } catch {
+    return {};
+  }
+}
 async function queryParentWorkflowState(client) {
   const { workflowExecution } = activity.Context.current().info;
   const handle = client.getHandle(
@@ -2180,10 +2283,13 @@ async function queryParentWorkflowState(client) {
   );
   return handle.query("getAgentState");
 }
-function createRunAgentActivity(client, handler) {
-  return async (config) => {
-    const state = await queryParentWorkflowState(client);
-    return handler({ ...config, state });
+function createRunAgentActivity(client, handler, scope) {
+  const name = `run${scope.charAt(0).toUpperCase()}${scope.slice(1)}`;
+  return {
+    [name]: async (config) => {
+      const state = await queryParentWorkflowState(client);
+      return handler({ ...config, state });
+    }
   };
 }
 function withParentWorkflowState(client, handler) {
@@ -2240,6 +2346,9 @@ var SandboxManager = class {
   async pause(id, ttlSeconds) {
     await this.provider.pause(id, ttlSeconds);
   }
+  async resume(id) {
+    await this.provider.resume(id);
+  }
   async snapshot(id) {
     return this.provider.snapshot(id);
   }
@@ -2283,6 +2392,9 @@ var SandboxManager = class {
       pauseSandbox: async (sandboxId, ttlSeconds) => {
         await this.pause(sandboxId, ttlSeconds);
       },
+      resumeSandbox: async (sandboxId) => {
+        await this.resume(sandboxId);
+      },
       snapshotSandbox: async (sandboxId) => {
         return this.snapshot(sandboxId);
       },
@@ -2988,6 +3100,7 @@ exports.editHandler = editHandler;
 exports.editTool = editTool;
 exports.filesWithMimeType = filesWithMimeType;
 exports.formatVirtualFileTree = formatVirtualFileTree;
+exports.getActivityContext = getActivityContext;
 exports.getShortId = getShortId;
 exports.globHandler = globHandler;
 exports.globTool = globTool;
@@ -2997,6 +3110,7 @@ exports.hasFileWithMimeType = hasFileWithMimeType;
 exports.hasNoOtherToolCalls = hasNoOtherToolCalls;
 exports.isTerminalStatus = isTerminalStatus;
 exports.parseSkillFile = parseSkillFile;
+exports.proxyRunAgent = proxyRunAgent;
 exports.proxyVirtualFsOps = proxyVirtualFsOps;
 exports.queryParentWorkflowState = queryParentWorkflowState;
 exports.readFileHandler = readFileHandler;