@tangle-network/agent-runtime 0.105.0 → 0.106.0

package/dist/chunk-KRBFHMV6.js

@@ -1,1228 +0,0 @@
-import {
-  zeroTokenUsage
-} from "./chunk-3MDZX7YU.js";
-
-// src/runtime/tangle-sandbox-exact-process-provider.ts
-import { isDeepStrictEqual } from "util";
-var exactProcessProviderMarker = "agent-runtime.exact-process-provider";
-var exactProcessEgressMarker = "agent-runtime.exact-process-egress";
-function createTangleSandboxExactProcessProvider(client, options = {}) {
-  const name = options.name ?? "tangle-sandbox-exact-process";
-  if (!name.trim()) throw new Error("Tangle Sandbox exact-process provider name must not be empty");
-  const exactProcess = {
-    async create(input) {
-      throwIfAborted(input.signal);
-      assertNoProviderOptions(input.providerOptions);
-      const egressPolicy = sandboxEgressPolicy(input.egress);
-      const metadata = exactMetadata(input.metadata, name, egressPolicy);
-      const sandbox = await client.create(
-        {
-          image: requiredText(input.image, "exact-process image"),
-          agent: false,
-          bare: false,
-          publicEdge: false,
-          ephemeral: true,
-          egressPolicy,
-          resources: sandboxResources(input),
-          maxLifetimeSeconds: sandboxLifetimeSeconds(input.maxLifetimeMs),
-          metadata,
-          idempotencyKey: requiredText(input.idempotencyKey, "exact-process idempotency key")
-        },
-        {
-          ...input.provisionTimeoutMs === void 0 ? {} : { timeoutMs: positiveInteger(input.provisionTimeoutMs, "provision timeout") },
-          ...input.signal === void 0 ? {} : { signal: input.signal }
-        }
-      );
-      try {
-        throwIfAborted(input.signal);
-        assertExactSandboxMetadata(sandbox, metadata);
-        await assertExactSandboxEgress(sandbox, egressPolicy);
-      } catch (error) {
-        await discardInvalidSandbox(sandbox, error);
-      }
-      return sandboxAsExactProcessEnvironment(sandbox, name);
-    },
-    async get(id) {
-      const sandbox = await client.get(id);
-      if (!sandbox || !isExactSandbox(sandbox, name)) return null;
-      await assertExactSandboxEgress(sandbox, egressFromMetadata(sandbox.metadata));
-      return sandboxAsExactProcessEnvironment(sandbox, name);
-    },
-    async list(query) {
-      assertNoProviderOptions(query?.providerOptions);
-      const sandboxes = await client.list();
-      return Promise.all(
-        sandboxes.filter((sandbox) => isExactSandbox(sandbox, name)).filter((sandbox) => metadataMatches(sandbox.metadata, query?.metadata)).map(async (sandbox) => {
-          await assertExactSandboxEgress(sandbox, egressFromMetadata(sandbox.metadata));
-          return sandboxAsExactProcessEnvironment(sandbox, name);
-        })
-      );
-    }
-  };
-  return {
-    name,
-    exactProcess,
-    capabilities: exactProcessOnlyCapabilities,
-    async create() {
-      throw new Error(`agent environment provider "${name}" supports exactProcess.create() only`);
-    }
-  };
-}
-function sandboxAsExactProcessEnvironment(sandbox, provider) {
-  return {
-    id: requiredText(sandbox.id, "Sandbox id"),
-    provider,
-    ...sandbox.metadata ? { metadata: sandbox.metadata } : {},
-    process: {
-      async list() {
-        return (await sandbox.process.list()).map((status) => exactProcessStatus(status));
-      },
-      async get(pid) {
-        const process = await sandbox.process.get(pid);
-        return process ? sandboxProcessAsExactProcess(process) : null;
-      },
-      async spawn(input, options) {
-        const process = await afterAbortCheck(
-          options?.signal,
-          () => sandbox.process.spawnExact(input.executable, [...input.args], {
-            cwd: input.cwd,
-            env: { ...input.env },
-            inheritEnv: false,
-            ...input.stdin === void 0 ? {} : { stdin: input.stdin },
-            timeoutMs: input.timeoutMs
-          })
-        );
-        return sandboxProcessAsExactProcess(process);
-      }
-    },
-    async writeFile(path, bytes, options) {
-      if (sandbox.fs.supportsWriteMode !== true) {
-        throw new Error("Tangle Sandbox does not declare exact file-mode support");
-      }
-      await afterAbortCheck(
-        options.signal,
-        () => sandbox.fs.write(path, Buffer.from(bytes).toString("base64"), {
-          encoding: "base64",
-          mode: fileMode(options.mode)
-        })
-      );
-    },
-    async readFile(path, options) {
-      const maxBytes = nonnegativeInteger(options.maxBytes, "exact-process file read maximum");
-      const initialSize = nonnegativeInteger(
-        (await afterAbortCheck(options.signal, () => sandbox.fs.stat(path))).size,
-        `Tangle Sandbox file size for "${path}"`
-      );
-      if (initialSize > maxBytes) {
-        throw new Error(
-          `Tangle Sandbox file "${path}" exceeds the ${maxBytes}-byte exact read maximum`
-        );
-      }
-      const result = await afterAbortCheck(
-        options.signal,
-        () => sandbox.fs.readBatch([path], { encoding: "base64" })
-      );
-      const failure = result.errors.find((entry) => entry.path === path);
-      if (failure) {
-        throw new Error(`Tangle Sandbox failed to read "${path}": ${failure.error}`);
-      }
-      const files = result.files.filter((entry) => entry.path === path);
-      if (files.length !== 1) {
-        throw new Error(`Tangle Sandbox returned ${files.length} files for exact read "${path}"`);
-      }
-      const file = files[0];
-      if (file.encoding !== "base64") {
-        throw new Error(`Tangle Sandbox returned non-binary content for exact read "${path}"`);
-      }
-      const size = nonnegativeInteger(file.size, `Tangle Sandbox file size for "${path}"`);
-      if (size !== initialSize) {
-        throw new Error(`Tangle Sandbox file "${path}" changed during exact read`);
-      }
-      if (size > maxBytes) {
-        throw new Error(
-          `Tangle Sandbox file "${path}" exceeds the ${maxBytes}-byte exact read maximum`
-        );
-      }
-      const bytes = Buffer.from(file.content, "base64");
-      if (bytes.byteLength !== size || bytes.toString("base64") !== file.content) {
-        throw new Error(
-          `Tangle Sandbox returned an invalid binary payload for exact read "${path}"`
-        );
-      }
-      return Uint8Array.from(bytes);
-    },
-    async destroy() {
-      await sandbox.delete();
-    }
-  };
-}
-function sandboxProcessAsExactProcess(process) {
-  const pid = positiveInteger(process.pid, "Tangle Sandbox process pid");
-  return {
-    pid,
-    async status() {
-      return exactProcessStatus(await process.status(), pid);
-    },
-    async wait() {
-      const waitExitCode = await process.wait();
-      if (!Number.isSafeInteger(waitExitCode)) {
-        throw new Error("Tangle Sandbox process wait returned an invalid exit code");
-      }
-      const status = exactProcessStatus(await process.status(), pid);
-      if (status.running || !status.termination) {
-        throw new Error("Tangle Sandbox process wait returned before terminal status");
-      }
-      if (status.termination.kind === "exit" && status.termination.exitCode !== waitExitCode) {
-        throw new Error("Tangle Sandbox process wait and status disagree on exit code");
-      }
-      return status.termination;
-    },
-    async kill() {
-      await process.kill("SIGKILL", { tree: true });
-    },
-    async *stdout() {
-      yield* process.stdout();
-    },
-    async *stderr() {
-      yield* process.stderr();
-    }
-  };
-}
-function exactProcessStatus(status, expectedPid) {
-  const pid = positiveInteger(status.pid, "Tangle Sandbox process pid");
-  if (expectedPid !== void 0 && pid !== expectedPid) {
-    throw new Error("Tangle Sandbox process status changed process identity");
-  }
-  if (typeof status.running !== "boolean") {
-    throw new Error("Tangle Sandbox process status is missing running state");
-  }
-  if (!Number.isSafeInteger(status.exitCode)) {
-    throw new Error("Tangle Sandbox process status is missing an integer exit code");
-  }
-  const exitSignal = optionalText(status.exitSignal, "Tangle Sandbox process exit signal");
-  if (status.running) {
-    if (status.exitCode !== -1) {
-      throw new Error("Tangle Sandbox running process must report exit code -1");
-    }
-    if (exitSignal) {
-      throw new Error("Tangle Sandbox running process must not report an exit signal");
-    }
-    return {
-      pid,
-      running: true,
-      exitCode: -1
-    };
-  }
-  const termination = exitSignal ? { kind: "signal", signal: exitSignal } : status.exitCode >= 0 ? { kind: "exit", exitCode: status.exitCode } : void 0;
-  if (!termination) {
-    throw new Error("Tangle Sandbox stopped process has no terminal reason");
-  }
-  return {
-    pid,
-    running: false,
-    exitCode: status.exitCode,
-    ...exitSignal ? { exitSignal } : {},
-    termination
-  };
-}
-function exactMetadata(metadata, provider, egressPolicy) {
-  for (const marker of [exactProcessProviderMarker, exactProcessEgressMarker]) {
-    if (Object.hasOwn(metadata, marker)) {
-      throw new Error(`exact-process metadata must not set "${marker}"`);
-    }
-  }
-  return {
-    ...metadata,
-    [exactProcessProviderMarker]: provider,
-    [exactProcessEgressMarker]: serializeEgressPolicy(egressPolicy)
-  };
-}
-function isExactSandbox(sandbox, provider) {
-  return sandbox.metadata?.[exactProcessProviderMarker] === provider;
-}
-function metadataMatches(metadata, expected) {
-  return expected === void 0 || Object.entries(expected).every(([key, value]) => isDeepStrictEqual(metadata?.[key], value));
-}
-function assertExactSandboxMetadata(sandbox, expected) {
-  if (!metadataMatches(sandbox.metadata, expected)) {
-    throw new Error("Tangle Sandbox did not persist exact-process metadata");
-  }
-}
-function egressFromMetadata(metadata) {
-  const encoded = metadata?.[exactProcessEgressMarker];
-  if (typeof encoded !== "string") {
-    throw new Error("Tangle Sandbox exact-process environment is missing egress metadata");
-  }
-  try {
-    const parsed = JSON.parse(encoded);
-    if (!parsed || typeof parsed !== "object") throw new Error("expected egress object");
-    const policy = parsed;
-    if (policy.mode === "blocked" && policy.allowDomains === void 0) return { mode: "blocked" };
-    if (policy.mode === "strict" && policy.includeImplicitDomains === false && Array.isArray(policy.allowDomains) && policy.allowDomains.every((domain) => typeof domain === "string")) {
-      const allowDomains = sortedDomains(policy.allowDomains);
-      if (new Set(allowDomains).size === allowDomains.length) {
-        return { mode: "strict", allowDomains, includeImplicitDomains: false };
-      }
-    }
-  } catch {
-    throw new Error("Tangle Sandbox exact-process environment has invalid egress metadata");
-  }
-  throw new Error("Tangle Sandbox exact-process environment has invalid egress metadata");
-}
-async function assertExactSandboxEgress(sandbox, expected) {
-  const actual = (await sandbox.egress.get()).policy;
-  if (actual.mode !== expected.mode) {
-    throw new Error(
-      `Tangle Sandbox egress mismatch: expected ${expected.mode}, received ${actual.mode}`
-    );
-  }
-  if (expected.mode === "blocked") {
-    const allowDomains = actual.allowDomains;
-    if (actual.mode === "blocked" && (allowDomains === void 0 || Array.isArray(allowDomains) && allowDomains.length === 0)) {
-      return;
-    }
-    throw new Error("Tangle Sandbox blocked egress retained an allowlist");
-  }
-  if (actual.mode !== "strict") {
-    throw new Error("Tangle Sandbox did not return strict egress policy");
-  }
-  const expectedDomains = sortedDomains(expected.allowDomains);
-  const actualDomains = sortedDomains(actual.allowDomains ?? []);
-  if (!isDeepStrictEqual(actualDomains, expectedDomains)) {
-    throw new Error("Tangle Sandbox strict egress differs from the exact allowlist");
-  }
-  if (actual.includeImplicitDomains !== false) {
-    throw new Error("Tangle Sandbox strict egress retained implicit domains");
-  }
-}
-function sandboxEgressPolicy(input) {
-  if (input.mode === "blocked") return { mode: "blocked" };
-  const allowDomains = input.allowDomains.map(
-    (domain) => requiredText(domain, "strict egress domain")
-  );
-  if (new Set(allowDomains).size !== allowDomains.length) {
-    throw new Error("strict egress domains must not contain duplicates");
-  }
-  return { mode: "strict", allowDomains, includeImplicitDomains: false };
-}
-function serializeEgressPolicy(policy) {
-  return JSON.stringify(
-    policy.mode === "blocked" ? { mode: "blocked" } : {
-      mode: "strict",
-      allowDomains: sortedDomains(policy.allowDomains),
-      includeImplicitDomains: false
-    }
-  );
-}
-function sandboxResources(input) {
-  const cpuCores = positiveNumber(input.resources.cpu, "exact-process cpu");
-  const memoryMB = positiveInteger(input.resources.memoryMb, "exact-process memory");
-  const diskMb = positiveInteger(input.resources.diskMb, "exact-process disk");
-  if (diskMb % 1024 !== 0) {
-    throw new Error("Tangle Sandbox exact-process disk must be a whole GiB");
-  }
-  return { cpuCores, memoryMB, diskGB: diskMb / 1024 };
-}
-function sandboxLifetimeSeconds(maxLifetimeMs) {
-  const milliseconds = positiveInteger(maxLifetimeMs, "exact-process maximum lifetime");
-  if (milliseconds % 1e3 !== 0) {
-    throw new Error(
-      "Tangle Sandbox exact-process maximum lifetime must be a whole number of seconds"
-    );
-  }
-  return milliseconds / 1e3;
-}
-function fileMode(value) {
-  const mode = nonnegativeInteger(value, "exact-process file mode");
-  if (mode > 4095) throw new Error("exact-process file mode exceeds POSIX mode bits");
-  return mode;
-}
-function assertNoProviderOptions(providerOptions) {
-  if (providerOptions && Object.keys(providerOptions).length > 0) {
-    throw new Error("Tangle Sandbox exact-process provider does not accept providerOptions");
-  }
-}
-function exactProcessOnlyCapabilities() {
-  return {
-    profile: {
-      namedProfiles: false,
-      systemPrompt: false,
-      instructions: false,
-      tools: false,
-      permissions: false,
-      mcp: false,
-      subagents: false,
-      resources: {
-        files: false,
-        instructions: false,
-        tools: false,
-        skills: false,
-        agents: false,
-        commands: false
-      },
-      hooks: false,
-      modes: false,
-      runtimeUpdate: false,
-      validation: false
-    },
-    streaming: { live: false, replay: false, detach: false, turnIdempotency: false },
-    sessions: { continue: false, list: false, messages: false },
-    workspace: {
-      read: false,
-      write: false,
-      exec: false,
-      git: false,
-      upload: false,
-      download: false
-    },
-    branching: { checkpoint: false, fork: false },
-    placement: false,
-    usage: false,
-    confidential: false,
-    exactProcess: { egress: ["blocked", "strict"] }
-  };
-}
-async function discardInvalidSandbox(sandbox, cause) {
-  try {
-    await sandbox.delete();
-  } catch (destroyError) {
-    throw new AggregateError(
-      [cause, destroyError],
-      "Tangle Sandbox exact-process creation failed and cleanup failed"
-    );
-  }
-  throw cause;
-}
-function sortedDomains(domains) {
-  return [...domains].sort((left, right) => left.localeCompare(right));
-}
-function requiredText(value, label) {
-  if (typeof value !== "string" || !value.trim())
-    throw new Error(`${label} must be a non-empty string`);
-  return value;
-}
-function optionalText(value, label) {
-  if (value === void 0) return void 0;
-  return requiredText(value, label);
-}
-function positiveNumber(value, label) {
-  if (!Number.isFinite(value) || value <= 0) throw new Error(`${label} must be positive`);
-  return value;
-}
-function positiveInteger(value, label) {
-  if (!Number.isSafeInteger(value) || value < 1)
-    throw new Error(`${label} must be a positive integer`);
-  return value;
-}
-function nonnegativeInteger(value, label) {
-  if (!Number.isSafeInteger(value) || value < 0)
-    throw new Error(`${label} must be a non-negative integer`);
-  return value;
-}
-function throwIfAborted(signal) {
-  signal?.throwIfAborted();
-}
-async function afterAbortCheck(signal, operation) {
-  throwIfAborted(signal);
-  const result = await operation();
-  throwIfAborted(signal);
-  return result;
-}
-
-// src/runtime/environment-provider.ts
-var ValidationError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ValidationError";
-  }
-};
-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 promptResultCompat(
-        {
-          response: resultFromEvents(events, text).content,
-          success: true,
-          durationMs: 0,
-          ...usage ? { usage } : {}
-        },
-        "success"
-      );
-    },
-    ...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));
-      }
-    } : {},
-    async checkpoint(options) {
-      const result = await box.snapshot({
-        ...options?.name ? { tags: [options.name] } : {}
-      });
-      return {
-        id: result.snapshotId,
-        provider: providerName,
-        ...options?.metadata ? { metadata: options.metadata } : {}
-      };
-    },
-    async fork(checkpoint, options) {
-      const forked = await client.create({
-        fromSnapshot: checkpoint.id,
-        fromSandboxId: String(box.id),
-        ...options?.name ? { name: options.name } : {},
-        ...options?.metadata ? { metadata: options.metadata } : {}
-      });
-      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 promptResultCompat(input, status) {
-  return { ...input, status };
-}
-function promptResultFromAgentTurnResult(result) {
-  return promptResultCompat(
-    {
-      response: result.text,
-      success: result.success,
-      durationMs: 0,
-      ...result.error ? { error: result.error } : {},
-      ...result.usage ? { usage: result.usage } : {}
-    },
-    result.success ? "success" : "failed"
-  );
-}
-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 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";
-}
-
-export {
-  createTangleSandboxExactProcessProvider,
-  createAgentEnvironmentProviderRegistry,
-  resolveAgentEnvironmentProvider,
-  providerAsSandboxClient,
-  sandboxClientAsProvider,
-  providerAsExecutor
-};
-//# sourceMappingURL=chunk-KRBFHMV6.js.map