@sepveneto/dnde-agent 0.1.1-beta.1 → 0.1.9

package/dist/agent-BO7EhtdO.js

@@ -0,0 +1,663 @@
+var V = Object.defineProperty;
+var Q = (t, s, e) => s in t ? V(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
+var a = (t, s, e) => Q(t, typeof s != "symbol" ? s + "" : s, e);
+import { C as E, U as x, r as X, t as I, o as v, s as y, a as Z, w as A, i as q, e as ee, A as te, n as k, b as R, p as C, c as se, S as ie, d as ne, M as re, f as ae } from "./index-B4GzASvE.js";
+function oe(t) {
+  return t ? !(typeof t == "object" && t && "constructor" in t && typeof t.constructor == "function" ? t.constructor.name : "").includes("ChatCompletions") : !0;
+}
+function ce(t) {
+  return G(t);
+}
+function G(t) {
+  return t ? !(typeof t == "object" && t && "constructor" in t && typeof t.constructor == "function" ? t.constructor.name : "").includes("ChatCompletions") : !1;
+}
+class le {
+}
+class pe extends le {
+  constructor(e = 0.9, i = 24e4) {
+    super();
+    a(this, "thresholdRatio");
+    a(this, "fallbackThreshold");
+    if (!Number.isFinite(e) || e < 0 || e > 1)
+      throw new x("DynamicCompactionPolicy.thresholdRatio must be a finite number between 0 and 1.");
+    this.thresholdRatio = e, this.fallbackThreshold = i;
+  }
+  compactThreshold(e) {
+    if (!e)
+      return this.fallbackThreshold;
+    const i = g.forModel(e);
+    return i ? Math.floor(i.contextWindow * this.thresholdRatio) : this.fallbackThreshold;
+  }
+}
+class g {
+  constructor(s) {
+    a(this, "contextWindow");
+    this.contextWindow = s;
+  }
+  static forModel(s) {
+    for (const e of de(s)) {
+      if (fe.has(e))
+        return new g(1047576);
+      if (me.has(e))
+        return new g(4e5);
+      if (ye.has(e))
+        return new g(2e5);
+      if (ge.has(e))
+        return new g(128e3);
+    }
+  }
+}
+class ue extends E {
+  constructor(e = new pe()) {
+    super();
+    a(this, "type", "compaction");
+    a(this, "policy");
+    this.policy = e;
+  }
+  samplingParams(e) {
+    if (e.modelInstance && !oe(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 he(t = {}) {
+  return new ue(t.policy);
+}
+function de(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 fe = /* @__PURE__ */ new Set([
+  "gpt-5.6",
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna",
+  "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"
+]), me = /* @__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"
+]), ye = /* @__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"
+]), ge = /* @__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"
+]), be = {
+  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
+}, P = "*** Begin Patch", j = "*** End Patch", D = "*** Add File: ", M = "*** Delete File: ", F = "*** Update File: ", K = "*** Move to: ";
+function O(t) {
+  if (t instanceof Error)
+    return t.message || t.toString();
+  try {
+    return JSON.stringify(t);
+  } catch (s) {
+    return String(t);
+  }
+}
+function we(t) {
+  if (typeof t == "string")
+    return t;
+  const s = t.image;
+  if (typeof s == "string")
+    return s;
+  if (!q(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,${ee(e.data)}` : "No image data was returned by the sandbox session.";
+}
+function ke(t, s) {
+  const e = O(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 _e(t) {
+  const s = t.trimStart();
+  if (s.startsWith(P))
+    return T(s);
+  let e;
+  try {
+    e = JSON.parse(t);
+  } catch (i) {
+    return {
+      ok: !1,
+      error: `Invalid apply_patch JSON: ${O(i)}`
+    };
+  }
+  return Te(e);
+}
+function Te(t) {
+  if (typeof t == "string")
+    return T(t);
+  if (Array.isArray(t))
+    return _(t);
+  if (!q(t))
+    return {
+      ok: !1,
+      error: "apply_patch input must be an object or array."
+    };
+  if (typeof t.patch == "string")
+    return T(t.patch);
+  if (Array.isArray(t.command)) {
+    const [s, e] = t.command;
+    if (s === "apply_patch" && typeof e == "string")
+      return T(e);
+  }
+  return Array.isArray(t.operations) ? _(t.operations) : t.operation !== void 0 ? _([t.operation]) : _([t]);
+}
+function _(t) {
+  const s = [];
+  for (const e of t) {
+    const i = te.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 T(t) {
+  const s = t.split(/\r?\n/);
+  if (s.at(-1) === "" && s.pop(), s[0] !== P)
+    return {
+      ok: !1,
+      error: `apply_patch input must start with "${P}".`
+    };
+  if (s.length < 2 || s.at(-1) !== j)
+    return {
+      ok: !1,
+      error: `apply_patch input must end with "${j}".`
+    };
+  const e = [];
+  let i = 1;
+  for (; i < s.length - 1; ) {
+    const n = s[i];
+    let r;
+    if (n.startsWith(D))
+      r = xe(s, i);
+    else if (n.startsWith(M))
+      r = Ie(s, i);
+    else if (n.startsWith(F))
+      r = ve(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 xe(t, s) {
+  const e = S(t[s], D);
+  if (!e)
+    return { error: `Missing path in apply_patch header: ${t[s]}` };
+  s += 1;
+  const i = [];
+  for (; s < t.length - 1 && !N(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: Y(i)
+    },
+    nextIndex: s
+  };
+}
+function Ie(t, s) {
+  const e = S(t[s], M);
+  return e ? (s += 1, s < t.length - 1 && !N(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 ve(t, s) {
+  const e = S(t[s], F);
+  if (!e)
+    return { error: `Missing path in apply_patch header: ${t[s]}` };
+  s += 1;
+  let i;
+  if (s < t.length - 1 && t[s].startsWith(K)) {
+    const r = S(t[s], K);
+    if (!r)
+      return { error: `Missing path in apply_patch header: ${t[s]}` };
+    i = r, s += 1;
+  }
+  const n = [];
+  for (; s < t.length - 1 && !N(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 ? Y(n) : "",
+      ...i ? { moveTo: i } : {}
+    },
+    nextIndex: s
+  };
+}
+function S(t, s) {
+  const e = t.slice(s.length).trim();
+  return e || null;
+}
+function N(t) {
+  return t.startsWith(D) || t.startsWith(M) || t.startsWith(F);
+}
+function Y(t) {
+  return `${t.join(`
+`)}
+`;
+}
+async function Se(t, s, e) {
+  var n;
+  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 (r) {
+    return `Failed to apply patch: ${O(r)}`;
+  }
+  return (i == null ? void 0 : i.status) === "failed" ? i.output ? `Patch failed: ${i.output}` : "Patch failed." : (n = i == null ? void 0 : i.output) != null ? n : "Patch applied.";
+}
+async function Ae(t, s, e) {
+  const i = [];
+  for (const n of s) {
+    const r = await Se(t, n, e);
+    r && i.push(r);
+  }
+  return i.join(`
+`) || "Patch applied.";
+}
+function Pe(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: be,
+    strict: !1,
+    deferLoading: !1,
+    needsApproval: async () => !1,
+    isEnabled: async () => !0,
+    invoke: async (e, i) => {
+      const n = _e(i);
+      return n.ok ? await Ae(t, n.operations, e) : n.error;
+    }
+  };
+}
+class Ee extends E {
+  constructor(e = {}) {
+    super();
+    a(this, "type", "filesystem");
+    a(this, "configureTools");
+    this.configureTools = e.configureTools;
+  }
+  tools() {
+    var p, u;
+    const e = X(this.type, this._session), i = (p = e.createEditor) == null ? void 0 : p.call(e, this._runAs);
+    if (!i)
+      throw new x("Filesystem sandbox sessions must provide createEditor().");
+    const n = (u = this._workspaceScope) != null && u.cwd ? Ce(i, this._workspaceScope) : i, r = [], l = async (o, h) => {
+      var m, d;
+      if (!e.viewImage)
+        throw new x("Filesystem sandbox sessions must provide viewImage().");
+      const c = (d = (m = this._workspaceScope) == null ? void 0 : m.anchor(o)) != null ? d : o;
+      try {
+        return await A("sandbox.view_image", {
+          path: c,
+          run_as: this._runAs
+        }, async () => await e.viewImage({
+          path: c,
+          runAs: this._runAs
+        }), this.tracingParent(h));
+      } catch (f) {
+        return ke(o, f);
+      }
+    };
+    return G(this._modelInstance) ? r.push(I({
+      name: "view_image",
+      description: "Returns an image output from a path in the sandbox workspace or an explicitly granted sandbox path.",
+      parameters: v({
+        path: y().describe("Path to an image file in the sandbox workspace or an explicitly granted sandbox path")
+      }),
+      execute: async ({ path: o }, h, c) => await l(o, c)
+    })) : r.push(I({
+      name: "view_image",
+      description: "Returns an image from a path in the sandbox workspace or an explicitly granted sandbox path as a data URL or reference string.",
+      parameters: v({
+        path: y().describe("Path to an image file in the sandbox workspace or an explicitly granted sandbox path")
+      }),
+      execute: async ({ path: o }, h, c) => we(await l(o, c))
+    })), ce(this._modelInstance) ? r.push(Z({
+      name: "apply_patch",
+      editor: n
+    })) : r.push(Pe(n)), this.configureTools ? this.configureTools([...r]) : r;
+  }
+}
+function Ce(t, s) {
+  return {
+    createFile: async (e, i) => await t.createFile({ ...e, path: s.anchor(e.path) }, i),
+    updateFile: async (e, i) => await t.updateFile({
+      ...e,
+      path: s.anchor(e.path),
+      ...e.moveTo ? { moveTo: s.anchor(e.moveTo) } : {}
+    }, i),
+    deleteFile: async (e, i) => await t.deleteFile({ ...e, path: s.anchor(e.path) }, i)
+  };
+}
+function De(t = {}) {
+  return new Ee(t);
+}
+const Me = 1e4, Fe = 250, Oe = [
+  "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 Ne extends E {
+  constructor(e = {}) {
+    super();
+    a(this, "type", "shell");
+    a(this, "configureTools");
+    this.configureTools = e.configureTools;
+  }
+  tools() {
+    var n;
+    const e = X(this.type, this._session);
+    if (!e.execCommand)
+      throw new x("Shell sandbox sessions must provide execCommand().");
+    const i = [
+      I({
+        name: "exec_command",
+        description: "Runs a command in a PTY, returning output or a session ID for ongoing interaction.",
+        parameters: v({
+          cmd: y().min(1).describe("Shell command to execute."),
+          workdir: y().optional().describe("Optional working directory to run the command in; defaults to the turn cwd."),
+          shell: y().optional().describe("Shell binary to launch. Defaults to the user's default shell."),
+          login: R().default(!0).describe("Whether to run the shell with -l/-i semantics. Defaults to true."),
+          tty: R().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: k().int().min(0).default(Me).describe("How long to wait (in milliseconds) for output before yielding."),
+          max_output_tokens: k().int().min(1).optional().describe("Maximum number of tokens to return. Excess output will be truncated.")
+        }),
+        execute: async ({ cmd: r, workdir: l, shell: p, login: u, tty: o, yield_time_ms: h, max_output_tokens: c }, m, d) => {
+          var b, w;
+          const f = (w = (b = this._workspaceScope) == null ? void 0 : b.anchor(l)) != null ? w : l;
+          return await A("sandbox.exec", {
+            cmd: r,
+            workdir: f,
+            shell: p,
+            login: u,
+            tty: o,
+            run_as: this._runAs
+          }, async () => await e.execCommand({
+            cmd: r,
+            workdir: f,
+            shell: p,
+            login: u,
+            tty: o,
+            yieldTimeMs: h,
+            maxOutputTokens: c,
+            runAs: this._runAs
+          }), this.tracingParent(d));
+        }
+      })
+    ];
+    return (n = e.supportsPty) != null && n.call(e) && e.writeStdin && i.push(I({
+      name: "write_stdin",
+      description: "Writes characters to an existing unified exec session and returns recent output.",
+      parameters: v({
+        session_id: k().int().describe("Identifier of the running unified exec session."),
+        chars: y().default("").describe("Bytes to write to stdin (may be empty to poll)."),
+        yield_time_ms: k().int().min(0).default(Fe).describe("How long to wait (in milliseconds) for output before yielding."),
+        max_output_tokens: k().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: p, max_output_tokens: u }, o, h) => await A("sandbox.write_stdin", {
+        session_id: r
+      }, async () => await e.writeStdin({
+        sessionId: r,
+        chars: l,
+        yieldTimeMs: p,
+        maxOutputTokens: u
+      }), this.tracingParent(h))
+    })), this.configureTools ? this.configureTools([...i]) : i;
+  }
+  instructions() {
+    return Oe;
+  }
+}
+function $e(t = {}) {
+  return new Ne(t);
+}
+C`
+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.
+`;
+C`
+### 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.
+`;
+C`
+### 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 Le() {
+  return [De(), $e(), he()];
+}
+const We = {
+  default: Le
+};
+var H, z;
+class J extends (z = se, H = ie, z) {
+  constructor(e) {
+    var i, n;
+    super(e);
+    a(this, H, !0);
+    a(this, "defaultManifest");
+    a(this, "baseInstructions");
+    a(this, "capabilities");
+    a(this, "runAs");
+    a(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 ? ne(e.defaultManifest) : void 0, this.baseInstructions = e.baseInstructions, this.capabilities = (i = e.capabilities) != null ? i : We.default(), this.runAs = Be(e.runAs), this.runtimeManifest = (n = this.defaultManifest) != null ? n : new re();
+  }
+  clone(e) {
+    var i, n, r, l, p, u, o, h, c, m, d, f, b, w, $, L, W, B, U;
+    return new J({
+      name: (i = e.name) != null ? i : this.name,
+      instructions: (n = e.instructions) != null ? n : this.instructions,
+      prompt: (r = e.prompt) != null ? r : this.prompt,
+      handoffDescription: (l = e.handoffDescription) != null ? l : this.handoffDescription,
+      handoffs: (p = e.handoffs) != null ? p : this.handoffs,
+      model: (u = e.model) != null ? u : this.model,
+      modelSettings: (o = e.modelSettings) != null ? o : this.modelSettings,
+      tools: (h = e.tools) != null ? h : this.tools,
+      mcpServers: (c = e.mcpServers) != null ? c : this.mcpServers,
+      mcpConfig: (m = e.mcpConfig) != null ? m : this.mcpConfig,
+      inputGuardrails: (d = e.inputGuardrails) != null ? d : this.inputGuardrails,
+      outputGuardrails: (f = e.outputGuardrails) != null ? f : this.outputGuardrails,
+      outputType: (b = e.outputType) != null ? b : this.outputType,
+      toolUseBehavior: (w = e.toolUseBehavior) != null ? w : this.toolUseBehavior,
+      resetToolChoice: ($ = e.resetToolChoice) != null ? $ : this.resetToolChoice,
+      defaultManifest: (L = e.defaultManifest) != null ? L : this.defaultManifest,
+      baseInstructions: (W = e.baseInstructions) != null ? W : this.baseInstructions,
+      capabilities: (B = e.capabilities) != null ? B : this.capabilities,
+      runAs: (U = e.runAs) != null ? U : this.runAs
+    });
+  }
+}
+function Be(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 ae(t);
+  }
+}
+export {
+  J as SandboxAgent
+};

package/dist/composables/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useFile';
+//# sourceMappingURL=index.d.ts.map

package/dist/composables/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composables/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA"}

package/dist/composables/useFile.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from "vue";
+export declare function useFile(file: Ref<HTMLInputElement | null>): {
+    list: import("vue").ShallowRef<{
+        name: string;
+        file: string;
+    }[], {
+        name: string;
+        file: string;
+    }[]>;
+    selectFile: () => void;
+    handleFileChange: (e: Event) => Promise<void>;
+    reset: () => void;
+};
+//# sourceMappingURL=useFile.d.ts.map

package/dist/composables/useFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFile.d.ts","sourceRoot":"","sources":["../../src/composables/useFile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,GAAG,EAAE,MAAM,KAAK,CAAC;AAEtC,wBAAgB,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,gBAAgB,GAAG,IAAI,CAAC;;cACxB,MAAM;cAAQ,MAAM;;cAApB,MAAM;cAAQ,MAAM;;;0BASjB,KAAK;;EAuBzC"}

package/dist/element.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"element.d.ts","sourceRoot":"","sources":["../src/element.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,KAAK,CAAA;AAIhD,cAAc,SAAS,CAAA;AAMvB;;GAEG;AACH,wBAAgB,eAAe,IAAI,qBAAqB,CAKvD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,MAAyB,GAAG,MAAM,GAAG,SAAS,CAU3F;AAKD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,WAAW,EAAE,WAAW,CAAA;KACzB;CACF"}
+{"version":3,"file":"element.d.ts","sourceRoot":"","sources":["../src/element.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,KAAK,CAAA;AAGhD,cAAc,SAAS,CAAA;AAMvB;;GAEG;AACH,wBAAgB,eAAe,IAAI,qBAAqB,CAMvD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,MAAyB,GAAG,MAAM,GAAG,SAAS,CAU3F;AAKD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,WAAW,EAAE,WAAW,CAAA;KACzB;CACF"}