zeitlich 0.2.40 → 0.2.42

package/dist/{workflow-DhplIN65.d.cts → workflow-BwT5EybR.d.ts}

@@ -1,6 +1,7 @@
-import { as as ToolMap, a1 as SessionConfig, aD as ZeitlichSession, $ as SandboxShutdown, ak as ThreadInit, _ as SandboxInit, u as JsonSerializable, B as BaseAgentState, p as AgentStateManager, aF as ToolRouterOptions, av as ToolRouter, R as RouterContext, J as JsonValue, ax as ToolWithHandler, w as ParsedToolCallUnion, at as ToolNames, aa as SubagentDefinition, ad as SubagentHooks, ae as SubagentSandboxConfig, a9 as SubagentConfig, af as SubagentSandboxShutdown, ag as SubagentSessionInput, ab as SubagentFnResult, a6 as SessionStartHook, a2 as SessionEndHook, E as PostToolUseHook, z as PostToolUseFailureHook, a4 as SessionExitReason, al as TokenUsage, f as RunAgentConfig, A as AgentResponse, F as FileEntryMetadata, az as VirtualFileTree, k as TreeMutation, s as FileEntry, aA as VirtualFsOps, h as SkillMetadata, i as Skill, c as ToolHandlerResponse, aq as ToolHandler, aC as WorkflowTask, d as ActivityToolHandler } from './types-Cn2r3ol3.cjs';
-import { g as SandboxOps } from './types-yx0LzPGn.cjs';
+import { au as ToolMap, _ as SandboxInit, ah as SubagentSandboxShutdown, a1 as SessionConfig, aF as ZeitlichSession, $ as SandboxShutdown, am as ThreadInit, u as JsonSerializable, B as BaseAgentState, p as AgentStateManager, aH as ToolRouterOptions, ax as ToolRouter, R as RouterContext, J as JsonValue, az as ToolWithHandler, w as ParsedToolCallUnion, av as ToolNames, ac as SubagentDefinition, af as SubagentHooks, ag as SubagentSandboxConfig, aa as SubagentConfig, ai as SubagentSessionInput, ad as SubagentFnResult, a7 as SessionStartHook, a2 as SessionEndHook, E as PostToolUseHook, z as PostToolUseFailureHook, a4 as SessionExitReason, an as TokenUsage, f as RunAgentConfig, A as AgentResponse, F as FileEntryMetadata, aB as VirtualFileTree, k as TreeMutation, s as FileEntry, aC as VirtualFsOps, h as SkillMetadata, i as Skill, c as ToolHandlerResponse, as as ToolHandler, aE as WorkflowTask, d as ActivityToolHandler } from './types-ChAy_jSP.js';
 import z$1, { z } from 'zod';
+import './types-CJ7tCdl6.js';
+import { Duration } from '@temporalio/common';
 import { Sinks, proxyActivities } from '@temporalio/workflow';
 
 /**
@@ -34,10 +35,10 @@ import { Sinks, proxyActivities } from '@temporalio/workflow';
  * const { finalMessage, exitReason } = await session.runSession({ stateManager });
  * ```
  */
