@tangle-network/agent-app 0.60.197 → 0.60.199

package/dist/{chunk-SUIH5B55.js → chunk-RJJRRR5Z.js}

@@ -21,6 +21,9 @@ import {
 import {
   buildAppToolMcpServer
 } from "./chunk-6A7MYOUI.js";
+import {
+  nextCallIndex
+} from "./chunk-7XQIY2LU.js";
 import {
   resolveTangleExecutionEnvironment,
   trimOrNull
@@ -40,6 +43,113 @@ var fail = (error) => ({
   error: error instanceof Error ? error : new Error(String(error))
 });
 
+// src/sandbox/prompt-trace.ts
+var asRec = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var asNum = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+var PHASES = ["agent_run_start", "harness_spawn", "harness_ready", "first_model_request", "first_upstream_byte", "first_text"];
+function createPromptTrace(trace, parent, meta) {
+  const startedAt = Date.now();
+  const prompt = trace.start("sandbox.prompt", "sandbox", meta, parent);
+  let firstEventAt;
+  let firstTextAt;
+  let generation;
+  let phases;
+  let events = 0;
+  const tools = /* @__PURE__ */ new Map();
+  const startTool = (id, name) => {
+    if (tools.has(id)) return;
+    tools.set(id, trace.start("tool.call", "tool", {
+      "gen_ai.tool.name": name,
+      "tool.call_id": id,
+      "call.index": nextCallIndex(trace, "tool.call"),
+      where: "sandbox",
+      approx: true
+    }, generation ?? prompt));
+  };
+  const observe = (raw) => {
+    try {
+      const event = asRec(raw);
+      if (!event) return;
+      const now = Date.now();
+      events++;
+      firstEventAt ??= now;
+      const type = typeof event.type === "string" ? event.type : "";
+      const data = asRec(event.data);
+      if (type === "result") {
+        const report = asRec(data?.firstTextPhases);
+        const offsets = asRec(report?.phasesMs);
+        if (offsets) {
+          phases = {
+            offsets,
+            warm: typeof report?.harnessWarm === "boolean" ? report.harnessWarm : null,
+            ...typeof report?.model === "string" ? { model: report.model } : {}
+          };
+        }
+        return;
+      }
+      if (type === "tool_call" || type === "tool.call") {
+        const id = String(data?.id ?? data?.callId ?? data?.callID ?? data?.name ?? "");
+        if (id) startTool(id, String(data?.name ?? data?.tool ?? "tool"));
+        return;
+      }
+      if (type === "tool_result" || type === "tool.result") {
+        const id = String(data?.id ?? data?.callId ?? data?.callID ?? data?.name ?? "");
+        tools.get(id)?.end(void 0, data?.error ?? (data?.status === "error" ? "tool_error" : void 0));
+        return;
+      }
+      if (type !== "message.part.updated") return;
+      const part = asRec(data?.part);
+      const partType = String(part?.type ?? "");
+      if (partType === "text" && firstTextAt === void 0 && (typeof data?.delta === "string" && data.delta || typeof part?.text === "string" && part.text)) {
+        firstTextAt = now;
+        generation = prompt.child("sandbox.generation", "model");
+      } else if (partType === "tool") {
+        const id = String(part?.id ?? part?.callID ?? "");
+        if (!id) return;
+        const state = asRec(part?.state);
+        const status = String(state?.status ?? part?.status ?? "");
+        startTool(id, String(part?.tool ?? "tool"));
+        if (status === "completed" || status === "error") tools.get(id)?.end(void 0, status === "error" ? "tool_error" : void 0);
+      }
+    } catch {
+    }
+  };
+  const end = (error) => {
+    try {
+      for (const span of tools.values()) span.end({ "tool.unclosed": true });
+      generation?.end();
+      if (phases && firstTextAt !== void 0) {
+        const firstText = asNum(phases.offsets.first_text);
+        if (firstText !== void 0 && firstTextAt - firstText >= startedAt) {
+          const origin = firstTextAt - firstText;
+          prompt.record("sandbox.transit", "sandbox", startedAt, origin, { note: "sdk, api, orchestrator and host hops, both ways" });
+          let previous = 0;
+          for (const phase of PHASES) {
+            const offset = asNum(phases.offsets[phase]);
+            if (offset === void 0 || offset < previous) continue;
+            prompt.record(`sidecar.${phase}`, phase === "first_upstream_byte" || phase === "first_text" ? "model" : "sandbox", origin + previous, origin + offset);
+            previous = offset;
+          }
+        }
+      }
+      prompt.set({
+        events,
+        ...firstEventAt !== void 0 ? { first_event_ms: firstEventAt - startedAt } : {},
+        ...firstTextAt !== void 0 ? { first_text_ms: firstTextAt - startedAt } : {},
+        ...phases?.warm !== null && phases?.warm !== void 0 ? { "sidecar.harness_warm": phases.warm } : {},
+        ...phases?.model ? { "sidecar.model": phases.model } : {},
+        ...Object.fromEntries(PHASES.flatMap((phase) => {
+          const offset = asNum(phases?.offsets[phase]);
+          return offset === void 0 ? [] : [[`sidecar.${phase}_ms`, Math.round(offset)]];
+        }))
+      });
+      prompt.end(void 0, error);
+    } catch {
+    }
+  };
+  return { observe, end };
+}
+
 // src/sandbox/model.ts
 function backendModelFields(model) {
   return {
@@ -427,7 +537,14 @@ var DEFAULT_TIMEOUT_MS = 5 * 6e4;
 var TASK_LIMIT = 2e4;
 var SANDBOX_RUN_DESCRIPTION = "Run work that needs a computer in this workspace's sandbox: executing code or scripts, reading or converting PDFs, spreadsheets and archives, filling forms with the installed toolkits, or editing many files. Describe the whole task and the result you need; the sandbox agent does it and returns its answer. Takes seconds to minutes, so use it only when the answer needs the computer.";
 function sandboxPromptRunner(shell, prompt = {}) {
-  return (box, task, { signal, timeoutMs }) => runSandboxPrompt(shell, box, task, { ...prompt, signal, timeoutMs, disallowQuestions: true });
+  return (box, task, { signal, timeoutMs, trace, span }) => runSandboxPrompt(shell, box, task, {
+    ...prompt,
+    signal,
+    timeoutMs,
+    disallowQuestions: true,
+    ...trace ? { trace } : {},
+    ...span ? { traceParent: span } : {}
+  });
 }
 function createSandboxRunTool(options) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -466,16 +583,25 @@ function createSandboxRunTool(options) {
         signal.addEventListener("abort", () => reject(signal.reason), { once: true });
       })]);
       let box;
+      const claim = context?.span?.child("sandbox.claim", "sandbox");
       try {
         box = await capped(options.box(signal));
+        claim?.end();
       } catch (error) {
+        claim?.end(void 0, error instanceof SandboxRunError ? error.code : "sandbox_unavailable");
         if (error instanceof SandboxRunError) return fail2(error.code, error.message, error.cause);
         return fail2("sandbox_unavailable", "The sandbox for this workspace could not start, so this work was not done.", error);
       }
       emit("box_ready", { ms: Date.now() - started });
       let answer;
       try {
-        answer = await capped(runTask(box, task, { signal, timeoutMs: Math.max(1, timeoutMs - (Date.now() - started)), emit }));
+        answer = await capped(runTask(box, task, {
+          signal,
+          timeoutMs: Math.max(1, timeoutMs - (Date.now() - started)),
+          emit,
+          ...context?.trace ? { trace: context.trace } : {},
+          ...context?.span ? { span: context.span } : {}
+        }));
       } catch (error) {
         const timedOut = signal.aborted && !options.signal?.aborted;
         return fail2("sandbox_failed", timedOut ? `The sandbox did not finish within ${Math.round(timeoutMs / 1e3)} s, so this work was not done.` : "The sandbox run failed, so this work was not done.", error);
@@ -559,10 +685,13 @@ function createSandboxExecTool(options) {
       if (options.warm) await options.warm.leases.turn(options.warm.key).catch(() => {
       });
       let box;
+      const reused = ready !== null;
+      const claim = context?.span?.child("sandbox.claim", "sandbox");
       const starting = place(signal);
       try {
         box = await raceAbort(starting, signal);
       } catch (error) {
+        claim?.end(void 0, error instanceof SandboxRunError ? error.code : "sandbox_unavailable");
         if (ready === starting) ready = null;
         if (error instanceof SandboxRunError) {
           options.onFailure?.(error);
@@ -570,15 +699,22 @@ function createSandboxExecTool(options) {
         }
         return fail2("sandbox_unavailable", "The sandbox did not start in time, so the command did not run.", error);
       }
+      claim?.end({ "claim.reused": reused });
       emit("box_ready", { ms: Date.now() - started });
       let result;
+      const execSpan = context?.span?.child("sandbox.exec", "sandbox");
       try {
         result = await raceAbort(box.exec(command, {
           ...cwd ? { cwd } : {},
           ...options.env ? { env: options.env } : {},
-          timeoutMs: Math.max(1, timeoutMs - (Date.now() - started))
+          timeoutMs: Math.max(1, timeoutMs - (Date.now() - started)),
+          // The same id the Router turn sends, so this command's Sandbox API and host records join the turn.
+          // SDK 0.62.2 added `traceId` to ExecOptions; an older SDK ignores the field.
+          ...context?.trace ? { traceId: context.trace.traceId } : {}
         }), signal);
+        execSpan?.end({ "exec.exit_code": result.exitCode });
       } catch (error) {
+        execSpan?.end(void 0, "exec_failed");
         const timedOut = signal.aborted && !options.signal?.aborted;
         return fail2("sandbox_failed", timedOut ? `The command did not finish within ${Math.round(timeoutMs / 1e3)} s.` : "The command could not run in the sandbox.", error);
       }
@@ -2384,9 +2520,24 @@ async function ensureWorkspaceSandbox(shell, options) {
     workspaceId: options.workspaceId,
     ...options.userId ? { userId: options.userId } : {}
   });
-  const box = await bringUpWorkspaceSandbox(shell, options);
-  await observeProvisionedBox(shell, options, box);
-  return box;
+  const { trace } = options;
+  const claim = trace?.start("sandbox.claim", "sandbox", { "workspace.harness": options.harness }, options.traceParent);
+  const traced = trace && claim ? {
+    ...options,
+    measure: (stage, operation) => {
+      const run = () => trace.measure(stage, "sandbox", () => operation(), void 0, claim);
+      return options.measure ? options.measure(stage, run) : run();
+    }
+  } : options;
+  try {
+    const box = await bringUpWorkspaceSandbox(shell, traced);
+    claim?.end({ "sandbox.id": box.id });
+    await observeProvisionedBox(shell, options, box);
+    return box;
+  } catch (error) {
+    claim?.end(void 0, error);
+    throw error;
+  }
 }
 async function observeProvisionedBox(shell, options, box) {
   if (!options.spend?.onProvisioned) return;
@@ -2521,11 +2672,12 @@ async function provisionWorkspaceSandbox(shell, options) {
     }
   }
   if (!replacementRequested && !forceNew && shell.resumeStopped !== false) {
-    const stopped = await listStopped(client, name);
+    const stopped = await measure("list_stopped", () => listStopped(client, name));
     if (!stopped.succeeded) throw stopped.error;
     if (stopped.value) {
-      const runtimeEnv2 = await resolveWorkspaceRuntimeEnv(shell, scope);
-      const resumed = await resumeStoppedBox(stopped.value, resumeTimeout, runtimeEnv2, onProgress);
+      const stoppedBox = stopped.value;
+      const runtimeEnv2 = await measure("runtime_env", () => resolveWorkspaceRuntimeEnv(shell, scope));
+      const resumed = await measure("resume", () => resumeStoppedBox(stoppedBox, resumeTimeout, runtimeEnv2, onProgress));
       if (!resumed.succeeded) {
         const recovery = await requestSandboxReplacement(
           shell.recoverStoppedSandbox,
@@ -2635,12 +2787,12 @@ async function provisionWorkspaceSandbox(shell, options) {
     SHELL_PROMPT_BUDGET_HINT
   );
   assertProvisionPayloadWithinCap(payload ?? {});
-  let box = await client.create(payload);
-  await box.waitFor("running", {
+  let box = await measure("create", () => client.create(payload));
+  await measure("wait_running", () => box.waitFor("running", {
     timeoutMs: shell.provisionTimeoutMs ?? DEFAULT_PROVISION_TIMEOUT_MS,
     ...onProgress ? { onProgress } : {}
-  });
-  box = await refreshRuntimeConnection(client, box);
+  }));
+  box = await measure("refresh_connection", () => refreshRuntimeConnection(client, box));
   if (deferredFiles.length > 0) {
     const written = await writeProfileFilesToBox(box, deferredFiles);
     if (!written.succeeded) {
@@ -2648,7 +2800,8 @@ async function provisionWorkspaceSandbox(shell, options) {
     }
   }
   if (shell.bootstrap) {
-    const boot = await shell.bootstrap(box, scope);
+    const bootstrap = shell.bootstrap.bind(shell);
+    const boot = await measure("bootstrap", () => bootstrap(box, scope));
     if (!boot.succeeded) {
       throw new Error(`bootstrap failed on new box ${name}`, { cause: boot.error });
     }
@@ -2793,7 +2946,8 @@ async function* detachedSandboxPromptEvents(box, prompt, options, backend) {
     ...options.expectedSecretProfileReceipt ? { expectedSecretProfileReceipt: options.expectedSecretProfileReceipt } : {},
     ...options.requireVisibleAssistantOutput !== void 0 ? { requireVisibleAssistantOutput: options.requireVisibleAssistantOutput } : {},
     ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
-    ...options.ttlMs !== void 0 ? { ttlMs: options.ttlMs } : {}
+    ...options.ttlMs !== void 0 ? { ttlMs: options.ttlMs } : {},
+    ...options.trace ? { traceId: options.trace.traceId } : {}
   });
   const admittedExecutionId = admission?.executionId ?? executionId;
   if (!admittedExecutionId) {
@@ -2810,6 +2964,7 @@ async function* detachedSandboxPromptEvents(box, prompt, options, backend) {
     sessionId: admission?.sessionId ?? sessionId,
     executionId: admittedExecutionId,
     lastEventId: lastEventId || "0",
+    ...options.trace ? { traceId: options.trace.traceId } : {},
     ...options.signal ? { signal: options.signal } : {}
   });
 }
@@ -3031,13 +3186,22 @@ async function* streamSandboxPrompt(shell, box, message, options) {
     ...options?.requireVisibleAssistantOutput !== void 0 ? { requireVisibleAssistantOutput: options.requireVisibleAssistantOutput } : {},
     ...options?.expectedPublicProfileRequestDigest ? { expectedPublicProfileRequestDigest: options.expectedPublicProfileRequestDigest } : {},
     ...options?.expectedSecretProfileReceipt ? { expectedSecretProfileReceipt: options.expectedSecretProfileReceipt } : {},
+    ...options?.trace ? { traceId: options.trace.traceId } : {},
     backend
   });
   const stream = options?.lastEventId ? dispatch() : resendRefusedDispatch(dispatch, options?.signal);
   emitSandboxActivity(options?.spend, box);
   let severedFinishReason = null;
+  const promptTrace = options?.trace ? createPromptTrace(options.trace, options.traceParent, {
+    "sandbox.id": box.id,
+    ...options.model ? { "gen_ai.request.model": options.model } : {},
+    ...options.harness ? { "sandbox.harness": options.harness } : {},
+    ...options.detach ? { "sandbox.detached": true } : {}
+  }) : void 0;
+  let promptError;
   try {
     for await (const event of stream) {
+      promptTrace?.observe(event);
       const step = classifySeveredStream(event);
       if (step) severedFinishReason = step.kind === "step-finish" && step.severed ? step.reason : null;
       if (severedFinishReason && isTerminalPromptEvent(event)) {
@@ -3051,8 +3215,12 @@ async function* streamSandboxPrompt(shell, box, message, options) {
       }
       yield event;
     }
+  } catch (error) {
+    promptError = error;
+    throw error;
   } finally {
     emitSandboxActivity(options?.spend, box);
+    promptTrace?.end(promptError);
   }
   if (severedFinishReason) {
     throw new Error(`sandbox model stream severed mid-turn (reason="${severedFinishReason}")`);
@@ -3345,4 +3513,4 @@ export {
   isTerminalPromptEvent,
   detectInteractiveQuestion
 };
-//# sourceMappingURL=chunk-SUIH5B55.js.map
+//# sourceMappingURL=chunk-RJJRRR5Z.js.map