@tangle-network/agent-runtime 0.79.0 → 0.79.1

package/dist/{chunk-EZ2QESTP.js → chunk-TSDKBFZP.js}

@@ -1,6 +1,21 @@
 import {
   buildLoopSpanNodes
 } from "./chunk-VMNEQHJR.js";
+import {
+  addTokenUsage,
+  deleteBoxSafe,
+  mapWithConcurrency,
+  providerAsExecutor,
+  randomSuffix,
+  randomUuid,
+  resolveAgentEnvironmentProvider,
+  sleep,
+  stringifySafe,
+  throwAbort,
+  throwIfAborted,
+  withTimeout,
+  zeroTokenUsage
+} from "./chunk-Z3RRRPRB.js";
 import {
   extractLlmCallEvent
 } from "./chunk-T2HVQVB4.js";
@@ -31,118 +46,6 @@ function assertModelAllowed(model, allowed) {
 
 // src/durable/spawn-journal.ts
 import { createHash } from "crypto";
-
-// src/runtime/util.ts
-async function deleteBoxSafe(box) {
-  if (!box || typeof box.delete !== "function") return true;
-  try {
-    await box.delete();
-    return true;
-  } catch {
-    return false;
-  }
-}
-function randomSuffix(len = 8) {
-  return Math.random().toString(36).slice(2, 2 + len);
-}
-function randomUuid() {
-  return crypto.randomUUID();
-}
-function abortError() {
-  const err = new Error("aborted");
-  err.name = "AbortError";
-  return err;
-}
-function throwAbort() {
-  throw abortError();
-}
-function throwIfAborted(signal) {
-  if (signal?.aborted) throw abortError();
-}
-function isAbortError(err) {
-  return err instanceof Error && err.name === "AbortError";
-}
-function sleep(ms, signal) {
-  return new Promise((resolve) => {
-    if (signal?.aborted) {
-      resolve();
-      return;
-    }
-    let onAbort;
-    const timer = setTimeout(() => {
-      if (onAbort && signal) signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    if (signal) {
-      onAbort = () => {
-        clearTimeout(timer);
-        resolve();
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-  });
-}
-function withTimeout(promise, ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => resolve(void 0), ms);
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve(value);
-      },
-      () => {
-        clearTimeout(timer);
-        resolve(void 0);
-      }
-    );
-  });
-}
-function stringifySafe(value, opts = {}) {
-  let s;
-  try {
-    if (typeof value === "string") {
-      s = value;
-    } else {
-      const json = opts.pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value);
-      s = json ?? String(value);
-    }
-  } catch {
-    s = String(value);
-  }
-  if (opts.max !== void 0 && s.length > opts.max) return `${s.slice(0, opts.max)}\u2026`;
-  return s;
-}
-function zeroTokenUsage() {
-  return { input: 0, output: 0 };
-}
-function addTokenUsage(acc, delta) {
-  acc.input += delta.input ?? 0;
-  acc.output += delta.output ?? 0;
-}
-async function mapWithConcurrency(items, limit, fn) {
-  const bound = Math.max(1, Math.floor(limit));
-  const results = new Array(items.length);
-  let next = 0;
-  let failed = false;
-  const worker = async () => {
-    while (!failed) {
-      const i = next;
-      next += 1;
-      if (i >= items.length) return;
-      try {
-        results[i] = await fn(items[i], i);
-      } catch (err) {
-        failed = true;
-        throw err;
-      }
-    }
-  };
-  const workerCount = Math.min(bound, items.length);
-  await Promise.all(Array.from({ length: workerCount }, () => worker()));
-  return results;
-}
-
-// src/durable/spawn-journal.ts
 function contentAddress(artifact) {
   const hex = createHash("sha256").update(stableStringify(artifact), "utf-8").digest("hex");
   return `sha256:${hex}`;
@@ -208,786 +111,6 @@ function assertSeqUnique(root, events, ev) {
   }
 }
 