-declare function createSession<T extends ToolMap, M = unknown, TContent = string>(config: SessionConfig<T, M, TContent> & {
-    sandboxOps: SandboxOps;
+declare function createSession<T extends ToolMap, M = unknown, TContent = string, TInit extends SandboxInit | undefined = undefined, TShutdown extends SubagentSandboxShutdown | undefined = undefined>(config: SessionConfig<T, M, TContent, TInit, TShutdown> & {
+    sandboxOps: NonNullable<SessionConfig<T, M, TContent, TInit, TShutdown>["sandboxOps"]>;
 }): Promise<ZeitlichSession<M, true>>;
-declare function createSession<T extends ToolMap, M = unknown, TContent = string>(config: SessionConfig<T, M, TContent>): Promise<ZeitlichSession<M, false>>;
+declare function createSession<T extends ToolMap, M = unknown, TContent = string, TInit extends SandboxInit | undefined = undefined, TShutdown extends SubagentSandboxShutdown | undefined = undefined>(config: SessionConfig<T, M, TContent, TInit, TShutdown>): Promise<ZeitlichSession<M, false>>;
 
 /**
  * Session config fields derived from a main workflow input, ready to spread
@@ -270,7 +271,7 @@ type SubagentArgs = {
  * still catching hangs; agents that legitimately need longer should set an
  * explicit `workflowOptions.workflowRunTimeout`.
  */
-declare const DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT = "1h";
+declare const DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT: Duration;
 
 /**
  * Creates a `SubagentConfig` from a `SubagentDefinition` (returned by `defineSubagentWorkflow`).

package/dist/{workflow-C2MZZj5K.d.ts → workflow-DMmiaw6w.d.cts}

@@ -1,6 +1,7 @@
-import { as as ToolMap, a1 as SessionConfig, aD as ZeitlichSession, $ as SandboxShutdown, ak as ThreadInit, _ as SandboxInit, u as JsonSerializable, B as BaseAgentState, p as AgentStateManager, aF as ToolRouterOptions, av as ToolRouter, R as RouterContext, J as JsonValue, ax as ToolWithHandler, w as ParsedToolCallUnion, at as ToolNames, aa as SubagentDefinition, ad as SubagentHooks, ae as SubagentSandboxConfig, a9 as SubagentConfig, af as SubagentSandboxShutdown, ag as SubagentSessionInput, ab as SubagentFnResult, a6 as SessionStartHook, a2 as SessionEndHook, E as PostToolUseHook, z as PostToolUseFailureHook, a4 as SessionExitReason, al as TokenUsage, f as RunAgentConfig, A as AgentResponse, F as FileEntryMetadata, az as VirtualFileTree, k as TreeMutation, s as FileEntry, aA as VirtualFsOps, h as SkillMetadata, i as Skill, c as ToolHandlerResponse, aq as ToolHandler, aC as WorkflowTask, d as ActivityToolHandler } from './types-DeQH84C_.js';
-import { g as SandboxOps } from './types-yx0LzPGn.js';
+import { au as ToolMap, _ as SandboxInit, ah as SubagentSandboxShutdown, a1 as SessionConfig, aF as ZeitlichSession, $ as SandboxShutdown, am as ThreadInit, u as JsonSerializable, B as BaseAgentState, p as AgentStateManager, aH as ToolRouterOptions, ax as ToolRouter, R as RouterContext, J as JsonValue, az as ToolWithHandler, w as ParsedToolCallUnion, av as ToolNames, ac as SubagentDefinition, af as SubagentHooks, ag as SubagentSandboxConfig, aa as SubagentConfig, ai as SubagentSessionInput, ad as SubagentFnResult, a7 as SessionStartHook, a2 as SessionEndHook, E as PostToolUseHook, z as PostToolUseFailureHook, a4 as SessionExitReason, an as TokenUsage, f as RunAgentConfig, A as AgentResponse, F as FileEntryMetadata, aB as VirtualFileTree, k as TreeMutation, s as FileEntry, aC as VirtualFsOps, h as SkillMetadata, i as Skill, c as ToolHandlerResponse, as as ToolHandler, aE as WorkflowTask, d as ActivityToolHandler } from './types-CdALEF3z.cjs';
 import z$1, { z } from 'zod';
+import './types-CJ7tCdl6.cjs';
+import { Duration } from '@temporalio/common';
 import { Sinks, proxyActivities } from '@temporalio/workflow';
 
 /**
@@ -34,10 +35,10 @@ import { Sinks, proxyActivities } from '@temporalio/workflow';
  * const { finalMessage, exitReason } = await session.runSession({ stateManager });
  * ```
  */
-declare function createSession<T extends ToolMap, M = unknown, TContent = string>(config: SessionConfig<T, M, TContent> & {
-    sandboxOps: SandboxOps;
+declare function createSession<T extends ToolMap, M = unknown, TContent = string, TInit extends SandboxInit | undefined = undefined, TShutdown extends SubagentSandboxShutdown | undefined = undefined>(config: SessionConfig<T, M, TContent, TInit, TShutdown> & {
+    sandboxOps: NonNullable<SessionConfig<T, M, TContent, TInit, TShutdown>["sandboxOps"]>;
 }): Promise<ZeitlichSession<M, true>>;
-declare function createSession<T extends ToolMap, M = unknown, TContent = string>(config: SessionConfig<T, M, TContent>): Promise<ZeitlichSession<M, false>>;
+declare function createSession<T extends ToolMap, M = unknown, TContent = string, TInit extends SandboxInit | undefined = undefined, TShutdown extends SubagentSandboxShutdown | undefined = undefined>(config: SessionConfig<T, M, TContent, TInit, TShutdown>): Promise<ZeitlichSession<M, false>>;
 
 /**
  * Session config fields derived from a main workflow input, ready to spread
@@ -270,7 +271,7 @@ type SubagentArgs = {
  * still catching hangs; agents that legitimately need longer should set an
  * explicit `workflowOptions.workflowRunTimeout`.
  */
-declare const DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT = "1h";
+declare const DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT: Duration;
 
 /**
  * Creates a `SubagentConfig` from a `SubagentDefinition` (returned by `defineSubagentWorkflow`).

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,30 +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,
-  waitForInputTimeout = "48h",
-  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;
@@ -1047,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;
@@ -1070,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") {
@@ -1082,7 +1134,7 @@ async function createSession({
           });
         }
         const forkInit = sandboxInit;
-        sandboxId = await sandboxOps.forkSandbox(
+        sandboxId = await wideOps().forkSandbox(
           forkInit.sandboxId,
           forkInit.options
         );
@@ -1095,7 +1147,7 @@ async function createSession({
           });
         }
         const restoreInit = sandboxInit;
-        sandboxId = await sandboxOps.restoreSandbox(
+        sandboxId = await wideOps().restoreSandbox(
           restoreInit.snapshot,
           restoreInit.options
         );
@@ -1111,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({
@@ -1136,12 +1188,23 @@ async function createSession({
             path,
             size: content.length,
             mtime: (/* @__PURE__ */ new Date()).toISOString(),
-            metadata: {}
+            metadata: {},
+            // Carry the content directly on the entry so any handler that
+            // constructs a VirtualFileSystem from `fileTree` can read it
+            // without needing to also wire up `inlineFiles` from state.
+            inlineContent: content
           }))
         ] : result.fileTree;
         stateManager.mergeUpdate({
           fileTree,
           virtualFsCtx: virtualFsConfig.ctx,
+          // `inlineFiles` is still the source of truth at read time:
+          // VirtualFileSystem checks the inlineFiles map first and only
+          // falls through to entry.inlineContent. Embedding the content on
+          // the entry is the migration target so that handlers building a
+          // VirtualFileSystem from `fileTree` alone (without forwarding
+          // `inlineFiles` from state) can read skill resources. Until a
+          // follow-up drops `inlineFiles`, both fields are populated.
           ...skillFiles && { inlineFiles: skillFiles }
         });
       }
