zeitlich 0.2.27 → 0.2.29

package/dist/workflow.cjs

@@ -113,7 +113,7 @@ function createToolRouter(options) {
       });
     }
   }
-  async function processToolCall(toolCall, turn, sandboxId, sandboxStateUpdate) {
+  async function processToolCall(toolCall, turn, sandboxId) {
     const startTime = Date.now();
     const tool = toolMap.get(toolCall.name);
     const preResult = await runPreHooks(toolCall, tool, turn);
@@ -131,6 +131,11 @@ function createToolRouter(options) {
       return null;
     }
     const effectiveArgs = preResult.args;
+    workflow.log.debug("tool call dispatched", {
+      toolName: toolCall.name,
+      toolCallId: toolCall.id,
+      turn
+    });
     let result;
     let content;
     let resultAppended = false;
@@ -142,8 +147,7 @@ function createToolRouter(options) {
           ...options.threadKey && { threadKey: options.threadKey },
           toolCallId: toolCall.id,
           toolName: toolCall.name,
-          ...sandboxId !== void 0 && { sandboxId },
-          ...sandboxStateUpdate && { sandboxStateUpdate }
+          ...sandboxId !== void 0 && { sandboxId }
         };
         const response = await tool.handler(
           effectiveArgs,
@@ -158,6 +162,13 @@ function createToolRouter(options) {
         content = JSON.stringify(result, null, 2);
       }
     } catch (error) {
+      workflow.log.warn("tool call failed", {
+        toolName: toolCall.name,
+        toolCallId: toolCall.id,
+        turn,
+        durationMs: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
+      });
       const recovery = await runFailureHooks(
         toolCall,
         tool,
@@ -183,19 +194,26 @@ function createToolRouter(options) {
         [workflow.uuid4(), config]
       );
     }
+    const durationMs = Date.now() - startTime;
     const toolResult = {
       toolCallId: toolCall.id,
       name: toolCall.name,
       data: result,
       ...metadata && { metadata }
     };
+    workflow.log.debug("tool call completed", {
+      toolName: toolCall.name,
+      toolCallId: toolCall.id,
+      turn,
+      durationMs
+    });
     await runPostHooks(
       toolCall,
       tool,
       toolResult,
       effectiveArgs,
       turn,
-      Date.now() - startTime
+      durationMs
     );
     return toolResult;
   }
@@ -237,10 +255,9 @@ function createToolRouter(options) {
       }
       const turn = context?.turn ?? 0;
       const sandboxId = context?.sandboxId;
-      const sandboxStateUpdate = context?.sandboxStateUpdate;
       if (options.parallel) {
         const results2 = await Promise.all(
-          toolCalls.map((tc) => processToolCall(tc, turn, sandboxId, sandboxStateUpdate))
+          toolCalls.map((tc) => processToolCall(tc, turn, sandboxId))
         );
         return results2.filter(
           (r) => r !== null
@@ -248,7 +265,7 @@ function createToolRouter(options) {
       }
       const results = [];
       for (const toolCall of toolCalls) {
-        const result = await processToolCall(toolCall, turn, sandboxId, sandboxStateUpdate);
+        const result = await processToolCall(toolCall, turn, sandboxId);
         if (result !== null) {
           results.push(result);
         }
@@ -384,7 +401,7 @@ function resolveSandboxConfig(config) {
   if (config === "own") return { source: "own" };
   return { source: "own", shutdown: config.shutdown };
 }
-function createSubagentHandler(subagents) {
+function createSubagentHandler(subagents, options) {
   const { taskQueue: parentTaskQueue } = workflow.workflowInfo();
   const childResults = /* @__PURE__ */ new Map();
   const pendingDestroys = /* @__PURE__ */ new Map();
@@ -416,10 +433,11 @@ function createSubagentHandler(subagents) {
     }
     let sandbox;
     if (sandboxCfg.source === "inherit" && parentSandboxId) {
+      const stateUpdate = options?.getSandboxStateForInheritance?.();
       sandbox = {
         mode: "inherit",
         sandboxId: parentSandboxId,
-        ...context.sandboxStateUpdate && { stateUpdate: context.sandboxStateUpdate }
+        ...stateUpdate && { stateUpdate }
       };
     } else if (sandboxCfg.source === "own") {
       const prevSbId = continuationThreadId ? threadSandboxes.get(continuationThreadId) : void 0;
@@ -438,6 +456,12 @@ function createSubagentHandler(subagents) {
       args: resolvedContext === void 0 ? [args.prompt, workflowInput] : [args.prompt, workflowInput, resolvedContext],
       taskQueue: config.taskQueue ?? parentTaskQueue
     };
+    workflow.log.info("subagent spawned", {
+      subagent: config.agentName,
+      childWorkflowId,
+      threadMode,
+      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");
@@ -454,11 +478,20 @@ function createSubagentHandler(subagents) {
     const childResult = childResults.get(childWorkflowId);
     childResults.delete(childWorkflowId);
     if (!childResult) {
+      workflow.log.warn("subagent returned no result", {
+        subagent: config.agentName,
+        childWorkflowId
+      });
       return {
         toolResponse: "Subagent workflow did not signal a result",
         data: null
       };
     }
+    workflow.log.info("subagent completed", {
+      subagent: config.agentName,
+      childWorkflowId,
+      ...childResult.usage && { usage: childResult.usage }
+    });
     const {
       toolResponse,
       data,
@@ -524,7 +557,7 @@ function createSubagentHandler(subagents) {
 }
 
 // src/lib/subagent/register.ts
-function buildSubagentRegistration(subagents) {
+function buildSubagentRegistration(subagents, options) {
   if (subagents.length === 0) return null;
   const getEnabled = () => subagents.filter(
     (s) => typeof s.enabled === "function" ? s.enabled() : s.enabled ?? true
@@ -534,7 +567,9 @@ function buildSubagentRegistration(subagents) {
     if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
   }
   const resolveSubagentName = (args) => args.subagent;
-  const { handler, destroySubagentSandboxes } = createSubagentHandler(subagents);
+  const { handler, destroySubagentSandboxes } = createSubagentHandler(subagents, {
+    getSandboxStateForInheritance: options?.getSandboxStateForInheritance
+  });
   const registration = {
     name: SUBAGENT_TOOL_NAME,
     enabled: () => getEnabled().length > 0,
@@ -673,7 +708,8 @@ async function createSession({
   sandboxOps,
   thread: threadInit,
   sandbox: sandboxInit,
-  sandboxShutdown = "destroy"
+  sandboxShutdown = "destroy",
+  virtualFs: virtualFsConfig
 }) {
   const threadMode = threadInit?.mode ?? "new";
   let threadId;
@@ -699,8 +735,11 @@ async function createSession({
   } = threadOps;
   const plugins = [];
   let destroySubagentSandboxes;
+  let sandboxStateGetter;
   if (subagents) {
-    const result = buildSubagentRegistration(subagents);
+    const result = buildSubagentRegistration(subagents, {
+      getSandboxStateForInheritance: () => sandboxStateGetter?.()
+    });
     if (result) {
       plugins.push(result.registration);
       destroySubagentSandboxes = result.destroySubagentSandboxes;
@@ -756,12 +795,21 @@ async function createSession({
       const sandboxMode = sandboxInit?.mode;
       let sandboxId;
       let sandboxOwned = false;
-      let sandboxStateUpdate;
+      sandboxStateGetter = () => {
+        const fileTree = stateManager.get("fileTree");
+        const resolverContext = stateManager.get("resolverContext");
+        const workspaceBase = stateManager.get("workspaceBase");
+        if (!fileTree && !resolverContext && !workspaceBase) return void 0;
+        return {
+          ...fileTree !== void 0 && { fileTree },
+          ...resolverContext !== void 0 && { resolverContext },
+          ...workspaceBase !== void 0 && { workspaceBase }
+        };
+      };
       if (sandboxMode === "inherit") {
         const inheritInit = sandboxInit;
         sandboxId = inheritInit.sandboxId;
         if (inheritInit.stateUpdate) {
-          sandboxStateUpdate = inheritInit.stateUpdate;
           stateManager.mergeUpdate(inheritInit.stateUpdate);
         }
         if (!sandboxOps) {
@@ -798,10 +846,20 @@ async function createSession({
         sandboxId = result.sandboxId;
         sandboxOwned = true;
         if (result.stateUpdate) {
-          sandboxStateUpdate = result.stateUpdate;
           stateManager.mergeUpdate(result.stateUpdate);
         }
       }
+      if (virtualFsConfig) {
+        const result = await virtualFsConfig.ops.resolveFileTree(
+          virtualFsConfig.resolverContext
+        );
+        stateManager.mergeUpdate({
+          fileTree: result.fileTree,
+          resolverContext: virtualFsConfig.resolverContext,
+          workspaceBase: virtualFsConfig.workspaceBase ?? "/",
+          ...result.stateUpdate
+        });
+      }
       if (hooks.onSessionStart) {
         await hooks.onSessionStart({
           threadId,
@@ -809,6 +867,14 @@ async function createSession({
           metadata
         });
       }
+      workflow.log.info("session started", {
+        agentName,
+        threadId,
+        threadMode,
+        maxTurns,
+        ...sandboxId && { sandboxId }
+      });
+      const sessionStartMs = Date.now();
       const systemPrompt = stateManager.getSystemPrompt();
       if (threadMode === "fork" && sourceThreadId) {
         await forkThread(sourceThreadId, threadId, threadKey);
@@ -831,6 +897,7 @@ async function createSession({
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
+          workflow.log.debug("turn started", { agentName, threadId, turn: currentTurn });
           stateManager.setTools(toolRouter.getToolDefinitions());
           const { message, rawToolCalls, usage } = await runAgent({
             threadId,
@@ -841,9 +908,24 @@ async function createSession({
           if (usage) {
             stateManager.updateUsage(usage);
           }
+          workflow.log.debug("model response received", {
+            agentName,
+            threadId,
+            turn: currentTurn,
+            toolCallCount: rawToolCalls.length,
+            ...usage && { usage }
+          });
           if (!toolRouter.hasTools() || rawToolCalls.length === 0) {
             stateManager.complete();
             exitReason = "completed";
+            workflow.log.info("session ended", {
+              agentName,
+              threadId,
+              exitReason,
+              turns: currentTurn,
+              durationMs: Date.now() - sessionStartMs,
+              usage: stateManager.getTotalUsage()
+            });
             return {
               threadId,
               finalMessage: message,
@@ -872,8 +954,7 @@ async function createSession({
             parsedToolCalls,
             {
               turn: currentTurn,
-              ...sandboxId !== void 0 && { sandboxId },
-              ...sandboxStateUpdate && { sandboxStateUpdate }
+              ...sandboxId !== void 0 && { sandboxId }
             }
           );
           for (const result of toolCallResults) {
@@ -896,9 +977,21 @@ async function createSession({
         }
         if (stateManager.getTurns() >= maxTurns && stateManager.isRunning()) {
           exitReason = "max_turns";
+          workflow.log.warn("session hit max turns", {
+            agentName,
+            threadId,
+            maxTurns
+          });
         }
       } catch (error) {
         exitReason = "failed";
+        workflow.log.error("session failed", {
+          agentName,
+          threadId,
+          turns: stateManager.getTurns(),
+          durationMs: Date.now() - sessionStartMs,
+          error: error instanceof Error ? error.message : String(error)
+        });
         throw workflow.ApplicationFailure.fromError(error);
       } finally {
         await callSessionEnd(exitReason, stateManager.getTurns());
@@ -917,6 +1010,14 @@ async function createSession({
           await destroySubagentSandboxes();
         }
       }
+      workflow.log.info("session ended", {
+        agentName,
+        threadId,
+        exitReason,
+        turns: stateManager.getTurns(),
+        durationMs: Date.now() - sessionStartMs,
+        usage: stateManager.getTotalUsage()
+      });
       return {
         threadId,
         finalMessage: null,
@@ -1176,6 +1277,60 @@ function defineSubagentWorkflow(config, fn) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   });
 }
+function createObservabilityHooks(agentName) {
+  const { zeitlichMetrics } = workflow.proxySinks();
+  let sessionStartMs = Date.now();
+  return {
+    onSessionStart: (ctx) => {
+      sessionStartMs = Date.now();
+      zeitlichMetrics.sessionStarted({
+        agentName,
+        threadId: ctx.threadId,
+        metadata: ctx.metadata
+      });
+    },
+    onSessionEnd: (ctx) => {
+      zeitlichMetrics.sessionEnded({
+        agentName,
+        threadId: ctx.threadId,
+        exitReason: ctx.exitReason,
+        turns: ctx.turns,
+        usage: {},
+        durationMs: Date.now() - sessionStartMs
+      });
+    },
+    onPostToolUse: (ctx) => {
+      zeitlichMetrics.toolExecuted({
+        agentName,
+        toolName: ctx.toolCall.name,
+        durationMs: ctx.durationMs,
+        success: true,
+        threadId: ctx.threadId,
+        turn: ctx.turn
+      });
+    },
+    onPostToolUseFailure: (ctx) => {
+      zeitlichMetrics.toolExecuted({
+        agentName,
+        toolName: ctx.toolCall.name,
+        durationMs: 0,
+        success: false,
+        threadId: ctx.threadId,
+        turn: ctx.turn
+      });
+      return {};
+    }
+  };
+}
+function composeHooks(...fns) {
+  return async (...args) => {
+    let lastResult;
+    for (const fn of fns) {
+      lastResult = await fn(...args);
+    }
+    return lastResult;
+  };
+}
 var SandboxNotSupportedError = class extends common.ApplicationFailure {
   constructor(operation) {
     super(
@@ -1191,7 +1346,7 @@ var SandboxNotFoundError = class extends common.ApplicationFailure {
   }
 };
 
-// src/adapters/sandbox/virtual/mutations.ts
+// src/lib/virtual-fs/mutations.ts
 function applyVirtualTreeMutations(stateManager, mutations) {
   let tree = [...stateManager.get("fileTree")];
   for (const m of mutations) {
@@ -1213,7 +1368,7 @@ function applyVirtualTreeMutations(stateManager, mutations) {
   return tree;
 }
 
-// src/adapters/sandbox/virtual/tree.ts
+// src/lib/virtual-fs/tree.ts
 var buildTree = (entries) => {
   const root = { name: "/", children: /* @__PURE__ */ new Map(), isFile: false };
   for (const entry of entries) {
@@ -1261,7 +1416,7 @@ function formatVirtualFileTree(entries, opts = {}) {
   return "/" + printNode(root, "", sort);
 }
 
-// src/adapters/sandbox/virtual/queries.ts
+// src/lib/virtual-fs/queries.ts
 function hasFileWithMimeType(stateManager, pattern) {
   const tree = stateManager.get("fileTree");
   const matchers = (Array.isArray(pattern) ? pattern : [pattern]).map(buildMatcher);
@@ -1302,6 +1457,25 @@ function buildGlobMatcher(pattern) {
   );
   return (v) => re.test(v);
 }
+function proxyVirtualFsOps(scope, options) {
+  const resolvedScope = scope ?? workflow.workflowInfo().workflowType;
+  const acts = workflow.proxyActivities(
+    options ?? {
+      startToCloseTimeout: "30s",
+      retry: {
+        maximumAttempts: 3,
+        initialInterval: "2s",
+        maximumInterval: "30s",
+        backoffCoefficient: 2
+      }
+    }
+  );
+  const prefix = resolvedScope;
+  const p = (key) => `${prefix}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+  return {
+    resolveFileTree: acts[p("resolveFileTree")]
+  };
+}
 
 // src/lib/skills/parse.ts
 function parseSkillFile(raw) {
@@ -1732,9 +1906,11 @@ exports.SandboxNotSupportedError = SandboxNotSupportedError;
 exports.applyVirtualTreeMutations = applyVirtualTreeMutations;
 exports.askUserQuestionTool = askUserQuestionTool;
 exports.bashTool = bashTool;
+exports.composeHooks = composeHooks;
 exports.createAgentStateManager = createAgentStateManager;
 exports.createAskUserQuestionHandler = createAskUserQuestionHandler;
 exports.createBashToolDescription = createBashToolDescription;
+exports.createObservabilityHooks = createObservabilityHooks;
 exports.createReadSkillHandler = createReadSkillHandler;
 exports.createReadSkillTool = createReadSkillTool;
 exports.createSession = createSession;
@@ -1758,6 +1934,7 @@ exports.hasFileWithMimeType = hasFileWithMimeType;
 exports.hasNoOtherToolCalls = hasNoOtherToolCalls;
 exports.isTerminalStatus = isTerminalStatus;
 exports.parseSkillFile = parseSkillFile;
+exports.proxyVirtualFsOps = proxyVirtualFsOps;
 exports.readFileTool = readFileTool;
 exports.taskCreateTool = taskCreateTool;
 exports.taskGetTool = taskGetTool;