-// src/runtime/environment-provider.ts
-function createAgentEnvironmentProviderRegistry(providers = []) {
-  const entries = /* @__PURE__ */ new Map();
-  const registry = {
-    register(provider, options = {}) {
-      if (!provider.name) {
-        throw new ValidationError("agent environment provider registry: provider.name required");
-      }
-      if (!options.replace && entries.has(provider.name)) {
-        throw new ValidationError(
-          `agent environment provider registry: provider "${provider.name}" already registered`
-        );
-      }
-      entries.set(provider.name, provider);
-    },
-    has(name) {
-      return entries.has(name);
-    },
-    get(name) {
-      return entries.get(name);
-    },
-    require(name) {
-      const provider = entries.get(name);
-      if (!provider) {
-        const available = Array.from(entries.keys()).sort();
-        const suffix = available.length > 0 ? `; available: ${available.join(", ")}` : "";
-        throw new ValidationError(
-          `agent environment provider registry: provider "${name}" is not registered${suffix}`
-        );
-      }
-      return provider;
-    },
-    names() {
-      return Array.from(entries.keys()).sort();
-    },
-    providers() {
-      return registry.names().map((name) => registry.require(name));
-    },
-    async capabilities(name) {
-      return registry.require(name).capabilities();
-    }
-  };
-  for (const provider of providers) registry.register(provider);
-  return registry;
-}
-function resolveAgentEnvironmentProvider(provider, registry) {
-  if (typeof provider !== "string") return provider;
-  if (!registry) {
-    throw new ValidationError(
-      `agent environment provider "${provider}" requires an AgentEnvironmentProviderRegistry`
-    );
-  }
-  return registry.require(provider);
-}
-function providerAsSandboxClient(provider, options = {}) {
-  return {
-    async create(createOptions) {
-      const mapped = {
-        ...options.defaults ?? {},
-        ...createInputFromSandboxOptions(createOptions),
-        ...options.mapCreateOptions?.(createOptions) ?? {}
-      };
-      if (mapped.profile === void 0) {
-        throw new ValidationError(
-          `providerAsSandboxClient(${provider.name}): profile required in defaults or CreateSandboxOptions.backend.profile`
-        );
-      }
-      const environment = await provider.create(mapped);
-      return environmentAsSandboxInstance(environment, {
-        requireTerminalEvent: options.requireTerminalEvent ?? true
-      });
-    }
-  };
-}
-function sandboxClientAsProvider(client, options = {}) {
-  const providerName = options.name ?? "tangle-sandbox";
-  return {
-    name: providerName,
-    capabilities: async () => {
-      if (options.capabilities) {
-        return typeof options.capabilities === "function" ? options.capabilities() : options.capabilities;
-      }
-      return defaultTangleSandboxCapabilities();
-    },
-    ...options.validateProfile ? { validateProfile: options.validateProfile } : {},
-    async create(input) {
-      const createOptions = options.mapCreateInput?.(input) ?? sandboxOptionsFromCreateInput(input, options.defaultBackend ?? "opencode");
-      const box = await client.create(createOptions);
-      return sandboxInstanceAsEnvironment(box, providerName, client);
-    },
-    ...hasGet(client) ? {
-      async get(id) {
-        const box = await client.get(id);
-        return box ? sandboxInstanceAsEnvironment(box, providerName, client) : null;
-      }
-    } : {},
-    ...hasList(client) ? {
-      async list(query) {
-        const boxes = await client.list(query?.providerOptions);
-        return boxes.map((box) => ({
-          id: String(box.id),
-          provider: providerName,
-          name: typeof box.name === "string" ? box.name : void 0,
-          status: statusFromUnknown(readBoxStatus(box)),
-          metadata: readBoxMetadata(box)
-        }));
-      }
-    } : {}
-  };
-}
-function providerAsExecutor(provider, options = {}) {
-  return (spec, ctx) => createProviderExecutor(provider, spec.profile, ctx, options);
-}
-function createProviderExecutor(provider, profile, ctx, options) {
-  const controller = new AbortController();
-  const abortIfSignalled = () => {
-    if (ctx.signal.aborted) controller.abort();
-  };
-  abortIfSignalled();
-  if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
-  let environment;
-  let artifact;
-  return {
-    runtime: options.runtime ?? provider.name,
-    execute(task, signal) {
-      return streamProviderExecutor({
-        provider,
-        profile,
-        task,
-        signal,
-        controller,
-        options,
-        onEnvironment: (env) => {
-          environment = env;
-        },
-        onArtifact: (next) => {
-          artifact = next;
-        }
-      });
-    },
-    async teardown(_grace) {
-      controller.abort();
-      await environment?.destroy?.();
-      return { destroyed: true };
-    },
-    resultArtifact() {
-      if (!artifact) {
-        throw new ValidationError(
-          `providerAsExecutor(${provider.name}): resultArtifact() read before stream drained`
-        );
-      }
-      return artifact;
-    }
-  };
-}
-async function* streamProviderExecutor(args) {
-  const started = Date.now();
-  const linked = mergeAbortSignals(args.signal, args.controller.signal);
-  const environment = await args.provider.create({
-    ...args.options.defaults ?? {},
-    profile: args.profile,
-    signal: linked
-  });
-  args.onEnvironment(environment);
-  const turn = args.options.taskToTurn?.(args.task, args.profile) ?? taskToTurnInput(args.task, linked);
-  const events = [];
-  const tokens = zeroTokenUsage();
-  let usd = 0;
-  let text = "";
-  let terminal = false;
-  try {
-    for await (const event of environment.stream({ ...turn, signal: linked })) {
-      events.push(event);
-      text += textFromEnvironmentEvent(event);
-      const usage = usageFromEnvironmentEvent(event);
-      if (usage.input || usage.output) {
-        tokens.input += usage.input;
-        tokens.output += usage.output;
-        yield { kind: "tokens", input: usage.input, output: usage.output };
-      }
-      if (usage.usd) {
-        usd += usage.usd;
-        yield { kind: "cost", usd: usage.usd };
-      }
-      if (isTerminalEnvironmentEvent(event)) terminal = true;
-    }
-    if ((args.options.requireTerminalEvent ?? true) && !terminal) {
-      throw new ValidationError(
-        `providerAsExecutor(${args.provider.name}): stream ended without a terminal result/done/status event`
-      );
-    }
-    yield { kind: "iteration" };
-    const result = resultFromEvents(events, text);
-    const spent = {
-      iterations: 1,
-      tokens,
-      usd,
-      ms: Date.now() - started
-    };
-    args.onArtifact({
-      outRef: contentRef(`provider:${args.provider.name}`, result),
-      out: result,
-      spent
-    });
-  } finally {
-    if (args.options.destroyOnSettle ?? true) await environment.destroy?.();
-  }
-}
-function createInputFromSandboxOptions(options) {
-  const profile = options?.backend?.profile;
-  const backend = options?.backend?.type;
-  return {
-    ...profile !== void 0 ? { profile } : {},
-    ...backend ? { backend } : {},
-    workspace: {
-      ...options?.environment ? { environment: options.environment } : {},
-      ...options?.image ? { image: options.image } : {},
-      ...options?.git?.url ? { repoUrl: options.git.url } : {},
-      ...options?.git?.ref ? { gitRef: options.git.ref } : {}
-    },
-    ...options?.resources ? { resources: options.resources } : {},
-    ...options?.env ? { env: options.env } : {},
-    ...options?.secrets ? { secrets: options.secrets } : {},
-    ...options?.metadata ? { metadata: options.metadata } : {},
-    ...options?.name ? { name: options.name } : {},
-    ...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
-    providerOptions: { sandboxCreateOptions: options ?? {} }
-  };
-}
-function sandboxOptionsFromCreateInput(input, defaultBackend) {
-  const backendType = input.backend ?? defaultBackend;
-  const workspace = input.workspace ?? {};
-  const providerOptions = input.providerOptions?.sandboxCreateOptions;
-  const base = providerOptions && typeof providerOptions === "object" ? { ...providerOptions } : {};
-  return {
-    ...base,
-    ...workspace.environment ? { environment: workspace.environment } : {},
-    ...workspace.image ? { image: workspace.image } : {},
-    ...workspace.repoUrl ? { git: { url: workspace.repoUrl, ref: workspace.gitRef } } : {},
-    ...input.resources ? { resources: input.resources } : {},
-    ...input.env ? { env: input.env } : {},
-    ...Array.isArray(input.secrets) ? { secrets: input.secrets } : {},
-    ...input.metadata ? { metadata: input.metadata } : {},
-    ...input.name ? { name: input.name } : {},
-    ...input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {},
-    backend: {
-      ...base.backend ?? {},
-      type: backendType,
-      profile: input.profile
-    }
-  };
-}
-function environmentAsSandboxInstance(environment, options) {
-  const box = {
-    id: environment.id,
-    name: environment.name,
-    status: "running",
-    async refresh() {
-      await environment.refresh?.();
-    },
-    async *streamPrompt(message, promptOptions) {
-      let terminal = false;
-      const input = turnInputFromPrompt(message, promptOptions);
-      for await (const event of environment.stream(input)) {
-        if (isTerminalEnvironmentEvent(event)) terminal = true;
-        const usageEvent = usageSandboxEvent(event);
-        if (usageEvent) yield usageEvent;
-        yield sandboxEventFromEnvironmentEvent(event);
-      }
-      if (options.requireTerminalEvent && !terminal) {
-        throw new ValidationError(
-          `providerAsSandboxClient(${environment.provider}): stream ended without a terminal result/done/status event`
-        );
-      }
-    },
-    async prompt(message, promptOptions) {
-      const events = [];
-      let text = "";
-      let usage;
-      let terminal = false;
-      for await (const event of environment.stream(turnInputFromPrompt(message, promptOptions))) {
-        events.push(event);
-        if (isTerminalEnvironmentEvent(event)) terminal = true;
-        text += textFromEnvironmentEvent(event);
-        usage = mergeTokenUsage(usage, event.usage);
-      }
-      if (options.requireTerminalEvent && !terminal) {
-        throw new ValidationError(
-          `providerAsSandboxClient(${environment.provider}): prompt ended without a terminal result/done/status event`
-        );
-      }
-      return {
-        response: resultFromEvents(events, text).content,
-        success: true,
-        durationMs: 0,
-        ...usage ? { usage } : {}
-      };
-    },
-    ...environment.dispatch ? {
-      async dispatchPrompt(message, promptOptions) {
-        const session = await environment.dispatch?.(
-          turnInputFromPrompt(message, promptOptions)
-        );
-        if (!session)
-          throw new ValidationError("providerAsSandboxClient: dispatch returned no session");
-        return sandboxDispatchResultFromSessionRef(session);
-      }
-    } : {},
-    ...environment.session ? {
-      session(id) {
-        return sessionAsSandboxSession(environment.session?.(id));
-      }
-    } : {},
-    ...environment.read ? { read: environment.read.bind(environment) } : {},
-    ...environment.write ? { write: environment.write.bind(environment) } : {},
-    ...environment.exec ? {
-      exec: environment.exec.bind(environment)
-    } : {},
-    ...environment.checkpoint ? {
-      async checkpoint(checkpointOptions) {
-        const checkpoint = await environment.checkpoint?.(checkpointOptions);
-        return { checkpointId: checkpoint?.id, id: checkpoint?.id };
-      }
-    } : {},
-    ...environment.fork ? {
-      async fork(checkpointId, forkOptions) {
-        const forked = await environment.fork?.({ id: checkpointId }, forkOptions);
-        if (!forked)
-          throw new ValidationError("providerAsSandboxClient: fork returned no environment");
-        return environmentAsSandboxInstance(forked, options);
-      }
-    } : {},
-    async delete() {
-      await environment.destroy?.();
-    }
-  };
-  return box;
-}
-function sandboxInstanceAsEnvironment(box, providerName, client) {
-  const environment = {
-    id: String(box.id),
-    provider: providerName,
-    ...typeof box.name === "string" ? { name: box.name } : {},
-    async status() {
-      await maybeRefresh(box);
-      return statusFromUnknown(readBoxStatus(box));
-    },
-    async *stream(input) {
-      for await (const event of box.streamPrompt(
-        promptFromTurnInput(input),
-        promptOptionsFromTurnInput(input)
-      )) {
-        yield environmentEventFromSandboxEvent(event);
-      }
-    },
-    ...hasDispatchPrompt(box) ? {
-      async dispatch(input) {
-        const dispatched = await box.dispatchPrompt(
-          promptFromTurnInput(input),
-          promptOptionsFromTurnInput(input)
-        );
-        return sessionRefFromSandboxDispatch(dispatched, providerName);
-      }
-    } : {},
-    ...hasSession(box) ? {
-      session(id) {
-        return sandboxSessionAsAgentSession(box.session(id));
-      }
-    } : {},
-    ...hasRead(box) ? { read: box.read.bind(box) } : {},
-    ...hasWrite(box) ? { write: box.write.bind(box) } : {},
-    ...hasExec(box) ? {
-      async exec(command, options) {
-        return execResultFromSandboxExecResult(await box.exec(command, options));
-      }
-    } : {},
-    ...hasCheckpoint(box) ? {
-      async checkpoint(options) {
-        const result = await box.checkpoint(options);
-        return { id: checkpointIdFromResult(result), provider: providerName };
-      }
-    } : {},
-    ...hasFork(box) ? {
-      async fork(checkpoint, options) {
-        const forked = await box.fork(checkpoint.id, options);
-        return sandboxInstanceAsEnvironment(forked, providerName, client);
-      }
-    } : {},
-    async placement() {
-      return placementInfoFromLoopPlacement(client.describePlacement?.(box), box);
-    },
-    async refresh() {
-      await maybeRefresh(box);
-    },
-    async destroy() {
-      await destroyBox(box);
-    }
-  };
-  return environment;
-}
-function sandboxSessionAsAgentSession(session) {
-  return {
-    id: session.id,
-    async status() {
-      const status = await session.status();
-      if (!status) return null;
-      return sessionStatusFromUnknown(status.status);
-    },
-    async *events(options) {
-      for await (const event of session.events(options))
-        yield environmentEventFromSandboxEvent(event);
-    },
-    async result() {
-      return agentTurnResultFromPromptResult(await session.result());
-    },
-    async prompt(input) {
-      return agentTurnResultFromPromptResult(
-        await session.prompt(promptFromTurnInput(input), promptOptionsFromTurnInput(input))
-      );
-    },
-    cancel() {
-      return session.cancel();
-    }
-  };
-}
-function sessionAsSandboxSession(session) {
-  if (!session) throw new ValidationError("providerAsSandboxClient: session(id) returned undefined");
-  return {
-    id: session.id,
-    status: session.status.bind(session),
-    async *events(options) {
-      for await (const event of session.events(options))
-        yield sandboxEventFromEnvironmentEvent(event);
-    },
-    async result() {
-      return promptResultFromAgentTurnResult(await session.result());
-    },
-    async prompt(message, options) {
-      return promptResultFromAgentTurnResult(
-        await session.prompt(turnInputFromPrompt(message, options))
-      );
-    },
-    cancel: session.cancel.bind(session)
-  };
-}
-function environmentEventFromSandboxEvent(event) {
-  const data = event.data && typeof event.data === "object" ? event.data : {};
-  return {
-    type: String(event.type),
-    data,
-    ...event.id ? { id: event.id } : {},
-    usage: tokenUsageFromData(data),
-    providerEvent: event
-  };
-}
-function sandboxEventFromEnvironmentEvent(event) {
-  return {
-    type: event.type,
-    data: {
-      ...event.data,
-      ...event.usage ? { usage: tokenUsageData(event.usage) } : {}
-    },
-    ...event.id ? { id: event.id } : {}
-  };
-}
-function usageSandboxEvent(event) {
-  if (!event.usage || isUsageType(event.type)) return void 0;
-  const usage = tokenUsageData(event.usage);
-  if (usage.inputTokens === void 0 && usage.outputTokens === void 0 && usage.totalCostUsd === void 0) {
-    return void 0;
-  }
-  return { type: "llm_call", data: usage };
-}
-function tokenUsageData(usage) {
-  return {
-    inputTokens: usage.inputTokens,
-    outputTokens: usage.outputTokens,
-    totalCostUsd: usage.cost
-  };
-}
-function turnInputFromPrompt(message, options) {
-  return {
-    ...typeof message === "string" ? { prompt: message } : { parts: message },
-    ...options?.sessionId ? { sessionId: options.sessionId } : {},
-    ...options?.model ? { model: options.model } : {},
-    ...options?.timeoutMs ? { timeoutMs: options.timeoutMs } : {},
-    ...options?.executionId ? { executionId: options.executionId } : {},
-    ...options?.lastEventId ? { lastEventId: options.lastEventId } : {},
-    ...options?.turnId ? { turnId: options.turnId } : {},
-    ...options?.detach !== void 0 ? { detach: options.detach } : {},
-    ...options?.context ? { context: options.context } : {},
-    ...options?.signal ? { signal: options.signal } : {},
-    ...options?.backend ? { providerOptions: { backend: options.backend } } : {}
-  };
-}
-function promptFromTurnInput(input) {
-  if (input.parts) return input.parts;
-  return input.prompt ?? "";
-}
-function promptOptionsFromTurnInput(input) {
-  return {
-    ...input.sessionId ? { sessionId: input.sessionId } : {},
-    ...input.model ? { model: input.model } : {},
-    ...input.timeoutMs ? { timeoutMs: input.timeoutMs } : {},
-    ...input.context ? { context: input.context } : {},
-    ...input.signal ? { signal: input.signal } : {},
-    ...input.executionId ? { executionId: input.executionId } : {},
-    ...input.lastEventId ? { lastEventId: input.lastEventId } : {},
-    ...input.turnId ? { turnId: input.turnId } : {},
-    ...input.detach !== void 0 ? { detach: input.detach } : {}
-  };
-}
-function taskToTurnInput(task, signal) {
-  return { prompt: taskToPrompt(task), signal };
-}
-function taskToPrompt(task) {
-  if (typeof task === "string") return task;
-  if (task && typeof task === "object") {
-    const record = task;
-    for (const key of ["prompt", "content", "task", "message"]) {
-      if (typeof record[key] === "string") return record[key];
-    }
-  }
-  return JSON.stringify(task);
-}
-function resultFromEvents(events, fallbackText) {
-  for (let i = events.length - 1; i >= 0; i -= 1) {
-    const event = events[i];
-    const text = event ? resultTextFromData(event.data) : void 0;
-    if (text !== void 0) return { content: text, events };
-  }
-  return { content: fallbackText, events };
-}
-function textFromEnvironmentEvent(event) {
-  if (typeof event.normalized === "object" && event.normalized && event.normalized.type === "message.part.updated") {
-    return typeof event.normalized.delta === "string" ? event.normalized.delta : "";
-  }
-  const data = event.data;
-  for (const key of ["delta", "chunk", "content", "text"]) {
-    if (typeof data[key] === "string" && !isTerminalEnvironmentEvent(event)) return data[key];
-  }
-  return "";
-}
-function resultTextFromData(data) {
-  for (const key of ["finalText", "text", "response", "resultSummary", "content"]) {
-    if (typeof data[key] === "string") return data[key];
-  }
-  return void 0;
-}
-function isTerminalEnvironmentEvent(event) {
-  if (event.type === "result" || event.type === "done" || event.type === "final") return true;
-  if (event.type.endsWith(".completed") || event.type.endsWith(".failed")) return true;
-  if (event.type === "status") {
-    const status = event.data.status;
-    return status === "completed" || status === "failed" || status === "cancelled";
-  }
-  return false;
-}
-function isUsageType(type) {
-  return type === "llm_call" || type === "usage" || type === "cost.usage";
-}
-function usageFromEnvironmentEvent(event) {
-  const usage = event.usage ?? tokenUsageFromData(event.data);
-  return {
-    input: finiteNumber(usage?.inputTokens) ?? 0,
-    output: finiteNumber(usage?.outputTokens) ?? 0,
-    usd: finiteNumber(usage?.cost) ?? finiteNumber(event.data.costUsd) ?? finiteNumber(event.data.totalCostUsd) ?? 0
-  };
-}
-function tokenUsageFromData(data) {
-  const usageRecord = data.usage && typeof data.usage === "object" ? data.usage : data.tokenUsage && typeof data.tokenUsage === "object" ? data.tokenUsage : data;
-  const inputTokens = finiteNumber(usageRecord.inputTokens) ?? finiteNumber(usageRecord.tokensIn) ?? finiteNumber(usageRecord.prompt_tokens);
-  const outputTokens = finiteNumber(usageRecord.outputTokens) ?? finiteNumber(usageRecord.tokensOut) ?? finiteNumber(usageRecord.completion_tokens);
-  const cost = finiteNumber(usageRecord.cost) ?? finiteNumber(usageRecord.costUsd) ?? finiteNumber(usageRecord.totalCostUsd) ?? finiteNumber(data.costUsd) ?? finiteNumber(data.totalCostUsd);
-  if (inputTokens === void 0 && outputTokens === void 0 && cost === void 0)
-    return void 0;
-  return {
-    inputTokens: inputTokens ?? 0,
-    outputTokens: outputTokens ?? 0,
-    ...cost !== void 0 ? { cost } : {}
-  };
-}
-function mergeTokenUsage(left, right) {
-  if (!left) return right;
-  if (!right) return left;
-  return {
-    inputTokens: left.inputTokens + right.inputTokens,
-    outputTokens: left.outputTokens + right.outputTokens,
-    ...left.cost !== void 0 || right.cost !== void 0 ? { cost: (left.cost ?? 0) + (right.cost ?? 0) } : {}
-  };
-}
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function promptResultFromAgentTurnResult(result) {
-  return {
-    response: result.text,
-    success: result.success,
-    durationMs: 0,
-    ...result.error ? { error: result.error } : {},
-    ...result.usage ? { usage: result.usage } : {}
-  };
-}
-function agentTurnResultFromPromptResult(result) {
-  const record = result;
-  const text = typeof record.response === "string" ? record.response : typeof record.text === "string" ? record.text : typeof record.finalText === "string" ? record.finalText : "";
-  const success = typeof record.success === "boolean" ? record.success : true;
-  return {
-    text,
-    success,
-    ...typeof record.error === "string" ? { error: record.error } : {},
-    usage: tokenUsageFromData(record)
-  };
-}
-function sandboxDispatchResultFromSessionRef(session) {
-  const hasStatus = session.metadata && Object.hasOwn(session.metadata, "status");
-  const status = hasStatus ? sessionStatusFromUnknown(session.metadata?.status) : "running";
-  return {
-    sessionId: session.id,
-    status,
-    alreadyExisted: session.metadata?.alreadyExisted === true
-  };
-}
-function sessionRefFromSandboxDispatch(dispatched, providerName) {
-  const record = dispatched && typeof dispatched === "object" ? dispatched : void 0;
-  const id = record?.sessionId ?? record?.id;
-  if (typeof id !== "string" || id.length === 0) {
-    throw new ValidationError("sandboxClientAsProvider: dispatch returned no session id");
-  }
-  if (!record) {
-    throw new ValidationError("sandboxClientAsProvider: dispatch returned no session record");
-  }
-  return {
-    id,
-    provider: providerName,
-    metadata: {
-      ...record.status ? { status: record.status } : {},
-      ...record.alreadyExisted !== void 0 ? { alreadyExisted: record.alreadyExisted } : {}
-    }
-  };
-}
-function execResultFromSandboxExecResult(result) {
-  const record = result;
-  const exitCode = finiteNumber(record.exitCode) ?? finiteNumber(record.code);
-  if (exitCode === void 0) {
-    throw new ValidationError("sandboxClientAsProvider: exec returned no exit code");
-  }
-  return {
-    exitCode,
-    stdout: typeof record.stdout === "string" ? record.stdout : "",
-    stderr: typeof record.stderr === "string" ? record.stderr : ""
-  };
-}
-function statusFromUnknown(status) {
-  if (status === "pending" || status === "provisioning" || status === "running") return status;
-  if (status === "stopped" || status === "failed" || status === "expired") return status;
-  if (status === "completed") return "stopped";
-  if (status === "cancelled") return "stopped";
-  return "unknown";
-}
-function sessionStatusFromUnknown(status) {
-  if (status === "completed" || status === "cancelled") return status;
-  return statusFromUnknown(status);
-}
-function readBoxStatus(box) {
-  return box.status;
-}
-function readBoxMetadata(box) {
-  const metadata = box.metadata;
-  return metadata && typeof metadata === "object" ? metadata : void 0;
-}
-async function maybeRefresh(box) {
-  const refresh = box.refresh;
-  if (typeof refresh === "function") await refresh.call(box);
-}
-async function destroyBox(box) {
-  const deleteBox = box.delete;
-  if (typeof deleteBox === "function") await deleteBox.call(box);
-}
-function placementInfoFromLoopPlacement(placement, box) {
-  if (!placement) return { kind: "sandbox", sandboxId: String(box.id) };
-  return {
-    kind: placement.kind === "fleet" ? "fleet" : "sandbox",
-    ...placement.sandboxId ? { sandboxId: placement.sandboxId } : { sandboxId: String(box.id) },
-    ...placement.fleetId ? { fleetId: placement.fleetId } : {},
-    ...placement.machineId ? { machineId: placement.machineId } : {}
-  };
-}
-function checkpointIdFromResult(result) {
-  const record = result && typeof result === "object" ? result : {};
-  const id = record.checkpointId ?? record.id;
-  if (typeof id !== "string" || id.length === 0) {
-    throw new ValidationError("sandboxClientAsProvider: checkpoint returned no checkpoint id");
-  }
-  return id;
-}
-function defaultTangleSandboxCapabilities() {
-  return {
-    profile: {
-      namedProfiles: true,
-      systemPrompt: true,
-      instructions: true,
-      tools: true,
-      permissions: true,
-      mcp: true,
-      subagents: true,
-      resources: {
-        files: true,
-        instructions: true,
-        tools: true,
-        skills: true,
-        agents: true,
-        commands: true
-      },
-      hooks: true,
-      modes: true,
-      runtimeUpdate: true,
-      validation: true
-    },
-    streaming: { live: true, replay: true, detach: true, turnIdempotency: true },
-    sessions: { continue: true, list: true, messages: true },
-    workspace: { read: true, write: true, exec: true, git: true, upload: true, download: true },
-    branching: { checkpoint: true, fork: true },
-    placement: true,
-    usage: true,
-    confidential: true
-  };
-}
-function mergeAbortSignals(a, b) {
-  const controller = new AbortController();
-  const abort = () => controller.abort();
-  if (a.aborted || b.aborted) controller.abort();
-  else {
-    a.addEventListener("abort", abort, { once: true });
-    b.addEventListener("abort", abort, { once: true });
-  }
-  return controller.signal;
-}
-function contentRef(prefix, value) {
-  let str;
-  try {
-    str = JSON.stringify(value) ?? String(value);
-  } catch {
-    str = String(value);
-  }
-  let hash = 2166136261;
-  for (let i = 0; i < str.length; i += 1) {
-    hash ^= str.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return `${prefix}:${(hash >>> 0).toString(16).padStart(8, "0")}`;
-}
-function hasGet(client) {
-  return typeof client.get === "function";
-}
-function hasList(client) {
-  return typeof client.list === "function";
-}
-function hasDispatchPrompt(box) {
-  return typeof box.dispatchPrompt === "function";
-}
-function hasSession(box) {
-  return typeof box.session === "function";
-}
-function hasRead(box) {
-  return typeof box.read === "function";
-}
-function hasWrite(box) {
-  return typeof box.write === "function";
-}
-function hasExec(box) {
-  return typeof box.exec === "function";
-}
-function hasCheckpoint(box) {
-  return typeof box.checkpoint === "function";
-}
-function hasFork(box) {
-  return typeof box.fork === "function";
-}
-
 // src/runtime-hooks.ts
 function defineRuntimeHooks(hooks) {
   return hooks;
@@ -1770,13 +893,13 @@ async function executeIteration(args) {
       await destroySandboxSafe(box, args.ctx.traceEmitter, args.runId, args.now);
     }
   }
-  if (isAbortError2(slot.error) || args.signal.aborted) {
+  if (isAbortError(slot.error) || args.signal.aborted) {
     if (slot.error) throw slot.error;
     throwAbort();
   }
   if (slot.error instanceof ValidationError) throw slot.error;
 }
-function isAbortError2(err) {
+function isAbortError(err) {
   return err instanceof Error && err.name === "AbortError";
 }
 var TEARDOWN_TIMEOUT_MS2 = 15e3;
@@ -2384,7 +1507,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
   } catch (err) {
     reconcileOnce(live.spent);
     await teardownSafe(executor, "brutalKill");
-    const aborted = childAbort.signal.aborted || isAbortError3(err);
+    const aborted = childAbort.signal.aborted || isAbortError2(err);
     return downRecord(errMessage(err), aborted || isInfraError(err), executor.metered?.());
   }
 }