@@ -1267,18 +1330,6 @@ async function createSession({
             continue;
           }
           assistantId = void 0;
-          if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
-            const conditionMet = await workflow.condition(
-              () => stateManager.getStatus() === "RUNNING",
-              waitForInputTimeout
-            );
-            if (!conditionMet) {
-              stateManager.cancel();
-              exitReason = "cancelled";
-              await workflow.condition(() => false, "2s");
-              break;
-            }
-          }
         }
         if (stateManager.getTurns() >= maxTurns && stateManager.isRunning()) {
           exitReason = "max_turns";
@@ -1314,19 +1365,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;
           }
@@ -1352,7 +1403,8 @@ async function createSession({
         onSessionExit({
           ...sandboxId && { sandboxId },
           ...exitSnapshot && { snapshot: exitSnapshot },
-          threadId
+          threadId,
+          usage: stateManager.getTotalUsage()
         });
       }
       return {
@@ -1573,6 +1625,20 @@ function createAgentStateManager({
     }
   };
 }
+var SandboxNotSupportedError = class extends common.ApplicationFailure {
+  constructor(operation) {
+    super(
+      `Sandbox does not support: ${operation}`,
+      "SandboxNotSupportedError",
+      true
+    );
+  }
+};
+var SandboxNotFoundError = class extends common.ApplicationFailure {
+  constructor(sandboxId) {
+    super(`Sandbox not found: ${sandboxId}`, "SandboxNotFoundError", true);
+  }
+};
 
 // src/lib/subagent/define.ts
 function defineSubagent(definition, overrides) {
@@ -1601,6 +1667,7 @@ function defineSubagentWorkflow(config, fn) {
     let capturedSnapshot;
     let capturedBaseSnapshot;
     let capturedThreadId;
+    let capturedUsage;
     const sessionInput = {
       agentName: config.name,
       sandboxShutdown: effectiveShutdown,
@@ -1617,10 +1684,17 @@ function defineSubagentWorkflow(config, fn) {
           });
         }
       },
-      onSessionExit: ({ sandboxId, snapshot, threadId }) => {
+      onSessionExit: ({ sandboxId, snapshot, threadId, usage }) => {
         capturedSandboxId = sandboxId;
         capturedSnapshot = snapshot;
         capturedThreadId = threadId;
+        capturedUsage = {
+          inputTokens: usage.totalInputTokens,
+          outputTokens: usage.totalOutputTokens,
+          cachedWriteTokens: usage.totalCachedWriteTokens,
+          cachedReadTokens: usage.totalCachedReadTokens,
+          reasonTokens: usage.totalReasonTokens
+        };
       }
     };
     const result = await fn(prompt, sessionInput, context ?? {});
@@ -1631,7 +1705,8 @@ function defineSubagentWorkflow(config, fn) {
       ...capturedSnapshot !== void 0 && { snapshot: capturedSnapshot },
       ...capturedBaseSnapshot !== void 0 && {
         baseSnapshot: capturedBaseSnapshot
-      }
+      },
+      ...capturedUsage !== void 0 && { usage: capturedUsage }
     };
   };
   Object.defineProperty(workflow$1, "name", { value: config.name });
@@ -1715,20 +1790,6 @@ function proxyRunAgent(scope, options) {
   );
   return acts[name];
 }
-var SandboxNotSupportedError = class extends common.ApplicationFailure {
-  constructor(operation) {
-    super(
-      `Sandbox does not support: ${operation}`,
-      "SandboxNotSupportedError",
-      true
-    );
-  }
-};
-var SandboxNotFoundError = class extends common.ApplicationFailure {
-  constructor(sandboxId) {
-    super(`Sandbox not found: ${sandboxId}`, "SandboxNotFoundError", true);
-  }
-};
 
 // src/lib/virtual-fs/mutations.ts
 function applyVirtualTreeMutations(stateManager, mutations) {