@openai/agents-realtime 0.8.4 → 0.9.0

package/dist/bundle/agent-C8M7S25V.mjs

@@ -0,0 +1,637 @@
+var U = Object.defineProperty;
+var j = (t, s, e) => s in t ? U(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
+var o = (t, s, e) => j(t, typeof s != "symbol" ? s + "" : s, e);
+import { Capability as _, requireBoundSession as N, UserError as b, tool as m, object as y, string as p, applyPatchTool as K, withSandboxSpan as w, isRecord as L, encodeUint8ArrayToBase64 as H, ApplyPatchOperation as z, number as d, boolean as P, prompt as T, Agent as X, SANDBOX_AGENT_BRAND as q, cloneManifest as G, Manifest as Y, normalizeUser as J } from "./index-B8JqVS66.mjs";
+function V(t) {
+  return t ? !(typeof t == "object" && t && "constructor" in t && typeof t.constructor == "function" ? t.constructor.name : "").includes("ChatCompletions") : !0;
+}
+function Q(t) {
+  return $(t);
+}
+function $(t) {
+  return t ? !(typeof t == "object" && t && "constructor" in t && typeof t.constructor == "function" ? t.constructor.name : "").includes("ChatCompletions") : !1;
+}
+class Z {
+}
+class ee extends Z {
+  constructor(e = 0.9, i = 24e4) {
+    super();
+    o(this, "thresholdRatio");
+    o(this, "fallbackThreshold");
+    this.thresholdRatio = e, this.fallbackThreshold = i;
+  }
+  compactThreshold(e) {
+    if (!e)
+      return this.fallbackThreshold;
+    const i = u.forModel(e);
+    return i ? Math.floor(i.contextWindow * this.thresholdRatio) : this.fallbackThreshold;
+  }
+}
+class u {
+  constructor(s) {
+    o(this, "contextWindow");
+    this.contextWindow = s;
+  }
+  static forModel(s) {
+    for (const e of ie(s)) {
+      if (ne.has(e))
+        return new u(1047576);
+      if (re.has(e))
+        return new u(4e5);
+      if (oe.has(e))
+        return new u(2e5);
+      if (ae.has(e))
+        return new u(128e3);
+    }
+  }
+}
+class te extends _ {
+  constructor(e = new ee()) {
+    super();
+    o(this, "type", "compaction");
+    o(this, "policy");
+    this.policy = e;
+  }
+  samplingParams(e) {
+    if (e.modelInstance && !V(e.modelInstance))
+      return {};
+    const i = typeof e.model == "string" ? e.model : void 0;
+    return {
+      context_management: [
+        {
+          type: "compaction",
+          compact_threshold: this.policy.compactThreshold(i)
+        }
+      ]
+    };
+  }
+  processContext(e) {
+    let i = -1;
+    for (let n = 0; n < e.length; n += 1)
+      e[n].type === "compaction" && (i = n);
+    return i === -1 ? e : e.slice(i);
+  }
+}
+function se(t = {}) {
+  return new te(t.policy);
+}
+function ie(t) {
+  const s = t.trim();
+  if (!s)
+    return [];
+  const i = (s.includes("/") ? s.slice(s.lastIndexOf("/") + 1) : s).toLowerCase(), n = i.replace(/-\d{4}-\d{2}-\d{2}$/u, "");
+  return [.../* @__PURE__ */ new Set([i, n])];
+}
+const ne = /* @__PURE__ */ new Set([
+  "gpt-5.4",
+  "gpt-5.4-2026-03-05",
+  "gpt-5.4-pro",
+  "gpt-5.4-pro-2026-03-05",
+  "gpt-4.1",
+  "gpt-4.1-2025-04-14",
+  "gpt-4.1-mini",
+  "gpt-4.1-mini-2025-04-14",
+  "gpt-4.1-nano",
+  "gpt-4.1-nano-2025-04-14"
+]), re = /* @__PURE__ */ new Set([
+  "gpt-5",
+  "gpt-5-codex",
+  "gpt-5-mini",
+  "gpt-5-nano",
+  "gpt-5-pro",
+  "gpt-5.1",
+  "gpt-5.1-codex",
+  "gpt-5.1-codex-max",
+  "gpt-5.1-codex-mini",
+  "gpt-5.2",
+  "gpt-5.2-codex",
+  "gpt-5.2-codex-cyber",
+  "gpt-5.2-pro",
+  "gpt-5.3-codex",
+  "gpt-5.3-codex-spark",
+  "gpt-5.4-mini",
+  "gpt-5.4-nano"
+]), oe = /* @__PURE__ */ new Set([
+  "codex-mini-latest",
+  "o1",
+  "o1-2024-12-17",
+  "o1-pro",
+  "o3",
+  "o3-2025-04-16",
+  "o3-mini",
+  "o3-pro",
+  "o3-deep-research",
+  "o4-mini",
+  "o4-mini-2025-04-16",
+  "o4-mini-deep-research"
+]), ae = /* @__PURE__ */ new Set([
+  "gpt-4o",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-mini",
+  "gpt-4o-mini-2024-07-18",
+  "gpt-5-chat-latest",
+  "gpt-5.1-chat-latest",
+  "gpt-5.2-chat-latest",
+  "gpt-5.3-chat-latest"
+]), le = {
+  type: "object",
+  properties: {
+    patch: {
+      type: "string",
+      description: "A freeform apply_patch payload wrapped in *** Begin Patch and *** End Patch."
+    },
+    operation: {
+      type: "object",
+      description: "A single structured apply_patch operation."
+    },
+    operations: {
+      type: "array",
+      items: { type: "object" },
+      description: "Structured apply_patch operations to apply in order."
+    },
+    command: {
+      type: "array",
+      description: 'Optional ["apply_patch", patch] command tuple form.'
+    },
+    type: {
+      type: "string",
+      enum: ["create_file", "update_file", "delete_file"],
+      description: "The patch operation to apply."
+    },
+    path: {
+      type: "string",
+      description: "The sandbox file path to patch."
+    },
+    diff: {
+      type: "string",
+      description: "The V4A patch diff for create_file and update_file operations."
+    },
+    moveTo: {
+      type: "string",
+      description: "Optional destination path for update_file move operations."
+    }
+  },
+  required: [],
+  additionalProperties: !0
+}, k = "*** Begin Patch", D = "*** End Patch", x = "*** Add File: ", I = "*** Delete File: ", v = "*** Update File: ", M = "*** Move to: ";
+function A(t) {
+  if (t instanceof Error)
+    return t.message || t.toString();
+  try {
+    return JSON.stringify(t);
+  } catch {
+    return String(t);
+  }
+}
+function ce(t) {
+  if (typeof t == "string")
+    return t;
+  const s = t.image;
+  if (typeof s == "string")
+    return s;
+  if (!L(s))
+    return "No image data was returned by the sandbox session.";
+  const e = s;
+  return typeof e.url == "string" ? e.url : typeof e.fileId == "string" ? `OpenAI file reference: ${e.fileId}` : typeof e.data == "string" ? `data:${typeof e.mediaType == "string" ? e.mediaType : "application/octet-stream"};base64,${e.data}` : e.data instanceof Uint8Array ? `data:${typeof e.mediaType == "string" ? e.mediaType : "application/octet-stream"};base64,${H(e.data)}` : "No image data was returned by the sandbox session.";
+}
+function pe(t, s) {
+  const e = A(s);
+  if (/not found/iu.test(e))
+    return `image path \`${t}\` was not found`;
+  if (/not a file/iu.test(e))
+    return `image path \`${t}\` is not a file`;
+  if (/exceeds the 10 MB limit|exceeded the allowed size/iu.test(e))
+    return `image path \`${t}\` exceeded the allowed size of 10MB; resize or compress the image and try again`;
+  if (/unsupported image format|not a supported image/iu.test(e))
+    return `image path \`${t}\` is not a supported image file`;
+  const i = s instanceof Error ? s.name : typeof s;
+  return `unable to read image at \`${t}\`: ${i}`;
+}
+function ue(t) {
+  const s = t.trimStart();
+  if (s.startsWith(k))
+    return f(s);
+  let e;
+  try {
+    e = JSON.parse(t);
+  } catch (i) {
+    return {
+      ok: !1,
+      error: `Invalid apply_patch JSON: ${A(i)}`
+    };
+  }
+  return de(e);
+}
+function de(t) {
+  if (typeof t == "string")
+    return f(t);
+  if (Array.isArray(t))
+    return h(t);
+  if (!L(t))
+    return {
+      ok: !1,
+      error: "apply_patch input must be an object or array."
+    };
+  if (typeof t.patch == "string")
+    return f(t.patch);
+  if (Array.isArray(t.command)) {
+    const [s, e] = t.command;
+    if (s === "apply_patch" && typeof e == "string")
+      return f(e);
+  }
+  return Array.isArray(t.operations) ? h(t.operations) : t.operation !== void 0 ? h([t.operation]) : h([t]);
+}
+function h(t) {
+  const s = [];
+  for (const e of t) {
+    const i = z.safeParse(e);
+    if (!i.success)
+      return {
+        ok: !1,
+        error: `Invalid apply_patch operation: ${i.error.message}`
+      };
+    s.push(i.data);
+  }
+  return s.length === 0 ? { ok: !1, error: "apply_patch input must include an operation." } : { ok: !0, operations: s };
+}
+function f(t) {
+  const s = t.split(/\r?\n/);
+  if (s.at(-1) === "" && s.pop(), s[0] !== k)
+    return {
+      ok: !1,
+      error: `apply_patch input must start with "${k}".`
+    };
+  if (s.length < 2 || s.at(-1) !== D)
+    return {
+      ok: !1,
+      error: `apply_patch input must end with "${D}".`
+    };
+  const e = [];
+  let i = 1;
+  for (; i < s.length - 1; ) {
+    const n = s[i];
+    let r;
+    if (n.startsWith(x))
+      r = he(s, i);
+    else if (n.startsWith(I))
+      r = fe(s, i);
+    else if (n.startsWith(v))
+      r = me(s, i);
+    else
+      return {
+        ok: !1,
+        error: `Invalid apply_patch file operation header: ${n}`
+      };
+    if ("error" in r)
+      return { ok: !1, error: r.error };
+    e.push(r.operation), i = r.nextIndex;
+  }
+  return e.length === 0 ? {
+    ok: !1,
+    error: "apply_patch input must include at least one file operation."
+  } : { ok: !0, operations: e };
+}
+function he(t, s) {
+  const e = g(t[s], x);
+  if (!e)
+    return { error: `Missing path in apply_patch header: ${t[s]}` };
+  s += 1;
+  const i = [];
+  for (; s < t.length - 1 && !S(t[s]); ) {
+    const n = t[s];
+    if (!n.startsWith("+"))
+      return { error: `Invalid Add File line: ${n}` };
+    i.push(n), s += 1;
+  }
+  return i.length === 0 ? {
+    error: `Add File patch for ${e} must include at least one + line.`
+  } : {
+    operation: {
+      type: "create_file",
+      path: e,
+      diff: F(i)
+    },
+    nextIndex: s
+  };
+}
+function fe(t, s) {
+  const e = g(t[s], I);
+  return e ? (s += 1, s < t.length - 1 && !S(t[s]) ? { error: `Delete File patch for ${e} must not include a diff.` } : {
+    operation: {
+      type: "delete_file",
+      path: e
+    },
+    nextIndex: s
+  }) : { error: `Missing path in apply_patch header: ${t[s]}` };
+}
+function me(t, s) {
+  const e = g(t[s], v);
+  if (!e)
+    return { error: `Missing path in apply_patch header: ${t[s]}` };
+  s += 1;
+  let i;
+  if (s < t.length - 1 && t[s].startsWith(M)) {
+    const r = g(t[s], M);
+    if (!r)
+      return { error: `Missing path in apply_patch header: ${t[s]}` };
+    i = r, s += 1;
+  }
+  const n = [];
+  for (; s < t.length - 1 && !S(t[s]); )
+    n.push(t[s]), s += 1;
+  return n.length === 0 && !i ? { error: `Update File patch for ${e} must include a hunk.` } : {
+    operation: {
+      type: "update_file",
+      path: e,
+      diff: n.length > 0 ? F(n) : "",
+      ...i ? { moveTo: i } : {}
+    },
+    nextIndex: s
+  };
+}
+function g(t, s) {
+  const e = t.slice(s.length).trim();
+  return e || null;
+}
+function S(t) {
+  return t.startsWith(x) || t.startsWith(I) || t.startsWith(v);
+}
+function F(t) {
+  return `${t.join(`
+`)}
+`;
+}
+async function ye(t, s, e) {
+  let i;
+  try {
+    switch (s.type) {
+      case "create_file":
+        i = await t.createFile(s, { runContext: e });
+        break;
+      case "update_file":
+        i = await t.updateFile(s, { runContext: e });
+        break;
+      case "delete_file":
+        i = await t.deleteFile(s, { runContext: e });
+        break;
+      default:
+        return "Unsupported apply_patch operation.";
+    }
+  } catch (n) {
+    return `Failed to apply patch: ${A(n)}`;
+  }
+  return (i == null ? void 0 : i.status) === "failed" ? i.output ? `Patch failed: ${i.output}` : "Patch failed." : (i == null ? void 0 : i.output) ?? "Patch applied.";
+}
+async function ge(t, s, e) {
+  const i = [];
+  for (const n of s) {
+    const r = await ye(t, n, e);
+    r && i.push(r);
+  }
+  return i.join(`
+`) || "Patch applied.";
+}
+function be(t) {
+  return {
+    type: "function",
+    name: "apply_patch",
+    description: "Applies a create, update, move, or delete file patch in the sandbox workspace. Accepts a freeform patch string or structured apply_patch operations.",
+    parameters: le,
+    strict: !1,
+    deferLoading: !1,
+    needsApproval: async () => !1,
+    isEnabled: async () => !0,
+    invoke: async (e, i) => {
+      const n = ue(i);
+      return n.ok ? await ge(t, n.operations, e) : n.error;
+    }
+  };
+}
+class we extends _ {
+  constructor(e = {}) {
+    super();
+    o(this, "type", "filesystem");
+    o(this, "configureTools");
+    this.configureTools = e.configureTools;
+  }
+  tools() {
+    var l;
+    const e = N(this.type, this._session), i = (l = e.createEditor) == null ? void 0 : l.call(e, this._runAs);
+    if (!i)
+      throw new b("Filesystem sandbox sessions must provide createEditor().");
+    const n = [], r = async (a) => {
+      if (!e.viewImage)
+        throw new b("Filesystem sandbox sessions must provide viewImage().");
+      try {
+        return await w("sandbox.view_image", {
+          path: a,
+          run_as: this._runAs
+        }, async () => await e.viewImage({
+          path: a,
+          runAs: this._runAs
+        }));
+      } catch (c) {
+        return pe(a, c);
+      }
+    };
+    return $(this._modelInstance) ? n.push(m({
+      name: "view_image",
+      description: "Returns an image output from a local path in the sandbox workspace.",
+      parameters: y({
+        path: p().describe("Local filesystem path to an image file")
+      }),
+      execute: async ({ path: a }) => await r(a)
+    })) : n.push(m({
+      name: "view_image",
+      description: "Returns an image from a local path in the sandbox workspace as a data URL or reference string.",
+      parameters: y({
+        path: p().describe("Local filesystem path to an image file")
+      }),
+      execute: async ({ path: a }) => ce(await r(a))
+    })), Q(this._modelInstance) ? n.push(K({
+      name: "apply_patch",
+      editor: i
+    })) : n.push(be(i)), this.configureTools ? this.configureTools([...n]) : n;
+  }
+}
+function ke(t = {}) {
+  return new we(t);
+}
+const _e = 1e4, Te = 250, xe = [
+  "When using the shell:",
+  "- Use `exec_command` for shell execution.",
+  "- If available, use `write_stdin` to interact with or poll running sessions.",
+  "- To interrupt a long-running process via `write_stdin`, start it with `tty=true` and send Ctrl-C (`\\u0003`).",
+  "- Prefer `rg` and `rg --files` for text/file discovery when available.",
+  "- Avoid using Python scripts just to print large file chunks."
+].join(`
+`);
+class Ie extends _ {
+  constructor(e = {}) {
+    super();
+    o(this, "type", "shell");
+    o(this, "configureTools");
+    this.configureTools = e.configureTools;
+  }
+  tools() {
+    var n;
+    const e = N(this.type, this._session);
+    if (!e.execCommand)
+      throw new b("Shell sandbox sessions must provide execCommand().");
+    const i = [
+      m({
+        name: "exec_command",
+        description: "Runs a command in a PTY, returning output or a session ID for ongoing interaction.",
+        parameters: y({
+          cmd: p().min(1).describe("Shell command to execute."),
+          workdir: p().optional().describe("Optional working directory to run the command in; defaults to the turn cwd."),
+          shell: p().optional().describe("Shell binary to launch. Defaults to the user's default shell."),
+          login: P().default(!0).describe("Whether to run the shell with -l/-i semantics. Defaults to true."),
+          tty: P().default(!1).describe("Whether to allocate a TTY for the command. Defaults to false (plain pipes); set to true to open a PTY and access TTY process."),
+          yield_time_ms: d().int().min(0).default(_e).describe("How long to wait (in milliseconds) for output before yielding."),
+          max_output_tokens: d().int().min(1).optional().describe("Maximum number of tokens to return. Excess output will be truncated.")
+        }),
+        execute: async ({ cmd: r, workdir: l, shell: a, login: c, tty: E, yield_time_ms: B, max_output_tokens: R }) => await w("sandbox.exec", {
+          cmd: r,
+          workdir: l,
+          shell: a,
+          login: c,
+          tty: E,
+          run_as: this._runAs
+        }, async () => await e.execCommand({
+          cmd: r,
+          workdir: l,
+          shell: a,
+          login: c,
+          tty: E,
+          yieldTimeMs: B,
+          maxOutputTokens: R,
+          runAs: this._runAs
+        }))
+      })
+    ];
+    return (n = e.supportsPty) != null && n.call(e) && e.writeStdin && i.push(m({
+      name: "write_stdin",
+      description: "Writes characters to an existing unified exec session and returns recent output.",
+      parameters: y({
+        session_id: d().int().describe("Identifier of the running unified exec session."),
+        chars: p().default("").describe("Bytes to write to stdin (may be empty to poll)."),
+        yield_time_ms: d().int().min(0).default(Te).describe("How long to wait (in milliseconds) for output before yielding."),
+        max_output_tokens: d().int().min(1).optional().describe("Maximum number of tokens to return. Excess output will be truncated.")
+      }),
+      execute: async ({ session_id: r, chars: l, yield_time_ms: a, max_output_tokens: c }) => await w("sandbox.write_stdin", {
+        session_id: r
+      }, async () => await e.writeStdin({
+        sessionId: r,
+        chars: l,
+        yieldTimeMs: a,
+        maxOutputTokens: c
+      }))
+    })), this.configureTools ? this.configureTools([...i]) : i;
+  }
+  instructions() {
+    return xe;
+  }
+}
+function ve(t = {}) {
+  return new Ie(t);
+}
+T`
+A skill is a set of local instructions to follow that is stored in a \`SKILL.md\` file. Below is the list of skills that can be used. Each entry includes a name, description, and file path so you can open the source for full instructions when using a specific skill.
+`;
+T`
+### How to use skills
+- Discovery: The list above is the skills available in this session (name + description + file path). Skill bodies live on disk at the listed paths.
+- Trigger rules: If the user names a skill (with \`$SkillName\` or plain text) OR the task clearly matches a skill's description shown above, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.
+- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.
+- How to use a skill (progressive disclosure):
+  1) After deciding to use a skill, open its \`SKILL.md\`. Read only enough to follow the workflow.
+  2) If \`SKILL.md\` points to extra folders such as \`references/\`, load only the specific files needed for the request; don't bulk-load everything.
+  3) If \`scripts/\` exist, prefer running or patching them instead of retyping large code blocks.
+  4) If \`assets/\` or templates exist, reuse them instead of recreating from scratch.
+- Coordination and sequencing:
+  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.
+  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.
+- Context hygiene:
+  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.
+  - Avoid deep reference-chasing: prefer opening only files directly linked from \`SKILL.md\` unless you're blocked.
+  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.
+- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.
+`;
+T`
+### How to use skills
+- Discovery: The list above is the skill index available in this session (name + description + workspace path). In lazy mode, those paths are loaded on demand instead of being present up front.
+- Trigger rules: If the user names a skill (with \`$SkillName\` or plain text) OR the task clearly matches a skill's description shown above, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.
+- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.
+- How to use a skill (progressive disclosure):
+  1) After deciding to use a lazy skill, call \`load_skill\` for that skill first, then open its \`SKILL.md\`.
+  2) If \`SKILL.md\` points to extra folders such as \`references/\`, load only the specific files needed for the request; don't bulk-load everything.
+  3) If \`scripts/\` exist, prefer running or patching them instead of retyping large code blocks.
+  4) If \`assets/\` or templates exist, reuse them instead of recreating from scratch.
+- Coordination and sequencing:
+  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.
+  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.
+- Context hygiene:
+  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.
+  - Avoid deep reference-chasing: prefer opening only files directly linked from \`SKILL.md\` unless you're blocked.
+  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.
+- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.
+`;
+function Ae() {
+  return [ke(), ve(), se()];
+}
+const Se = {
+  default: Ae
+};
+var C, O;
+class W extends (O = X, C = q, O) {
+  constructor(e) {
+    super(e);
+    o(this, C, !0);
+    o(this, "defaultManifest");
+    o(this, "baseInstructions");
+    o(this, "capabilities");
+    o(this, "runAs");
+    o(this, "runtimeManifest");
+    if (e.baseInstructions !== void 0 && typeof e.baseInstructions != "string" && typeof e.baseInstructions != "function")
+      throw new TypeError("SandboxAgent baseInstructions must be a string or function.");
+    this.defaultManifest = e.defaultManifest ? G(e.defaultManifest) : void 0, this.baseInstructions = e.baseInstructions, this.capabilities = e.capabilities ?? Se.default(), this.runAs = Ee(e.runAs), this.runtimeManifest = this.defaultManifest ?? new Y();
+  }
+  clone(e) {
+    return new W({
+      name: e.name ?? this.name,
+      instructions: e.instructions ?? this.instructions,
+      prompt: e.prompt ?? this.prompt,
+      handoffDescription: e.handoffDescription ?? this.handoffDescription,
+      handoffs: e.handoffs ?? this.handoffs,
+      model: e.model ?? this.model,
+      modelSettings: e.modelSettings ?? this.modelSettings,
+      tools: e.tools ?? this.tools,
+      mcpServers: e.mcpServers ?? this.mcpServers,
+      inputGuardrails: e.inputGuardrails ?? this.inputGuardrails,
+      outputGuardrails: e.outputGuardrails ?? this.outputGuardrails,
+      outputType: e.outputType ?? this.outputType,
+      toolUseBehavior: e.toolUseBehavior ?? this.toolUseBehavior,
+      resetToolChoice: e.resetToolChoice ?? this.resetToolChoice,
+      defaultManifest: e.defaultManifest ?? this.defaultManifest,
+      baseInstructions: e.baseInstructions ?? this.baseInstructions,
+      capabilities: e.capabilities ?? this.capabilities,
+      runAs: e.runAs ?? this.runAs
+    });
+  }
+}
+function Ee(t) {
+  if (t !== void 0) {
+    if (typeof t == "string") {
+      const s = t.trim();
+      if (!s)
+        throw new TypeError("SandboxAgent runAs must be non-empty.");
+      return s;
+    }
+    return J(t);
+  }
+}
+export {
+  W as SandboxAgent
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"agent-C8M7S25V.mjs","sources":["../../../agents-core/dist/sandbox/capabilities/transport.mjs","../../../agents-core/dist/sandbox/capabilities/compaction.mjs","../../../agents-core/dist/sandbox/capabilities/filesystem.mjs","../../../agents-core/dist/sandbox/capabilities/shell.mjs","../../../agents-core/dist/sandbox/capabilities/skills.mjs","../../../agents-core/dist/sandbox/capabilities/index.mjs","../../../agents-core/dist/sandbox/agent.mjs"],"sourcesContent":["export function supportsResponsesCompactionTransport(modelInstance) {\n    if (!modelInstance) {\n        return true;\n    }\n    const constructorName = typeof modelInstance === 'object' &&\n        modelInstance &&\n        'constructor' in modelInstance &&\n        typeof modelInstance.constructor === 'function'\n        ? modelInstance.constructor.name\n        : '';\n    return !constructorName.includes('ChatCompletions');\n}\nexport function supportsApplyPatchTransport(modelInstance) {\n    return supportsStructuredToolOutputTransport(modelInstance);\n}\nexport function supportsStructuredToolOutputTransport(modelInstance) {\n    if (!modelInstance) {\n        return false;\n    }\n    const constructorName = typeof modelInstance === 'object' &&\n        modelInstance &&\n        'constructor' in modelInstance &&\n        typeof modelInstance.constructor === 'function'\n        ? modelInstance.constructor.name\n        : '';\n    return !constructorName.includes('ChatCompletions');\n}\n//# sourceMappingURL=transport.mjs.map","import { Capability } from \"./base.mjs\";\nimport { supportsResponsesCompactionTransport } from \"./transport.mjs\";\nexport class CompactionPolicy {\n}\nexport class StaticCompactionPolicy extends CompactionPolicy {\n    threshold;\n    constructor(threshold = 240000) {\n        super();\n        this.threshold = threshold;\n    }\n    compactThreshold() {\n        return this.threshold;\n    }\n}\nexport class DynamicCompactionPolicy extends CompactionPolicy {\n    thresholdRatio;\n    fallbackThreshold;\n    constructor(thresholdRatio = 0.9, fallbackThreshold = 240000) {\n        super();\n        this.thresholdRatio = thresholdRatio;\n        this.fallbackThreshold = fallbackThreshold;\n    }\n    compactThreshold(model) {\n        if (!model) {\n            return this.fallbackThreshold;\n        }\n        const modelInfo = CompactionModelInfo.forModel(model);\n        if (!modelInfo) {\n            return this.fallbackThreshold;\n        }\n        return Math.floor(modelInfo.contextWindow * this.thresholdRatio);\n    }\n}\nexport class CompactionModelInfo {\n    contextWindow;\n    constructor(contextWindow) {\n        this.contextWindow = contextWindow;\n    }\n    static forModel(model) {\n        for (const candidate of getSandboxCompactionModelCandidates(model)) {\n            if (SANDBOX_CONTEXT_WINDOWS_1M.has(candidate)) {\n                return new CompactionModelInfo(1047576);\n            }\n            if (SANDBOX_CONTEXT_WINDOWS_400K.has(candidate)) {\n                return new CompactionModelInfo(400000);\n            }\n            if (SANDBOX_CONTEXT_WINDOWS_200K.has(candidate)) {\n                return new CompactionModelInfo(200000);\n            }\n            if (SANDBOX_CONTEXT_WINDOWS_128K.has(candidate)) {\n                return new CompactionModelInfo(128000);\n            }\n        }\n        return undefined;\n    }\n}\nclass CompactionCapability extends Capability {\n    type = 'compaction';\n    policy;\n    constructor(policy = new DynamicCompactionPolicy()) {\n        super();\n        this.policy = policy;\n    }\n    samplingParams(samplingParams) {\n        if (samplingParams.modelInstance &&\n            !supportsResponsesCompactionTransport(samplingParams.modelInstance)) {\n            return {};\n        }\n        const model = typeof samplingParams.model === 'string'\n            ? samplingParams.model\n            : undefined;\n        return {\n            context_management: [\n                {\n                    type: 'compaction',\n                    compact_threshold: this.policy.compactThreshold(model),\n                },\n            ],\n        };\n    }\n    processContext(context) {\n        let lastCompactionIndex = -1;\n        for (let index = 0; index < context.length; index += 1) {\n            if (context[index].type === 'compaction') {\n                lastCompactionIndex = index;\n            }\n        }\n        if (lastCompactionIndex === -1) {\n            return context;\n        }\n        return context.slice(lastCompactionIndex);\n    }\n}\nexport function compaction(args = {}) {\n    return new CompactionCapability(args.policy);\n}\nfunction getSandboxCompactionModelCandidates(model) {\n    const trimmed = model.trim();\n    if (!trimmed) {\n        return [];\n    }\n    const withoutProviderPrefix = trimmed.includes('/')\n        ? trimmed.slice(trimmed.lastIndexOf('/') + 1)\n        : trimmed;\n    const normalized = withoutProviderPrefix.toLowerCase();\n    const withoutPinnedDate = normalized.replace(/-\\d{4}-\\d{2}-\\d{2}$/u, '');\n    return [...new Set([normalized, withoutPinnedDate])];\n}\nconst SANDBOX_CONTEXT_WINDOWS_1M = new Set([\n    'gpt-5.4',\n    'gpt-5.4-2026-03-05',\n    'gpt-5.4-pro',\n    'gpt-5.4-pro-2026-03-05',\n    'gpt-4.1',\n    'gpt-4.1-2025-04-14',\n    'gpt-4.1-mini',\n    'gpt-4.1-mini-2025-04-14',\n    'gpt-4.1-nano',\n    'gpt-4.1-nano-2025-04-14',\n]);\nconst SANDBOX_CONTEXT_WINDOWS_400K = new Set([\n    'gpt-5',\n    'gpt-5-codex',\n    'gpt-5-mini',\n    'gpt-5-nano',\n    'gpt-5-pro',\n    'gpt-5.1',\n    'gpt-5.1-codex',\n    'gpt-5.1-codex-max',\n    'gpt-5.1-codex-mini',\n    'gpt-5.2',\n    'gpt-5.2-codex',\n    'gpt-5.2-codex-cyber',\n    'gpt-5.2-pro',\n    'gpt-5.3-codex',\n    'gpt-5.3-codex-spark',\n    'gpt-5.4-mini',\n    'gpt-5.4-nano',\n]);\nconst SANDBOX_CONTEXT_WINDOWS_200K = new Set([\n    'codex-mini-latest',\n    'o1',\n    'o1-2024-12-17',\n    'o1-pro',\n    'o3',\n    'o3-2025-04-16',\n    'o3-mini',\n    'o3-pro',\n    'o3-deep-research',\n    'o4-mini',\n    'o4-mini-2025-04-16',\n    'o4-mini-deep-research',\n]);\nconst SANDBOX_CONTEXT_WINDOWS_128K = new Set([\n    'gpt-4o',\n    'gpt-4o-2024-08-06',\n    'gpt-4o-mini',\n    'gpt-4o-mini-2024-07-18',\n    'gpt-5-chat-latest',\n    'gpt-5.1-chat-latest',\n    'gpt-5.2-chat-latest',\n    'gpt-5.3-chat-latest',\n]);\n//# sourceMappingURL=compaction.mjs.map","import { z } from 'zod';\nimport { UserError } from \"../../errors.mjs\";\nimport { applyPatchTool, tool, } from \"../../tool.mjs\";\nimport { ApplyPatchOperation } from \"../../types/protocol.mjs\";\nimport { encodeUint8ArrayToBase64 } from \"../../utils/base64.mjs\";\nimport { withSandboxSpan } from \"../runtime/spans.mjs\";\nimport { isRecord } from \"../shared/typeGuards.mjs\";\nimport { Capability, requireBoundSession, } from \"./base.mjs\";\nimport { supportsApplyPatchTransport, supportsStructuredToolOutputTransport, } from \"./transport.mjs\";\nconst applyPatchFunctionParameters = {\n    type: 'object',\n    properties: {\n        patch: {\n            type: 'string',\n            description: 'A freeform apply_patch payload wrapped in *** Begin Patch and *** End Patch.',\n        },\n        operation: {\n            type: 'object',\n            description: 'A single structured apply_patch operation.',\n        },\n        operations: {\n            type: 'array',\n            items: { type: 'object' },\n            description: 'Structured apply_patch operations to apply in order.',\n        },\n        command: {\n            type: 'array',\n            description: 'Optional [\"apply_patch\", patch] command tuple form.',\n        },\n        type: {\n            type: 'string',\n            enum: ['create_file', 'update_file', 'delete_file'],\n            description: 'The patch operation to apply.',\n        },\n        path: {\n            type: 'string',\n            description: 'The sandbox file path to patch.',\n        },\n        diff: {\n            type: 'string',\n            description: 'The V4A patch diff for create_file and update_file operations.',\n        },\n        moveTo: {\n            type: 'string',\n            description: 'Optional destination path for update_file move operations.',\n        },\n    },\n    required: [],\n    additionalProperties: true,\n};\nconst BEGIN_PATCH = '*** Begin Patch';\nconst END_PATCH = '*** End Patch';\nconst ADD_FILE = '*** Add File: ';\nconst DELETE_FILE = '*** Delete File: ';\nconst UPDATE_FILE = '*** Update File: ';\nconst MOVE_TO = '*** Move to: ';\nfunction toErrorMessage(error) {\n    if (error instanceof Error) {\n        return error.message || error.toString();\n    }\n    try {\n        return JSON.stringify(error);\n    }\n    catch {\n        return String(error);\n    }\n}\nfunction renderImageForTextTransport(output) {\n    if (typeof output === 'string') {\n        return output;\n    }\n    const image = output.image;\n    if (typeof image === 'string') {\n        return image;\n    }\n    if (!isRecord(image)) {\n        return 'No image data was returned by the sandbox session.';\n    }\n    const imageRecord = image;\n    if (typeof imageRecord.url === 'string') {\n        return imageRecord.url;\n    }\n    if (typeof imageRecord.fileId === 'string') {\n        return `OpenAI file reference: ${imageRecord.fileId}`;\n    }\n    if (typeof imageRecord.data === 'string') {\n        const mediaType = typeof imageRecord.mediaType === 'string'\n            ? imageRecord.mediaType\n            : 'application/octet-stream';\n        return `data:${mediaType};base64,${imageRecord.data}`;\n    }\n    if (imageRecord.data instanceof Uint8Array) {\n        const mediaType = typeof imageRecord.mediaType === 'string'\n            ? imageRecord.mediaType\n            : 'application/octet-stream';\n        return `data:${mediaType};base64,${encodeUint8ArrayToBase64(imageRecord.data)}`;\n    }\n    return 'No image data was returned by the sandbox session.';\n}\nfunction renderViewImageError(path, error) {\n    const message = toErrorMessage(error);\n    if (/not found/iu.test(message)) {\n        return `image path \\`${path}\\` was not found`;\n    }\n    if (/not a file/iu.test(message)) {\n        return `image path \\`${path}\\` is not a file`;\n    }\n    if (/exceeds the 10 MB limit|exceeded the allowed size/iu.test(message)) {\n        return `image path \\`${path}\\` exceeded the allowed size of 10MB; resize or compress the image and try again`;\n    }\n    if (/unsupported image format|not a supported image/iu.test(message)) {\n        return `image path \\`${path}\\` is not a supported image file`;\n    }\n    const name = error instanceof Error ? error.name : typeof error;\n    return `unable to read image at \\`${path}\\`: ${name}`;\n}\nfunction parseApplyPatchInput(rawInput) {\n    const trimmedInput = rawInput.trimStart();\n    if (trimmedInput.startsWith(BEGIN_PATCH)) {\n        return parseFreeformPatch(trimmedInput);\n    }\n    let payload;\n    try {\n        payload = JSON.parse(rawInput);\n    }\n    catch (error) {\n        return {\n            ok: false,\n            error: `Invalid apply_patch JSON: ${toErrorMessage(error)}`,\n        };\n    }\n    return parseApplyPatchPayload(payload);\n}\nfunction parseApplyPatchPayload(payload) {\n    if (typeof payload === 'string') {\n        return parseFreeformPatch(payload);\n    }\n    if (Array.isArray(payload)) {\n        return parseStructuredOperations(payload);\n    }\n    if (!isRecord(payload)) {\n        return {\n            ok: false,\n            error: 'apply_patch input must be an object or array.',\n        };\n    }\n    if (typeof payload.patch === 'string') {\n        return parseFreeformPatch(payload.patch);\n    }\n    if (Array.isArray(payload.command)) {\n        const [commandName, patch] = payload.command;\n        if (commandName === 'apply_patch' && typeof patch === 'string') {\n            return parseFreeformPatch(patch);\n        }\n    }\n    if (Array.isArray(payload.operations)) {\n        return parseStructuredOperations(payload.operations);\n    }\n    if (payload.operation !== undefined) {\n        return parseStructuredOperations([payload.operation]);\n    }\n    return parseStructuredOperations([payload]);\n}\nfunction parseStructuredOperations(payloads) {\n    const operations = [];\n    for (const payload of payloads) {\n        const parsed = ApplyPatchOperation.safeParse(payload);\n        if (!parsed.success) {\n            return {\n                ok: false,\n                error: `Invalid apply_patch operation: ${parsed.error.message}`,\n            };\n        }\n        operations.push(parsed.data);\n    }\n    if (operations.length === 0) {\n        return { ok: false, error: 'apply_patch input must include an operation.' };\n    }\n    return { ok: true, operations };\n}\nfunction parseFreeformPatch(rawPatch) {\n    const lines = rawPatch.split(/\\r?\\n/);\n    if (lines.at(-1) === '') {\n        lines.pop();\n    }\n    if (lines[0] !== BEGIN_PATCH) {\n        return {\n            ok: false,\n            error: `apply_patch input must start with \"${BEGIN_PATCH}\".`,\n        };\n    }\n    if (lines.length < 2 || lines.at(-1) !== END_PATCH) {\n        return {\n            ok: false,\n            error: `apply_patch input must end with \"${END_PATCH}\".`,\n        };\n    }\n    const operations = [];\n    let index = 1;\n    while (index < lines.length - 1) {\n        const line = lines[index];\n        let parsed;\n        if (line.startsWith(ADD_FILE)) {\n            parsed = parseAddFilePatch(lines, index);\n        }\n        else if (line.startsWith(DELETE_FILE)) {\n            parsed = parseDeleteFilePatch(lines, index);\n        }\n        else if (line.startsWith(UPDATE_FILE)) {\n            parsed = parseUpdateFilePatch(lines, index);\n        }\n        else {\n            return {\n                ok: false,\n                error: `Invalid apply_patch file operation header: ${line}`,\n            };\n        }\n        if ('error' in parsed) {\n            return { ok: false, error: parsed.error };\n        }\n        operations.push(parsed.operation);\n        index = parsed.nextIndex;\n    }\n    if (operations.length === 0) {\n        return {\n            ok: false,\n            error: 'apply_patch input must include at least one file operation.',\n        };\n    }\n    return { ok: true, operations };\n}\nfunction parseAddFilePatch(lines, index) {\n    const path = parsePatchHeader(lines[index], ADD_FILE);\n    if (!path) {\n        return { error: `Missing path in apply_patch header: ${lines[index]}` };\n    }\n    index += 1;\n    const diffLines = [];\n    while (index < lines.length - 1 && !isFileOperationHeader(lines[index])) {\n        const line = lines[index];\n        if (!line.startsWith('+')) {\n            return { error: `Invalid Add File line: ${line}` };\n        }\n        diffLines.push(line);\n        index += 1;\n    }\n    if (diffLines.length === 0) {\n        return {\n            error: `Add File patch for ${path} must include at least one + line.`,\n        };\n    }\n    return {\n        operation: {\n            type: 'create_file',\n            path,\n            diff: joinDiff(diffLines),\n        },\n        nextIndex: index,\n    };\n}\nfunction parseDeleteFilePatch(lines, index) {\n    const path = parsePatchHeader(lines[index], DELETE_FILE);\n    if (!path) {\n        return { error: `Missing path in apply_patch header: ${lines[index]}` };\n    }\n    index += 1;\n    if (index < lines.length - 1 && !isFileOperationHeader(lines[index])) {\n        return { error: `Delete File patch for ${path} must not include a diff.` };\n    }\n    return {\n        operation: {\n            type: 'delete_file',\n            path,\n        },\n        nextIndex: index,\n    };\n}\nfunction parseUpdateFilePatch(lines, index) {\n    const path = parsePatchHeader(lines[index], UPDATE_FILE);\n    if (!path) {\n        return { error: `Missing path in apply_patch header: ${lines[index]}` };\n    }\n    index += 1;\n    let moveTo;\n    if (index < lines.length - 1 && lines[index].startsWith(MOVE_TO)) {\n        const parsedMoveTo = parsePatchHeader(lines[index], MOVE_TO);\n        if (!parsedMoveTo) {\n            return { error: `Missing path in apply_patch header: ${lines[index]}` };\n        }\n        moveTo = parsedMoveTo;\n        index += 1;\n    }\n    const diffLines = [];\n    while (index < lines.length - 1 && !isFileOperationHeader(lines[index])) {\n        diffLines.push(lines[index]);\n        index += 1;\n    }\n    if (diffLines.length === 0 && !moveTo) {\n        return { error: `Update File patch for ${path} must include a hunk.` };\n    }\n    return {\n        operation: {\n            type: 'update_file',\n            path,\n            diff: diffLines.length > 0 ? joinDiff(diffLines) : '',\n            ...(moveTo ? { moveTo } : {}),\n        },\n        nextIndex: index,\n    };\n}\nfunction parsePatchHeader(line, prefix) {\n    const path = line.slice(prefix.length).trim();\n    return path ? path : null;\n}\nfunction isFileOperationHeader(line) {\n    return (line.startsWith(ADD_FILE) ||\n        line.startsWith(DELETE_FILE) ||\n        line.startsWith(UPDATE_FILE));\n}\nfunction joinDiff(lines) {\n    return `${lines.join('\\n')}\\n`;\n}\nasync function applyPatchOperation(editor, operation, runContext) {\n    let result;\n    try {\n        switch (operation.type) {\n            case 'create_file':\n                result = await editor.createFile(operation, { runContext });\n                break;\n            case 'update_file':\n                result = await editor.updateFile(operation, { runContext });\n                break;\n            case 'delete_file':\n                result = await editor.deleteFile(operation, { runContext });\n                break;\n            default:\n                return 'Unsupported apply_patch operation.';\n        }\n    }\n    catch (error) {\n        return `Failed to apply patch: ${toErrorMessage(error)}`;\n    }\n    if (result?.status === 'failed') {\n        return result.output ? `Patch failed: ${result.output}` : 'Patch failed.';\n    }\n    return result?.output ?? 'Patch applied.';\n}\nasync function applyPatchOperations(editor, operations, runContext) {\n    const outputs = [];\n    for (const operation of operations) {\n        const output = await applyPatchOperation(editor, operation, runContext);\n        if (output) {\n            outputs.push(output);\n        }\n    }\n    return outputs.join('\\n') || 'Patch applied.';\n}\nfunction applyPatchFunctionTool(editor) {\n    const fallbackTool = {\n        type: 'function',\n        name: 'apply_patch',\n        description: 'Applies a create, update, move, or delete file patch in the sandbox workspace. Accepts a freeform patch string or structured apply_patch operations.',\n        parameters: applyPatchFunctionParameters,\n        strict: false,\n        deferLoading: false,\n        needsApproval: async () => false,\n        isEnabled: async () => true,\n        invoke: async (runContext, input) => {\n            const parsed = parseApplyPatchInput(input);\n            if (!parsed.ok) {\n                return parsed.error;\n            }\n            return await applyPatchOperations(editor, parsed.operations, runContext);\n        },\n    };\n    return fallbackTool;\n}\nclass FilesystemCapability extends Capability {\n    type = 'filesystem';\n    configureTools;\n    constructor(args = {}) {\n        super();\n        this.configureTools = args.configureTools;\n    }\n    tools() {\n        const session = requireBoundSession(this.type, this._session);\n        const editor = session.createEditor?.(this._runAs);\n        if (!editor) {\n            throw new UserError('Filesystem sandbox sessions must provide createEditor().');\n        }\n        const tools = [];\n        const viewImage = async (path) => {\n            if (!session.viewImage) {\n                throw new UserError('Filesystem sandbox sessions must provide viewImage().');\n            }\n            try {\n                return await withSandboxSpan('sandbox.view_image', {\n                    path,\n                    run_as: this._runAs,\n                }, async () => await session.viewImage({\n                    path,\n                    runAs: this._runAs,\n                }));\n            }\n            catch (error) {\n                return renderViewImageError(path, error);\n            }\n        };\n        if (supportsStructuredToolOutputTransport(this._modelInstance)) {\n            tools.push(tool({\n                name: 'view_image',\n                description: 'Returns an image output from a local path in the sandbox workspace.',\n                parameters: z.object({\n                    path: z.string().describe('Local filesystem path to an image file'),\n                }),\n                execute: async ({ path, }) => await viewImage(path),\n            }));\n        }\n        else {\n            tools.push(tool({\n                name: 'view_image',\n                description: 'Returns an image from a local path in the sandbox workspace as a data URL or reference string.',\n                parameters: z.object({\n                    path: z.string().describe('Local filesystem path to an image file'),\n                }),\n                execute: async ({ path }) => renderImageForTextTransport(await viewImage(path)),\n            }));\n        }\n        if (supportsApplyPatchTransport(this._modelInstance)) {\n            tools.push(applyPatchTool({\n                name: 'apply_patch',\n                editor,\n            }));\n        }\n        else {\n            tools.push(applyPatchFunctionTool(editor));\n        }\n        return this.configureTools ? this.configureTools([...tools]) : tools;\n    }\n}\nexport function filesystem(args = {}) {\n    return new FilesystemCapability(args);\n}\n//# sourceMappingURL=filesystem.mjs.map","import { z } from 'zod';\nimport { UserError } from \"../../errors.mjs\";\nimport { tool } from \"../../tool.mjs\";\nimport { withSandboxSpan } from \"../runtime/spans.mjs\";\nimport { Capability, requireBoundSession, } from \"./base.mjs\";\nconst DEFAULT_EXEC_YIELD_TIME_MS = 10_000;\nconst DEFAULT_WRITE_STDIN_YIELD_TIME_MS = 250;\nconst SHELL_INSTRUCTIONS = [\n    'When using the shell:',\n    '- Use `exec_command` for shell execution.',\n    '- If available, use `write_stdin` to interact with or poll running sessions.',\n    '- To interrupt a long-running process via `write_stdin`, start it with `tty=true` and send Ctrl-C (`\\\\u0003`).',\n    '- Prefer `rg` and `rg --files` for text/file discovery when available.',\n    '- Avoid using Python scripts just to print large file chunks.',\n].join('\\n');\nclass ShellCapability extends Capability {\n    type = 'shell';\n    configureTools;\n    constructor(args = {}) {\n        super();\n        this.configureTools = args.configureTools;\n    }\n    tools() {\n        const session = requireBoundSession(this.type, this._session);\n        if (!session.execCommand) {\n            throw new UserError('Shell sandbox sessions must provide execCommand().');\n        }\n        const tools = [\n            tool({\n                name: 'exec_command',\n                description: 'Runs a command in a PTY, returning output or a session ID for ongoing interaction.',\n                parameters: z.object({\n                    cmd: z.string().min(1).describe('Shell command to execute.'),\n                    workdir: z\n                        .string()\n                        .optional()\n                        .describe('Optional working directory to run the command in; defaults to the turn cwd.'),\n                    shell: z\n                        .string()\n                        .optional()\n                        .describe(\"Shell binary to launch. Defaults to the user's default shell.\"),\n                    login: z\n                        .boolean()\n                        .default(true)\n                        .describe('Whether to run the shell with -l/-i semantics. Defaults to true.'),\n                    tty: z\n                        .boolean()\n                        .default(false)\n                        .describe('Whether to allocate a TTY for the command. Defaults to false (plain pipes); set to true to open a PTY and access TTY process.'),\n                    yield_time_ms: z\n                        .number()\n                        .int()\n                        .min(0)\n                        .default(DEFAULT_EXEC_YIELD_TIME_MS)\n                        .describe('How long to wait (in milliseconds) for output before yielding.'),\n                    max_output_tokens: z\n                        .number()\n                        .int()\n                        .min(1)\n                        .optional()\n                        .describe('Maximum number of tokens to return. Excess output will be truncated.'),\n                }),\n                execute: async ({ cmd, workdir, shell, login, tty, yield_time_ms, max_output_tokens, }) => await withSandboxSpan('sandbox.exec', {\n                    cmd,\n                    workdir,\n                    shell,\n                    login,\n                    tty,\n                    run_as: this._runAs,\n                }, async () => await session.execCommand({\n                    cmd,\n                    workdir,\n                    shell,\n                    login,\n                    tty,\n                    yieldTimeMs: yield_time_ms,\n                    maxOutputTokens: max_output_tokens,\n                    runAs: this._runAs,\n                })),\n            }),\n        ];\n        if (session.supportsPty?.() && session.writeStdin) {\n            tools.push(tool({\n                name: 'write_stdin',\n                description: 'Writes characters to an existing unified exec session and returns recent output.',\n                parameters: z.object({\n                    session_id: z\n                        .number()\n                        .int()\n                        .describe('Identifier of the running unified exec session.'),\n                    chars: z\n                        .string()\n                        .default('')\n                        .describe('Bytes to write to stdin (may be empty to poll).'),\n                    yield_time_ms: z\n                        .number()\n                        .int()\n                        .min(0)\n                        .default(DEFAULT_WRITE_STDIN_YIELD_TIME_MS)\n                        .describe('How long to wait (in milliseconds) for output before yielding.'),\n                    max_output_tokens: z\n                        .number()\n                        .int()\n                        .min(1)\n                        .optional()\n                        .describe('Maximum number of tokens to return. Excess output will be truncated.'),\n                }),\n                execute: async ({ session_id, chars, yield_time_ms, max_output_tokens, }) => await withSandboxSpan('sandbox.write_stdin', {\n                    session_id,\n                }, async () => await session.writeStdin({\n                    sessionId: session_id,\n                    chars,\n                    yieldTimeMs: yield_time_ms,\n                    maxOutputTokens: max_output_tokens,\n                })),\n            }));\n        }\n        return this.configureTools ? this.configureTools([...tools]) : tools;\n    }\n    instructions() {\n        return SHELL_INSTRUCTIONS;\n    }\n}\nexport function shell(args = {}) {\n    return new ShellCapability(args);\n}\n//# sourceMappingURL=shell.mjs.map","import { z } from 'zod';\nimport { tool } from \"../../tool.mjs\";\nimport { dir, file, isDir, isDirectoryLikeEntry, } from \"../entries/index.mjs\";\nimport { SandboxSkillsConfigError } from \"../errors.mjs\";\nimport { normalizeRelativePath } from \"../manifest.mjs\";\nimport { prompt } from \"../runtime/prompts.mjs\";\nimport { Capability, requireBoundSession } from \"./base.mjs\";\nclass SkillsCapability extends Capability {\n    type = 'skills';\n    skills;\n    from;\n    lazyFrom;\n    index;\n    skillsPath;\n    constructor(args) {\n        super();\n        this.skills = args.skills ?? [];\n        this.from = args.from;\n        this.lazyFrom = args.lazyFrom;\n        this.index = args.index;\n        this.skillsPath = normalizeRelativePath(args.skillsPath ?? '.agents');\n        validateSkillsCapability(this);\n    }\n    tools() {\n        if (!this.lazyFrom) {\n            return [];\n        }\n        const session = requireBoundSession(this.type, this._session);\n        if (!session.pathExists || !session.materializeEntry) {\n            throw new SandboxSkillsConfigError('Skills sandbox sessions must provide pathExists() and materializeEntry().');\n        }\n        return [\n            tool({\n                name: 'load_skill',\n                description: 'Load a single lazily configured skill into the sandbox so its SKILL.md, scripts, references, and assets can be read from the workspace.',\n                parameters: z.object({\n                    skill_name: z\n                        .string()\n                        .min(1)\n                        .describe('Name of the lazily configured skill to materialize.'),\n                }),\n                execute: async ({ skill_name, }) => {\n                    const match = resolveLazySkillMatch(this, skill_name);\n                    const relativeSkillPath = normalizeRelativePath(match.path ?? match.name);\n                    const destinationPath = joinRelativePaths(this.skillsPath, relativeSkillPath);\n                    const skillMarkdownPath = joinRelativePaths(destinationPath, 'SKILL.md');\n                    if (await session.pathExists(skillMarkdownPath, this._runAs)) {\n                        return {\n                            status: 'already_loaded',\n                            skill_name: match.name,\n                            path: destinationPath,\n                        };\n                    }\n                    await session.materializeEntry({\n                        path: destinationPath,\n                        entry: resolveLazySkillEntry(this.lazyFrom.source, relativeSkillPath),\n                        runAs: this._runAs,\n                    });\n                    return {\n                        status: 'loaded',\n                        skill_name: match.name,\n                        path: destinationPath,\n                    };\n                },\n            }),\n        ];\n    }\n    processManifest(manifest) {\n        const existingPaths = new Set(Object.keys(manifest.entries).map((path) => normalizeRelativePath(path)));\n        if (this.lazyFrom) {\n            const overlaps = [...existingPaths]\n                .filter((path) => pathsOverlap(path, this.skillsPath))\n                .sort();\n            if (overlaps.length > 0) {\n                throw new SandboxSkillsConfigError(`skills lazyFrom path overlaps existing manifest entries: ${overlaps.join(', ')}`);\n            }\n            return manifest;\n        }\n        if (this.from) {\n            const overlap = [...existingPaths].find((path) => pathsOverlap(path, this.skillsPath));\n            if (overlap) {\n                throw new SandboxSkillsConfigError(`skills path overlaps existing manifest entries: ${overlap}`);\n            }\n            manifest.entries[this.skillsPath] = this.from;\n            return manifest;\n        }\n        for (const skill of this.skills) {\n            const skillPath = joinRelativePaths(this.skillsPath, skill.name);\n            const overlap = [...existingPaths].find((path) => pathsOverlap(path, skillPath));\n            if (overlap) {\n                throw new SandboxSkillsConfigError(`skill path overlaps existing manifest entries: ${skillPath}`);\n            }\n            manifest.entries[skillPath] = renderSkillDescriptor(skill);\n            existingPaths.add(skillPath);\n        }\n        return manifest;\n    }\n    async instructions(manifest) {\n        const metadata = resolveSkillsMetadata(this, await this.resolveRuntimeMetadata(manifest));\n        if (metadata.length === 0 && this.from) {\n            return renderSkillsDiscoveryInstructions(this.skillsPath);\n        }\n        if (metadata.length === 0) {\n            return null;\n        }\n        return renderSkillsInstructions({\n            metadata,\n            lazy: Boolean(this.lazyFrom),\n        });\n    }\n    async resolveRuntimeMetadata(_manifest) {\n        if (!this.from || !this._session?.listDir || !this._session.readFile) {\n            return [];\n        }\n        let entries;\n        try {\n            entries = await this._session.listDir({\n                path: this.skillsPath,\n                runAs: this._runAs,\n            });\n        }\n        catch {\n            return [];\n        }\n        const metadata = [];\n        for (const entry of entries) {\n            if (entry.type !== 'dir') {\n                continue;\n            }\n            let content;\n            try {\n                content = await this._session.readFile({\n                    path: joinRelativePaths(entry.path, 'SKILL.md'),\n                    runAs: this._runAs,\n                });\n            }\n            catch {\n                continue;\n            }\n            const markdown = typeof content === 'string'\n                ? content\n                : new TextDecoder().decode(content);\n            const frontmatter = parseSkillFrontmatter(markdown);\n            metadata.push({\n                name: frontmatter.name ?? entry.name,\n                description: frontmatter.description ?? 'No description provided.',\n                path: entry.name,\n            });\n        }\n        return metadata;\n    }\n}\nexport function skills(args) {\n    return new SkillsCapability(args);\n}\nconst SKILLS_SECTION_INTRO = prompt `\nA skill is a set of local instructions to follow that is stored in a \\`SKILL.md\\` file. Below is the list of skills that can be used. Each entry includes a name, description, and file path so you can open the source for full instructions when using a specific skill.\n`;\nconst HOW_TO_USE_SKILLS_SECTION = prompt `\n### How to use skills\n- Discovery: The list above is the skills available in this session (name + description + file path). Skill bodies live on disk at the listed paths.\n- Trigger rules: If the user names a skill (with \\`$SkillName\\` or plain text) OR the task clearly matches a skill's description shown above, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.\n- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.\n- How to use a skill (progressive disclosure):\n  1) After deciding to use a skill, open its \\`SKILL.md\\`. Read only enough to follow the workflow.\n  2) If \\`SKILL.md\\` points to extra folders such as \\`references/\\`, load only the specific files needed for the request; don't bulk-load everything.\n  3) If \\`scripts/\\` exist, prefer running or patching them instead of retyping large code blocks.\n  4) If \\`assets/\\` or templates exist, reuse them instead of recreating from scratch.\n- Coordination and sequencing:\n  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.\n  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.\n- Context hygiene:\n  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.\n  - Avoid deep reference-chasing: prefer opening only files directly linked from \\`SKILL.md\\` unless you're blocked.\n  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.\n- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.\n`;\nconst HOW_TO_USE_LAZY_SKILLS_SECTION = prompt `\n### How to use skills\n- Discovery: The list above is the skill index available in this session (name + description + workspace path). In lazy mode, those paths are loaded on demand instead of being present up front.\n- Trigger rules: If the user names a skill (with \\`$SkillName\\` or plain text) OR the task clearly matches a skill's description shown above, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.\n- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.\n- How to use a skill (progressive disclosure):\n  1) After deciding to use a lazy skill, call \\`load_skill\\` for that skill first, then open its \\`SKILL.md\\`.\n  2) If \\`SKILL.md\\` points to extra folders such as \\`references/\\`, load only the specific files needed for the request; don't bulk-load everything.\n  3) If \\`scripts/\\` exist, prefer running or patching them instead of retyping large code blocks.\n  4) If \\`assets/\\` or templates exist, reuse them instead of recreating from scratch.\n- Coordination and sequencing:\n  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.\n  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.\n- Context hygiene:\n  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.\n  - Avoid deep reference-chasing: prefer opening only files directly linked from \\`SKILL.md\\` unless you're blocked.\n  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.\n- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.\n`;\nfunction validateSkillsCapability(capability) {\n    const configuredSources = [\n        capability.skills.length > 0,\n        Boolean(capability.from),\n        Boolean(capability.lazyFrom),\n    ].filter(Boolean).length;\n    if (configuredSources === 0) {\n        throw new SandboxSkillsConfigError('skills capability requires `skills`, `from`, or `lazyFrom`.');\n    }\n    if (configuredSources > 1) {\n        throw new SandboxSkillsConfigError('skills capability accepts only one of `skills`, `from`, or `lazyFrom`.');\n    }\n    if (capability.from && !isDirectoryLikeEntry(capability.from)) {\n        throw new SandboxSkillsConfigError('skills from must be a directory-like entry such as dir, git_repo, or mount.');\n    }\n    const seenSkillNames = new Set();\n    for (const skill of capability.skills) {\n        const normalizedName = normalizeRelativePath(skill.name);\n        if (seenSkillNames.has(normalizedName)) {\n            throw new SandboxSkillsConfigError(`duplicate skill name: ${skill.name}`);\n        }\n        seenSkillNames.add(normalizedName);\n    }\n}\nfunction renderSkillDescriptor(skill) {\n    const children = {\n        'SKILL.md': normalizeSkillContent(skill.content),\n    };\n    if (skill.scripts && Object.keys(skill.scripts).length > 0) {\n        children.scripts = dir({\n            children: skill.scripts,\n        });\n    }\n    if (skill.references && Object.keys(skill.references).length > 0) {\n        children.references = dir({\n            children: skill.references,\n        });\n    }\n    if (skill.assets && Object.keys(skill.assets).length > 0) {\n        children.assets = dir({\n            children: skill.assets,\n        });\n    }\n    return dir({\n        children,\n    });\n}\nfunction normalizeSkillContent(content) {\n    if (typeof content === 'string' || content instanceof Uint8Array) {\n        return file({\n            content,\n        });\n    }\n    return content;\n}\nfunction resolveSkillsMetadata(capability, runtimeMetadata = []) {\n    if (capability.skills.length > 0) {\n        return capability.skills\n            .map((skill) => ({\n            name: skill.name,\n            description: skill.description,\n            path: joinRelativePaths(capability.skillsPath, skill.name),\n        }))\n            .sort((left, right) => left.name.localeCompare(right.name));\n    }\n    const configuredIndex = resolveLazySkillIndex(capability.lazyFrom) ??\n        capability.index ??\n        (runtimeMetadata.length > 0 ? runtimeMetadata : undefined) ??\n        deriveIndexFromDirEntry(capability.from);\n    return configuredIndex\n        .map((skill) => ({\n        ...skill,\n        path: joinRelativePaths(capability.skillsPath, skill.path ?? normalizeRelativePath(skill.name)),\n    }))\n        .sort((left, right) => left.name.localeCompare(right.name));\n}\nexport function parseSkillFrontmatter(markdown) {\n    const lines = markdown.split(/\\r?\\n/);\n    if (lines[0]?.trim() !== '---') {\n        return {};\n    }\n    const endIndex = lines.findIndex((line, index) => index > 0 && line.trim() === '---');\n    if (endIndex === -1) {\n        return {};\n    }\n    const metadata = {};\n    for (const line of lines.slice(1, endIndex)) {\n        const stripped = line.trim();\n        const delimiterIndex = stripped.indexOf(':');\n        if (!stripped || stripped.startsWith('#') || delimiterIndex === -1) {\n            continue;\n        }\n        const key = stripped.slice(0, delimiterIndex).trim();\n        const rawValue = stripped.slice(delimiterIndex + 1).trim();\n        if (!key) {\n            continue;\n        }\n        metadata[key] = unquoteFrontmatterValue(rawValue);\n    }\n    return metadata;\n}\nfunction unquoteFrontmatterValue(value) {\n    if (value.length >= 2 &&\n        value[0] === value[value.length - 1] &&\n        (value[0] === '\"' || value[0] === \"'\")) {\n        return value.slice(1, -1);\n    }\n    return value;\n}\nfunction resolveLazySkillIndex(lazySource) {\n    if (!lazySource) {\n        return undefined;\n    }\n    if (lazySource.index) {\n        return lazySource.index;\n    }\n    const derivedIndex = deriveIndexFromDirEntry(lazySource.source);\n    return derivedIndex.length > 0 ? derivedIndex : undefined;\n}\nfunction deriveIndexFromDirEntry(entry) {\n    if (!entry || !isDir(entry) || !entry.children) {\n        return [];\n    }\n    return Object.entries(entry.children)\n        .filter(([, child]) => child.type === 'dir')\n        .map(([name, child]) => ({\n        name,\n        description: child.description ?? 'No description provided.',\n    }));\n}\nfunction renderSkillsDiscoveryInstructions(skillsPath) {\n    return prompt `\n## Skills\n${SKILLS_SECTION_INTRO}\n\n### Skill source\n- Skills are materialized under ${skillsPath}. Discover available skills by inspecting child directories and their SKILL.md files at runtime.\n\n${HOW_TO_USE_SKILLS_SECTION}\n`;\n}\nfunction renderSkillsInstructions(args) {\n    const availableSkills = args.metadata\n        .map((skill) => `- ${skill.name}: ${skill.description} (file: ${skill.path ?? skill.name})`)\n        .join('\\n');\n    const lazyLoadingInstructions = args.lazy\n        ? prompt `\n### Lazy loading\n- These skills are indexed for planning, but they are not materialized in the workspace yet.\n- Call \\`load_skill\\` with a single skill name from the list before reading its \\`SKILL.md\\` or other files from the workspace.\n- \\`load_skill\\` stages exactly one skill under the listed path. If you need more than one skill, call it multiple times.\n`\n        : '';\n    const usageInstructions = args.lazy\n        ? HOW_TO_USE_LAZY_SKILLS_SECTION\n        : HOW_TO_USE_SKILLS_SECTION;\n    const lazyLoadingSection = lazyLoadingInstructions\n        ? `${lazyLoadingInstructions}\\n\\n`\n        : '';\n    return prompt `\n## Skills\n${SKILLS_SECTION_INTRO}\n\n### Available skills\n${availableSkills}\n\n${lazyLoadingSection}${usageInstructions}\n`;\n}\nfunction resolveLazySkillMatch(capability, skillName) {\n    const index = resolveLazySkillIndex(capability.lazyFrom) ?? capability.index ?? [];\n    const matches = index.filter((skill) => {\n        const relativePath = normalizeRelativePath(skill.path ?? skill.name);\n        const pathBaseName = relativePath.split('/').pop() ?? relativePath;\n        return (skill.name === skillName ||\n            relativePath === skillName ||\n            pathBaseName === skillName);\n    });\n    if (matches.length === 0) {\n        throw new SandboxSkillsConfigError(`lazy skill not found: ${skillName}`);\n    }\n    if (matches.length > 1) {\n        throw new SandboxSkillsConfigError(`lazy skill name is ambiguous: ${skillName}`);\n    }\n    return matches[0];\n}\nfunction joinRelativePaths(left, right) {\n    const normalizedLeft = normalizeRelativePath(left);\n    const normalizedRight = normalizeRelativePath(right);\n    if (!normalizedLeft) {\n        return normalizedRight;\n    }\n    if (!normalizedRight) {\n        return normalizedLeft;\n    }\n    return `${normalizedLeft}/${normalizedRight}`;\n}\nfunction joinSourcePath(sourceRoot, relativePath) {\n    const trimmedRoot = sourceRoot.replace(/[\\\\/]+$/, '');\n    if (!trimmedRoot) {\n        return relativePath;\n    }\n    return `${trimmedRoot}/${relativePath}`;\n}\nfunction resolveLazySkillEntry(source, relativeSkillPath) {\n    if (source.type === 'local_dir') {\n        if (!source.src) {\n            throw new SandboxSkillsConfigError('Lazy skill local_dir sources require a concrete src value.');\n        }\n        return {\n            ...source,\n            type: 'local_dir',\n            src: joinSourcePath(source.src, relativeSkillPath),\n        };\n    }\n    if (source.type === 'git_repo') {\n        const baseSubpath = source.subpath\n            ? normalizeRelativePath(source.subpath)\n            : '';\n        return {\n            ...source,\n            type: 'git_repo',\n            subpath: joinRelativePaths(baseSubpath, relativeSkillPath),\n        };\n    }\n    if (source.type === 'dir') {\n        const child = readDirChild(source, relativeSkillPath);\n        if (!child) {\n            throw new SandboxSkillsConfigError(`lazy skill source path not found: ${relativeSkillPath}`);\n        }\n        return child;\n    }\n    throw new SandboxSkillsConfigError(`Lazy skill source type is not supported yet: ${source.type}`);\n}\nfunction readDirChild(source, relativeSkillPath) {\n    let current = source;\n    for (const segment of normalizeRelativePath(relativeSkillPath).split('/')) {\n        if (!segment) {\n            continue;\n        }\n        if (!current || !isDir(current) || !current.children) {\n            return undefined;\n        }\n        current = current.children[segment];\n    }\n    return current;\n}\nfunction pathsOverlap(left, right) {\n    return (left === right ||\n        left.startsWith(`${right}/`) ||\n        right.startsWith(`${left}/`));\n}\n//# sourceMappingURL=skills.mjs.map","import { compaction } from \"./compaction.mjs\";\nimport { filesystem } from \"./filesystem.mjs\";\nimport { shell } from \"./shell.mjs\";\nexport { Capability } from \"./base.mjs\";\nexport { CompactionModelInfo, CompactionPolicy, DynamicCompactionPolicy, StaticCompactionPolicy, compaction, } from \"./compaction.mjs\";\nexport { filesystem } from \"./filesystem.mjs\";\nexport { memory } from \"./memory.mjs\";\nexport { InMemoryMemoryStore } from \"../memory/storage.mjs\";\nexport { shell } from \"./shell.mjs\";\nexport { skills } from \"./skills.mjs\";\nfunction defaultCapabilities() {\n    return [filesystem(), shell(), compaction()];\n}\nexport const Capabilities = {\n    default: defaultCapabilities,\n};\n//# sourceMappingURL=index.mjs.map","import { Agent } from \"../agent.mjs\";\nimport { SANDBOX_AGENT_BRAND } from \"./brand.mjs\";\nimport { Capabilities } from \"./capabilities/index.mjs\";\nimport { cloneManifest, Manifest } from \"./manifest.mjs\";\nimport { normalizeUser } from \"./users.mjs\";\nexport class SandboxAgent extends Agent {\n    [SANDBOX_AGENT_BRAND] = true;\n    defaultManifest;\n    baseInstructions;\n    capabilities;\n    runAs;\n    runtimeManifest;\n    constructor(config) {\n        super(config);\n        if (config.baseInstructions !== undefined &&\n            typeof config.baseInstructions !== 'string' &&\n            typeof config.baseInstructions !== 'function') {\n            throw new TypeError('SandboxAgent baseInstructions must be a string or function.');\n        }\n        this.defaultManifest = config.defaultManifest\n            ? cloneManifest(config.defaultManifest)\n            : undefined;\n        this.baseInstructions = config.baseInstructions;\n        this.capabilities = config.capabilities ?? Capabilities.default();\n        this.runAs = normalizeRunAs(config.runAs);\n        this.runtimeManifest = this.defaultManifest ?? new Manifest();\n    }\n    clone(config) {\n        return new SandboxAgent({\n            name: config.name ?? this.name,\n            instructions: config.instructions ?? this.instructions,\n            prompt: config.prompt ?? this.prompt,\n            handoffDescription: config.handoffDescription ?? this.handoffDescription,\n            handoffs: config.handoffs ?? this.handoffs,\n            model: config.model ?? this.model,\n            modelSettings: config.modelSettings ?? this.modelSettings,\n            tools: config.tools ?? this.tools,\n            mcpServers: config.mcpServers ?? this.mcpServers,\n            inputGuardrails: config.inputGuardrails ?? this.inputGuardrails,\n            outputGuardrails: config.outputGuardrails ?? this.outputGuardrails,\n            outputType: config.outputType ?? this.outputType,\n            toolUseBehavior: config.toolUseBehavior ?? this.toolUseBehavior,\n            resetToolChoice: config.resetToolChoice ?? this.resetToolChoice,\n            defaultManifest: config.defaultManifest ?? this.defaultManifest,\n            baseInstructions: config.baseInstructions ?? this.baseInstructions,\n            capabilities: config.capabilities ?? this.capabilities,\n            runAs: config.runAs ?? this.runAs,\n        });\n    }\n}\nfunction normalizeRunAs(runAs) {\n    if (runAs === undefined) {\n        return undefined;\n    }\n    if (typeof runAs === 'string') {\n        const trimmed = runAs.trim();\n        if (!trimmed) {\n            throw new TypeError('SandboxAgent runAs must be non-empty.');\n        }\n        return trimmed;\n    }\n    return normalizeUser(runAs);\n}\n//# sourceMappingURL=agent.mjs.map"],"names":["supportsResponsesCompactionTransport","modelInstance","supportsApplyPatchTransport","supportsStructuredToolOutputTransport","CompactionPolicy","DynamicCompactionPolicy","thresholdRatio","fallbackThreshold","__publicField","model","modelInfo","CompactionModelInfo","contextWindow","candidate","getSandboxCompactionModelCandidates","SANDBOX_CONTEXT_WINDOWS_1M","SANDBOX_CONTEXT_WINDOWS_400K","SANDBOX_CONTEXT_WINDOWS_200K","SANDBOX_CONTEXT_WINDOWS_128K","CompactionCapability","Capability","policy","samplingParams","context","lastCompactionIndex","index","compaction","args","trimmed","normalized","withoutPinnedDate","applyPatchFunctionParameters","BEGIN_PATCH","END_PATCH","ADD_FILE","DELETE_FILE","UPDATE_FILE","MOVE_TO","toErrorMessage","error","renderImageForTextTransport","output","image","isRecord","imageRecord","encodeUint8ArrayToBase64","renderViewImageError","path","message","name","parseApplyPatchInput","rawInput","trimmedInput","parseFreeformPatch","payload","parseApplyPatchPayload","parseStructuredOperations","commandName","patch","payloads","operations","parsed","ApplyPatchOperation","rawPatch","lines","line","parseAddFilePatch","parseDeleteFilePatch","parseUpdateFilePatch","parsePatchHeader","diffLines","isFileOperationHeader","joinDiff","moveTo","parsedMoveTo","prefix","applyPatchOperation","editor","operation","runContext","result","applyPatchOperations","outputs","applyPatchFunctionTool","input","FilesystemCapability","session","requireBoundSession","_a","UserError","tools","viewImage","withSandboxSpan","tool","z.object","z.string","applyPatchTool","filesystem","DEFAULT_EXEC_YIELD_TIME_MS","DEFAULT_WRITE_STDIN_YIELD_TIME_MS","SHELL_INSTRUCTIONS","ShellCapability","z\n                        .string","z\n                        .boolean","z\n                        .number","cmd","workdir","shell","login","tty","yield_time_ms","max_output_tokens","session_id","chars","prompt","defaultCapabilities","Capabilities","SandboxAgent","_b","Agent","SANDBOX_AGENT_BRAND","config","cloneManifest","normalizeRunAs","Manifest","runAs","normalizeUser"],"mappings":"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"}