@@ -2486,7 +1609,7 @@ function isAgentSpec(value) {
   const v = value;
   return "profile" in v && "harness" in v;
 }
-function isAbortError3(err) {
+function isAbortError2(err) {
   return typeof err === "object" && err !== null && "name" in err && err.name === "AbortError";
 }
 function isInfraError(err) {
@@ -2988,7 +2111,7 @@ var cliSeamKey = "cli";
 var bridgeSeamKey = "bridge";
 var cliWorktreeSeamKey = "cli-worktree";
 var providerSeamKey = "provider";
-function contentRef2(prefix, value) {
+function contentRef(prefix, value) {
   let str;
   try {
     str = JSON.stringify(value) ?? String(value);
@@ -3041,7 +2164,7 @@ var routerInlineExecutor = (spec, ctx) => {
         ms: Date.now() - started
       };
       const out = { content: r.content };
-      artifact = { outRef: contentRef2("router", { model, content: r.content }), out, spent };
+      artifact = { outRef: contentRef("router", { model, content: r.content }), out, spent };
       return artifact;
     },
     teardown(_grace) {
@@ -3095,7 +2218,7 @@ var routerToolsInlineExecutor = (spec, ctx) => {
         if (pending.length) messages.push({ role: "user", content: inbox.fold(pending) });
         return pending.length > 0;
       };
-      const external = mergeAbortSignals2(signal, controller.signal);
+      const external = mergeAbortSignals(signal, controller.signal);
       for (let t = 0; t < maxTurns; t += 1) {
         flush();
         const interruptSig = inbox.freshInterrupt();
@@ -3199,7 +2322,7 @@ var routerToolsInlineExecutor = (spec, ctx) => {
       const usd = isModelPriced2(model) ? estimateCost2(tokens.input, tokens.output, model) : 0;
       const spent = { iterations: turns, tokens, usd, ms: Date.now() - started };
       const out = { content: lastText };
-      artifact = { outRef: contentRef2("router-tools", { model, content: lastText }), out, spent };
+      artifact = { outRef: contentRef("router-tools", { model, content: lastText }), out, spent };
       return artifact;
     },
     teardown(_grace) {
@@ -3283,7 +2406,7 @@ async function* streamSandboxLeaf(args) {
   }
   const agentRun = {
     profile: args.spec.profile,
-    taskToPrompt: (t) => taskToPrompt2(t),
+    taskToPrompt: (t) => taskToPrompt(t),
     name: args.spec.profile.name ?? args.harness,
     sandboxOverrides: { backend: { type: args.harness } }
   };
@@ -3313,7 +2436,7 @@ async function* streamSandboxLeaf(args) {
       ms: Date.now() - started
     };
     args.onArtifact({
-      outRef: contentRef2("sandbox", { harness: args.harness, out }),
+      outRef: contentRef("sandbox", { harness: args.harness, out }),
       out,
       ...verdict ? { verdict } : {},
       spent
@@ -3370,7 +2493,7 @@ var cliExecutor = (_spec, ctx) => {
   };
 };
 async function* streamCliLeaf(args) {
-  const prompt = taskToPrompt2(args.task);
+  const prompt = taskToPrompt(args.task);
   const proc = spawn3(args.seam.bin, args.seam.args ?? [], {
     ...args.seam.cwd ? { cwd: args.seam.cwd } : {},
     env: { ...process.env, ...args.seam.env ?? {} },
@@ -3408,7 +2531,7 @@ async function* streamCliLeaf(args) {
     );
   }
   const out = { content: chunks.join("") };
-  args.onArtifact({ outRef: contentRef2("cli", out), out, spent: zeroSpend2() });
+  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend2() });
   yield { kind: "iteration" };
 }
 function killWithGrace(proc, grace) {
@@ -3481,13 +2604,13 @@ async function* streamBridgeSession(args) {
   const { seam, inbox } = args;
   const started = Date.now();
   const url = `${seam.bridgeUrl.replace(/\/$/, "")}/v1/chat/completions`;
-  const external = mergeAbortSignals2(args.signal, args.controller.signal);
+  const external = mergeAbortSignals(args.signal, args.controller.signal);
   const tokens = zeroTokenUsage();
   let usd = 0;
   let turns = 0;
   let lastText = "";
   const toolCalls = [];
-  let nextPrompt = taskToPrompt2(args.task);
+  let nextPrompt = taskToPrompt(args.task);
   const system = args.spec.profile.prompt?.systemPrompt;
   for (let t = 0; t < args.maxTurns; t += 1) {
     const pending = inbox.drain();
@@ -3582,7 +2705,7 @@ ${folded}` : folded;
   };
   const out = { content: lastText, toolCalls };
   args.onArtifact({
-    outRef: contentRef2("bridge", { model: seam.model, session: args.sessionId, content: lastText }),
+    outRef: contentRef("bridge", { model: seam.model, session: args.sessionId, content: lastText }),
     out,
     spent
   });
@@ -3733,7 +2856,7 @@ function readSeam(ctx, key, who) {
   }
   return seam;
 }
-function taskToPrompt2(task) {
+function taskToPrompt(task) {
   if (typeof task === "string") return task;
   if (task && typeof task === "object") {
     const obj = task;
@@ -3749,7 +2872,7 @@ function taskToMessages(task, spec) {
   if (typeof system === "string" && system.length > 0) {
     messages.push({ role: "system", content: system });
   }
-  messages.push({ role: "user", content: taskToPrompt2(task) });
+  messages.push({ role: "user", content: taskToPrompt(task) });
   return messages;
 }
 function singleShotDriver(maxIterations) {
@@ -3775,7 +2898,7 @@ function linkSignals2(a, b) {
   b.addEventListener("abort", onAbort, { once: true });
   return c.signal;
 }
-function mergeAbortSignals2(...signals) {
+function mergeAbortSignals(...signals) {
   const c = new AbortController();
   const onAbort = () => c.abort();
   for (const s of signals) {
@@ -6963,23 +6086,9 @@ function routerBrainFromProfile(profile, deps) {
 
 export {
   assertModelAllowed,
-  deleteBoxSafe,
-  randomSuffix,
-  throwAbort,
-  throwIfAborted,
-  isAbortError,
-  sleep,
-  stringifySafe,
-  zeroTokenUsage,
-  addTokenUsage,
   contentAddress,
   InMemoryResultBlobStore,
   InMemorySpawnJournal,
-  createAgentEnvironmentProviderRegistry,
-  resolveAgentEnvironmentProvider,
-  providerAsSandboxClient,
-  sandboxClientAsProvider,
-  providerAsExecutor,
   defineRuntimeHooks,
   composeRuntimeHooks,
   notifyRuntimeHookEvent,
@@ -7069,4 +6178,4 @@ export {
   createInProcessTransport,
   serveCoordinationMcp
 };
-//# sourceMappingURL=chunk-EZ2QESTP.js.map
+//# sourceMappingURL=chunk-TSDKBFZP.js.map