@pi-oxide/pi-host-web 0.5.0 → 0.8.0

package/dist/index.js

@@ -0,0 +1,1706 @@
+var U = Object.defineProperty;
+var H = (t, e, s) => e in t ? U(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var b = (t, e, s) => H(t, typeof e != "symbol" ? e + "" : e, s);
+import { l as S, h as _, b as G, g as P, i as F, e as K, o as Q, c as X, r as V, w as Y, m as Z, n as ee } from "./index-CAp51VNq.js";
+import { C as _t, a as yt, N as bt, f as xt, j as wt, k as St, s as kt, t as vt, v as Rt } from "./index-CAp51VNq.js";
+import { zodToJsonSchema as te } from "zod-to-json-schema";
+class se {
+  constructor() {
+    b(this, "handlers", {});
+  }
+  on(e, s) {
+    this.handlers[e] || (this.handlers[e] = /* @__PURE__ */ new Set());
+    const o = this.handlers[e];
+    return o.add(s), () => {
+      o.delete(s), o.size === 0 && delete this.handlers[e];
+    };
+  }
+  off(e, s) {
+    const o = this.handlers[e];
+    o && (o.delete(s), o.size === 0 && delete this.handlers[e]);
+  }
+  emit(e, s) {
+    const o = this.handlers[e];
+    if (o)
+      for (const r of o)
+        r(s);
+  }
+  clear() {
+    this.handlers = {};
+  }
+}
+const O = 1;
+class J {
+  constructor() {
+    b(this, "logger", S("snapshot"));
+  }
+  serialize(e) {
+    return {
+      version: O,
+      data: e
+    };
+  }
+  deserialize(e) {
+    return e.version !== O ? (this.logger.warn("Snapshot version mismatch, starting fresh", {
+      expected: O,
+      got: e.version
+    }), null) : e.data;
+  }
+}
+class oe {
+  createRunState() {
+    return {
+      messages: [],
+      toolCalls: [],
+      artifacts: [],
+      usage: { input: 0, output: 0, cache_read: 0, cache_write: 0, total_tokens: 0 },
+      text: "",
+      currentMessage: null,
+      currentTool: null
+    };
+  }
+  map(e, s) {
+    const o = [];
+    switch (e.type) {
+      case "agent_start": {
+        o.push({ type: "status", payload: { state: "loading", message: "Agent starting..." } });
+        break;
+      }
+      case "turn_start": {
+        o.push({ type: "status", payload: { state: "thinking", message: "Thinking..." } });
+        break;
+      }
+      case "message_start": {
+        const r = this.convertWasmMessage(e.message);
+        s.currentMessage = r, s.messages.push(r), o.push({ type: "messageStart", payload: r }), o.push({ type: "status", payload: { state: "thinking" } });
+        break;
+      }
+      case "message_update": {
+        const r = e.delta;
+        r.kind === "text_delta" && r.text ? (s.text += r.text, o.push({ type: "text", payload: r.text })) : r.kind === "thinking_delta" && o.push({ type: "status", payload: { state: "thinking", message: "Thinking..." } });
+        break;
+      }
+      case "message_end": {
+        const r = this.convertWasmMessage(e.message);
+        s.currentMessage = r;
+        const n = s.messages.findIndex((a) => a.id === r.id);
+        n >= 0 ? s.messages[n] = r : s.messages.push(r), o.push({ type: "messageEnd", payload: r });
+        break;
+      }
+      case "tool_execution_start": {
+        const r = {
+          id: e.tool_call_id,
+          name: e.tool_name,
+          title: e.tool_name,
+          input: e.args ?? {},
+          status: "running",
+          startedAt: Date.now()
+        };
+        s.currentTool = r, s.toolCalls.push(r), o.push({ type: "toolStart", payload: r }), o.push({
+          type: "status",
+          payload: { state: "running_tool", message: `Running ${e.tool_name}...` }
+        });
+        break;
+      }
+      case "tool_execution_update": {
+        const r = s.toolCalls.find((n) => n.id === e.tool_call_id);
+        r && (r.output = (r.output ?? "") + e.chunk, o.push({ type: "toolUpdate", payload: r }));
+        break;
+      }
+      case "tool_execution_end": {
+        let r = s.toolCalls.find((a) => a.id === e.tool_call_id);
+        if (!r) {
+          const a = e.tool_name ?? "unknown";
+          r = {
+            id: e.tool_call_id,
+            name: a,
+            title: a,
+            input: e.args ?? {},
+            status: e.is_error ? "failed" : "completed",
+            startedAt: Date.now(),
+            endedAt: Date.now()
+          }, s.toolCalls.push(r);
+        }
+        r.status = e.is_error ? "failed" : "completed", r.endedAt = Date.now();
+        const n = e.result.content.filter((a) => a.type === "text").map((a) => a.text).join(`
+`);
+        r.output = n, o.push({ type: "toolEnd", payload: r });
+        break;
+      }
+      case "tool_execution_cancelled": {
+        const r = s.toolCalls.find((n) => n.id === e.tool_call_id);
+        r && (r.status = "cancelled", r.endedAt = Date.now(), o.push({ type: "toolEnd", payload: r }));
+        break;
+      }
+      case "turn_end": {
+        const r = this.convertWasmMessage(e.message), n = s.messages.findIndex((a) => a.id === r.id);
+        n >= 0 ? s.messages[n] = r : s.messages.push(r);
+        for (const a of e.tool_results) {
+          let i = s.toolCalls.find((c) => c.id === a.tool_call_id);
+          if (!i) {
+            const c = a.tool_name ?? "unknown";
+            i = {
+              id: a.tool_call_id,
+              name: c,
+              title: c,
+              input: {},
+              status: a.is_error ? "failed" : "completed",
+              startedAt: Date.now(),
+              endedAt: Date.now()
+            }, s.toolCalls.push(i);
+          }
+          i.status = a.is_error ? "failed" : "completed", i.endedAt = Date.now();
+          const l = a.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+          i.output = l;
+        }
+        o.push({ type: "status", payload: { state: "completed" } });
+        break;
+      }
+      case "save_point": {
+        o.push({ type: "status", payload: { state: "saving", message: "Saving session..." } });
+        break;
+      }
+      case "settled": {
+        o.push({ type: "status", payload: { state: "completed" } });
+        break;
+      }
+      case "queue_update":
+        break;
+      case "agent_end": {
+        o.push({ type: "status", payload: { state: "idle" } });
+        break;
+      }
+    }
+    return o;
+  }
+  buildRunResult(e, s) {
+    return s.aborted ? {
+      status: "aborted",
+      text: e.text,
+      toolCalls: e.toolCalls,
+      artifacts: e.artifacts,
+      usage: e.usage
+    } : {
+      status: "completed",
+      message: e.currentMessage ?? void 0,
+      text: e.text,
+      toolCalls: e.toolCalls,
+      artifacts: e.artifacts,
+      usage: e.usage
+    };
+  }
+  processMarkers(e, s) {
+    const o = [];
+    for (const r of e)
+      if (r.type === "new_artifacts" && r.entry_ids)
+        for (const n of r.entry_ids)
+          s.artifacts.push({ id: n, kind: "text" }), o.push({ type: "artifact", payload: { id: n, kind: "text" } });
+    return o;
+  }
+  convertWasmMessage(e) {
+    return {
+      id: this.generateStableId(e),
+      role: e.role,
+      content: e.content.map((o) => this.convertContent(o)),
+      timestamp: e.timestamp ?? Date.now(),
+      tool_call_id: e.role === "tool_result" ? e.tool_call_id : void 0
+    };
+  }
+  generateStableId(e) {
+    const s = e.content.map((o) => {
+      var r;
+      return o.type === "text" ? `t:${((r = o.text) == null ? void 0 : r.slice(0, 20)) ?? ""}` : o.type === "tool_call" ? `tc:${o.id ?? ""}:${o.name ?? ""}` : o.type === "image" ? `img:${o.media_type ?? ""}` : o.type;
+    }).join("|");
+    return `msg-${e.role}-${e.timestamp ?? 0}-${s}`;
+  }
+  convertContent(e) {
+    return e.type === "text" ? { type: "text", text: e.text } : e.type === "tool_call" ? { type: "tool_call", id: e.id, name: e.name, arguments: e.arguments } : e.type === "image" ? { type: "image", mimeType: e.media_type, data: e.data } : { type: "text", text: "" };
+  }
+}
+function v(t) {
+  return typeof t == "object" && t !== null;
+}
+function k(t, e) {
+  if (v(t)) {
+    const s = t[e];
+    return typeof s == "string" ? s : void 0;
+  }
+}
+function ne(t, e) {
+  if (v(t)) {
+    const s = t[e];
+    return typeof s == "number" ? s : void 0;
+  }
+}
+function re(t, e) {
+  if (v(t)) {
+    const s = t[e];
+    return typeof s == "boolean" ? s : void 0;
+  }
+}
+const W = [], C = {
+  log: console.log.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console),
+  info: console.info.bind(console)
+};
+function E(t, e) {
+  W.push({ level: t, args: e.map(String), timestamp: Date.now() });
+}
+console.log = (...t) => {
+  E("log", t), C.log(...t);
+};
+console.warn = (...t) => {
+  E("warn", t), C.warn(...t);
+};
+console.error = (...t) => {
+  E("error", t), C.error(...t);
+};
+console.info = (...t) => {
+  E("info", t), C.info(...t);
+};
+function I(t, e) {
+  const s = (t.textContent || "").trim().slice(0, 500), o = {};
+  for (const a of Array.from(t.attributes))
+    o[a.name] = a.value;
+  const r = window.getComputedStyle(t), n = r.display !== "none" && r.visibility !== "hidden" && r.opacity !== "0";
+  return {
+    tag: t.tagName.toLowerCase(),
+    text: s,
+    attributes: o,
+    visible: n,
+    selector: e
+  };
+}
+class ae {
+  constructor() {
+    b(this, "logger", S("browser-runtime"));
+  }
+  getPage() {
+    const e = document.activeElement, s = e && e !== document.body ? I(e, "") : null;
+    return this.logger.debug("getPage", { url: location.href, title: document.title }), {
+      url: location.href,
+      title: document.title,
+      readyState: document.readyState,
+      focusedElement: s
+    };
+  }
+  evalJs(e) {
+    return this.logger.debug("evalJs", { sourceLength: e.length }), new Function(e)();
+  }
+  querySelector(e) {
+    const s = document.querySelector(e);
+    return this.logger.debug("querySelector", { selector: e, found: !!s }), s ? I(s, e) : null;
+  }
+  querySelectorAll(e) {
+    const s = Array.from(document.querySelectorAll(e));
+    return this.logger.debug("querySelectorAll", { selector: e, count: s.length }), s.map((o) => I(o, e));
+  }
+  click(e) {
+    this.logger.debug("click", { selector: e });
+    const s = document.querySelector(e);
+    return s ? (s.click(), { ok: !0 }) : (this.logger.warn("click failed: element not found", { selector: e }), {
+      ok: !1,
+      error: {
+        code: "element_not_found",
+        message: `No element matches: ${e}`
+      }
+    });
+  }
+  type(e, s) {
+    this.logger.debug("type", { selector: e, textLength: s.length });
+    const o = document.querySelector(e);
+    return o ? !(o instanceof HTMLInputElement) && !(o instanceof HTMLTextAreaElement) ? (this.logger.warn("type failed: not an input", { selector: e, tag: o.tagName }), {
+      ok: !1,
+      error: {
+        code: "not_input",
+        message: `Element is not an input or textarea: ${e}`
+      }
+    }) : (o.value = s, o.dispatchEvent(new Event("input", { bubbles: !0 })), { ok: !0 }) : (this.logger.warn("type failed: element not found", { selector: e }), {
+      ok: !1,
+      error: {
+        code: "element_not_found",
+        message: `No element matches: ${e}`
+      }
+    });
+  }
+  getConsole() {
+    const e = [...W];
+    return this.logger.debug("getConsole", { count: e.length }), e;
+  }
+}
+const ie = {
+  type: "object",
+  properties: {},
+  additionalProperties: !1
+}, le = {
+  type: "object",
+  properties: {
+    source: {
+      type: "string",
+      description: "JavaScript source code to evaluate in the page context."
+    }
+  },
+  required: ["source"],
+  additionalProperties: !1
+}, ce = {
+  type: "object",
+  properties: {
+    selector: {
+      type: "string",
+      description: "CSS selector to match elements."
+    },
+    all: {
+      type: "boolean",
+      description: "If true, return all matching elements. Default: false (first match only)."
+    }
+  },
+  required: ["selector"],
+  additionalProperties: !1
+}, ue = {
+  type: "object",
+  properties: {
+    selector: {
+      type: "string",
+      description: "CSS selector of the element to click."
+    }
+  },
+  required: ["selector"],
+  additionalProperties: !1
+}, de = {
+  type: "object",
+  properties: {
+    selector: {
+      type: "string",
+      description: "CSS selector of the input element to type into."
+    },
+    text: {
+      type: "string",
+      description: "Text to type into the element."
+    }
+  },
+  required: ["selector", "text"],
+  additionalProperties: !1
+}, me = {
+  type: "object",
+  properties: {
+    level: {
+      type: "string",
+      description: "Filter by level: 'log', 'warn', 'error', 'info'. Omit for all."
+    },
+    limit: {
+      type: "number",
+      description: "Maximum number of entries to return. Default: 50."
+    }
+  },
+  additionalProperties: !1
+}, pe = {
+  name: "browser_get_page",
+  label: "Get Page",
+  description: "Get the current page state: URL, title, ready state, and focused element summary.",
+  parameters: ie,
+  execution_mode: "parallel"
+}, ge = {
+  name: "browser_eval_js",
+  label: "Eval JS",
+  description: "Evaluate JavaScript in the page context and return the JSON-serializable result. Returns a typed error if the code throws.",
+  parameters: le,
+  execution_mode: "sequential"
+}, fe = {
+  name: "browser_query_selector",
+  label: "Query Selector",
+  description: "Query elements by CSS selector. Returns tag, text preview, attributes, and visibility for each matched element. Use 'all: true' to return all matches.",
+  parameters: ce,
+  execution_mode: "parallel"
+}, he = {
+  name: "browser_click",
+  label: "Click",
+  description: "Click an element by CSS selector.",
+  parameters: ue,
+  execution_mode: "sequential"
+}, _e = {
+  name: "browser_type",
+  label: "Type",
+  description: "Type text into an input element by CSS selector.",
+  parameters: de,
+  execution_mode: "sequential"
+}, ye = {
+  name: "browser_console",
+  label: "Console",
+  description: "Read captured console logs, warnings, and errors from the page. Optionally filter by level and limit count.",
+  parameters: me,
+  execution_mode: "parallel"
+}, N = [
+  pe,
+  ge,
+  fe,
+  he,
+  _e,
+  ye
+], be = '#{ action: "project", text: head(text, 3000) }', xe = '#{ action: "project", text: head(text, 5000) }', we = `let all = lines(text);
+let errs = [];
+for line in all {
+  if contains(line, "ERROR") || contains(line, "FATAL") {
+    errs.push(line);
+  }
+}
+#{ action: "project", text: join(errs, "\\n") }`, Se = {
+  browser_get_page: be,
+  browser_console: we,
+  browser_eval_js: xe
+}, ke = 500;
+function D(t) {
+  return async (e) => {
+    try {
+      return await t(e);
+    } catch (s) {
+      return {
+        content: [{ type: "text", text: s instanceof Error ? s.message : String(s) }]
+      };
+    }
+  };
+}
+function ve(t, e) {
+  return t.length <= e ? { text: t, truncated: !1 } : { text: `${t.slice(0, e)}...`, truncated: !0 };
+}
+function M(t, e, s = !1) {
+  return {
+    content_kind: "generic_text",
+    strategy: {
+      type: "dynamic",
+      script: Se[t] || '#{ action: "project", text: head(text, 2000) }'
+    },
+    original_chars: Array.from(e).length,
+    truncated_by_tool: s
+  };
+}
+function $(t) {
+  const { text: e, truncated: s } = ve(t.text, ke);
+  return {
+    tag: t.tag,
+    text: e,
+    textTruncated: s,
+    attributes: t.attributes,
+    visible: t.visible,
+    selector: t.selector
+  };
+}
+function Re(t, e, s) {
+  let o = t;
+  e && (o = o.filter((i) => i.level === e));
+  const r = s ?? 50, n = o.length > r, a = o.slice(-r);
+  return {
+    entries: a.map((i) => ({
+      level: i.level,
+      args: i.args,
+      timestamp: i.timestamp
+    })),
+    count: a.length,
+    totalAvailable: o.length,
+    truncated: n
+  };
+}
+function T(t, e) {
+  const s = JSON.stringify(t(), null, 2);
+  return {
+    content: [{ type: "text", text: s }],
+    details: M(e, s, !1)
+  };
+}
+function Ae(t, e) {
+  switch (S("browser").info("Executing browser tool", { toolName: t.name }), t.name) {
+    case "browser_get_page": {
+      const o = e.getPage(), r = JSON.stringify(
+        {
+          url: o.url,
+          title: o.title,
+          readyState: o.readyState,
+          focusedElement: o.focusedElement ? $(o.focusedElement) : null
+        },
+        null,
+        2
+      );
+      return {
+        content: [{ type: "text", text: r }],
+        details: M("browser_get_page", r, !1)
+      };
+    }
+    case "browser_eval_js": {
+      const o = k(t.arguments, "source");
+      if (typeof o != "string" || o.length === 0)
+        throw new Error("source must be a non-empty string");
+      return T(() => ({ ok: !0, result: e.evalJs(o) }), "browser_eval_js");
+    }
+    case "browser_query_selector": {
+      const o = k(t.arguments, "selector"), r = re(t.arguments, "all");
+      if (!o)
+        throw new Error("selector is required");
+      return T(() => {
+        if (r) {
+          const a = e.querySelectorAll(o);
+          return {
+            selector: o,
+            matchCount: a.length,
+            elements: a.map($)
+          };
+        }
+        const n = e.querySelector(o);
+        return { selector: o, found: n ? $(n) : null };
+      }, "browser_query_selector");
+    }
+    case "browser_click": {
+      const o = k(t.arguments, "selector");
+      if (!o)
+        throw new Error("selector is required");
+      return T(() => {
+        const r = e.click(o);
+        if (!r.ok)
+          throw new Error(r.error.message);
+        return { ok: !0, action: "click", selector: o };
+      }, "browser_click");
+    }
+    case "browser_type": {
+      const o = k(t.arguments, "selector"), r = k(t.arguments, "text");
+      if (!o)
+        throw new Error("selector is required");
+      if (typeof r != "string")
+        throw new Error("text must be a string");
+      return T(() => {
+        const n = e.type(o, r);
+        if (!n.ok)
+          throw new Error(n.error.message);
+        return {
+          ok: !0,
+          action: "type",
+          selector: o,
+          textLength: r.length
+        };
+      }, "browser_type");
+    }
+    case "browser_console": {
+      const o = k(t.arguments, "level"), r = ne(t.arguments, "limit"), n = e.getConsole(), a = Re(n, o, r), i = JSON.stringify(a, null, 2);
+      return {
+        content: [{ type: "text", text: i }],
+        details: M("browser_console", i, !1)
+      };
+    }
+    default:
+      throw new Error(`no browser tool handler for: ${t.name}`);
+  }
+}
+function ot(t) {
+  const e = S("browser"), s = t ?? new ae();
+  e.info("Browser tools initialized");
+  const o = {};
+  for (const n of N)
+    o[n.name] = (a) => Ae(a, s);
+  return {
+    definitions: N.map((n) => ({
+      name: n.name,
+      description: n.description,
+      inputSchema: n.parameters,
+      run: (a) => {
+        const i = o[n.name];
+        return i ? i({ id: "", name: n.name, arguments: a }) : null;
+      }
+    })),
+    getHandler(n) {
+      const a = o[n];
+      return a ? async (i) => await a({ id: "", name: n, arguments: i }) : null;
+    }
+  };
+}
+const Te = {
+  type: "object",
+  properties: {
+    artifact_id: {
+      type: "string",
+      description: "The artifact id to retrieve (e.g. tool-result-abc123)."
+    }
+  },
+  required: ["artifact_id"],
+  additionalProperties: !1
+}, Ce = 50, Ee = {
+  type: "object",
+  properties: {
+    pattern: {
+      type: "string",
+      description: "Text pattern to search for inside stored artifacts."
+    }
+  },
+  required: ["pattern"],
+  additionalProperties: !1
+}, je = {
+  name: "artifact_read",
+  label: "Read Artifact",
+  description: "Read the full original text of a previously stored artifact by its id. Use this when a projected tool result references an artifact you need to inspect.",
+  parameters: Te,
+  execution_mode: "parallel"
+}, Oe = {
+  name: "artifact_search",
+  label: "Search Artifacts",
+  description: "Search all stored artifacts for a text pattern. Returns up to 50 matching artifact ids, a short snippet around the first match, and the match count. Use artifact_read to retrieve the full text.",
+  parameters: Ee,
+  execution_mode: "parallel"
+}, Ie = [je, Oe];
+function $e(t, e, s) {
+  return {
+    artifact_read: D(async (o) => {
+      const r = k(o.arguments, "artifact_id");
+      if (typeof r != "string" || r.length === 0)
+        throw new Error("artifact_id must be a non-empty string");
+      let n;
+      if (e && s) {
+        const a = s();
+        a ? n = await e.load(a, r) ?? "" : n = "";
+      } else
+        n = "";
+      if (n === "")
+        throw new Error(`artifact not found: ${r}`);
+      return {
+        content: [{ type: "text", text: n }]
+      };
+    }),
+    artifact_search: D(async (o) => {
+      const r = k(o.arguments, "pattern");
+      if (typeof r != "string" || r.length === 0)
+        throw new Error("pattern must be a non-empty string");
+      let n;
+      if (e && s) {
+        const l = s();
+        l ? n = await e.search(l, r) : n = [];
+      } else
+        n = [];
+      const a = n.slice(0, Ce);
+      return {
+        content: [{ type: "text", text: JSON.stringify(
+          a.map((l) => ({
+            id: l.id,
+            snippet: l.snippet,
+            match_count: l.match_count
+          })),
+          null,
+          2
+        ) }]
+      };
+    })
+  };
+}
+class Pe {
+  /**
+   * Build a WASM ToolMap from AgentTools packs.
+   * Artifact tools are wired with the store at build time.
+   */
+  build(e, s, o) {
+    const r = {}, n = /* @__PURE__ */ new Set();
+    for (const i of e)
+      for (const l of i.definitions) {
+        if (n.has(l.name))
+          throw _("tool_duplicate", `Duplicate tool name: ${l.name}`, { recoverable: !1 });
+        n.add(l.name);
+        const c = i.getHandler(l.name);
+        c && (r[l.name] = async (d) => {
+          let u;
+          if (l.inputSchema && z(l.inputSchema)) {
+            const g = l.inputSchema.safeParse(d.arguments);
+            if (!g.success)
+              throw new G("tool_input_invalid", `Invalid input: ${g.error.message}`);
+            u = g.data;
+          } else
+            u = d.arguments;
+          const f = await c(u);
+          if (Me(f))
+            return f;
+          const m = {
+            content: [{ type: "text", text: typeof f == "string" ? f : JSON.stringify(f, null, 2) }]
+          };
+          return l.details && (m.details = l.details(f)), m;
+        });
+      }
+    if (e.some(
+      (i) => i.definitions.some((l) => l.name === "artifact_read" || l.name === "artifact_search")
+    )) {
+      const i = $e(
+        () => 0,
+        s,
+        () => o
+      );
+      for (const [l, c] of Object.entries(i)) {
+        if (n.has(l))
+          throw _("tool_duplicate", `Duplicate tool name: ${l}`, { recoverable: !1 });
+        r[l] = c;
+      }
+    }
+    return r;
+  }
+  /**
+   * Convert AgentToolDefinition[] to WASM ToolDefinition[] for the LLM.
+   * Uses zod-to-json-schema for Zod schemas; passes plain objects through.
+   */
+  getLlmTools(e) {
+    const s = [], o = /* @__PURE__ */ new Set();
+    for (const r of e)
+      for (const n of r.definitions) {
+        if (o.has(n.name))
+          throw _("tool_duplicate", `Duplicate tool name: ${n.name}`, { recoverable: !1 });
+        o.add(n.name);
+        let a;
+        if (z(n.inputSchema)) {
+          const i = te(n.inputSchema, { name: n.name });
+          a = v(i) ? i : { type: "object", properties: {} };
+        } else v(n.inputSchema) ? a = n.inputSchema : a = { type: "object", properties: {} };
+        s.push({
+          name: n.name,
+          label: n.name,
+          description: n.description,
+          parameters: a,
+          execution_mode: "parallel"
+        });
+      }
+    return s;
+  }
+}
+function Me(t) {
+  return typeof t == "object" && t !== null && "content" in t && Array.isArray(t.content);
+}
+function z(t) {
+  var e, s;
+  return typeof t == "object" && t !== null && "_def" in t && typeof t._def == "object" && !!((s = (e = t._def) == null ? void 0 : e.typeName) != null && s.startsWith("Zod"));
+}
+function q(t) {
+  return typeof t == "string" ? t : JSON.stringify(t) ?? "";
+}
+function Le(t) {
+  try {
+    return JSON.parse(t);
+  } catch {
+    return t;
+  }
+}
+function L(t) {
+  switch (t) {
+    case "tool_call":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "error":
+      return "error";
+    default:
+      return "end_turn";
+  }
+}
+function Ne(t, e, s) {
+  let o = "";
+  const r = /* @__PURE__ */ new Map();
+  let n = "end", a, i, l, c;
+  const d = new Promise((p) => {
+    c = p;
+  }), u = {
+    [Symbol.asyncIterator]: async function* () {
+      try {
+        for await (const p of t) {
+          if (e.aborted) return;
+          switch (p.type) {
+            case "start": {
+              yield { kind: "start", ...p.payload };
+              break;
+            }
+            case "text_delta": {
+              const m = p.payload;
+              o += m, yield { kind: "text_delta", text: m };
+              break;
+            }
+            case "tool_call_delta": {
+              const m = p.payload, h = r.get(m.id), g = q(m.arguments ?? m.delta ?? "");
+              r.set(m.id, {
+                id: m.id,
+                name: m.name || (h == null ? void 0 : h.name) || "",
+                arguments: ((h == null ? void 0 : h.arguments) ?? "") + g
+              }), yield {
+                kind: "tool_call_delta",
+                tool_call_id: m.id,
+                delta: { type: "string", value: g }
+              };
+              break;
+            }
+            case "done": {
+              const m = p.payload;
+              a = m.model, i = m.usage, m.usage && (s.usage = m.usage), n = m.stopReason;
+              for (const h of m.content)
+                h.type === "tool_call" && r.set(h.id, {
+                  id: h.id,
+                  name: h.name,
+                  arguments: q(h.arguments)
+                });
+              break;
+            }
+          }
+        }
+      } catch (p) {
+        l = p;
+      } finally {
+        c();
+      }
+    }
+  }, f = (async () => {
+    if (await d, l)
+      return {
+        Err: {
+          error: {
+            code: "stream_error",
+            message: l instanceof Error ? l.message : String(l)
+          },
+          aborted: !1
+        }
+      };
+    const p = [];
+    o && p.push({ type: "text", text: o });
+    for (const m of r.values())
+      p.push({
+        type: "tool_call",
+        id: m.id,
+        name: m.name,
+        arguments: Le(m.arguments)
+      });
+    return {
+      Ok: {
+        content: p,
+        api: "sdk",
+        provider: "sdk",
+        model: a ?? "sdk-model",
+        stop_reason: L(n),
+        error_message: L(n) === "error" ? "Model returned an error stop reason" : void 0,
+        timestamp: Date.now(),
+        usage: {
+          input: (i == null ? void 0 : i.input) ?? 0,
+          output: (i == null ? void 0 : i.output) ?? 0,
+          cache_read: (i == null ? void 0 : i.cache_read) ?? 0,
+          cache_write: (i == null ? void 0 : i.cache_write) ?? 0,
+          total_tokens: (i == null ? void 0 : i.total_tokens) ?? 0
+        }
+      }
+    };
+  })();
+  return { chunks: u, result: f };
+}
+function De(t, e) {
+  var r, n, a, i, l;
+  const s = {
+    [Symbol.asyncIterator]: async function* () {
+      var c, d, u, f, p;
+      if (!e.aborted) {
+        yield {
+          kind: "start",
+          content: [{ type: "text", text: "" }],
+          api: "sdk",
+          provider: "sdk",
+          model: t.model ?? "sdk-model",
+          stop_reason: "end_turn",
+          error_message: void 0,
+          timestamp: Date.now(),
+          usage: {
+            input: ((c = t.usage) == null ? void 0 : c.input) ?? 0,
+            output: ((d = t.usage) == null ? void 0 : d.output) ?? 0,
+            cache_read: ((u = t.usage) == null ? void 0 : u.cache_read) ?? 0,
+            cache_write: ((f = t.usage) == null ? void 0 : f.cache_write) ?? 0,
+            total_tokens: ((p = t.usage) == null ? void 0 : p.total_tokens) ?? 0
+          }
+        };
+        for (const m of t.content) {
+          if (e.aborted) return;
+          if (m.type === "text" && m.text) {
+            const h = m.text.split(/(\s+)/);
+            for (const g of h) {
+              if (e.aborted) return;
+              g && (yield { kind: "text_delta", text: g }, await new Promise((y) => setTimeout(y, 10)));
+            }
+          }
+        }
+      }
+    }
+  }, o = Promise.resolve({
+    Ok: {
+      content: t.content.map((c) => c.type === "text" ? { type: "text", text: c.text } : c.type === "tool_call" ? { type: "tool_call", id: c.id, name: c.name, arguments: c.arguments } : { type: "text", text: "" }),
+      api: "sdk",
+      provider: "sdk",
+      model: t.model ?? "sdk-model",
+      stop_reason: L(t.stopReason),
+      error_message: t.stopReason === "error" ? "Model returned an error stop reason" : void 0,
+      timestamp: Date.now(),
+      usage: {
+        input: ((r = t.usage) == null ? void 0 : r.input) ?? 0,
+        output: ((n = t.usage) == null ? void 0 : n.output) ?? 0,
+        cache_read: ((a = t.usage) == null ? void 0 : a.cache_read) ?? 0,
+        cache_write: ((i = t.usage) == null ? void 0 : i.cache_write) ?? 0,
+        total_tokens: ((l = t.usage) == null ? void 0 : l.total_tokens) ?? 0
+      }
+    }
+  });
+  return { chunks: s, result: o };
+}
+async function ze(t, e, s) {
+  const o = {
+    instructions: "Summarize the following conversation context concisely. Preserve key facts, decisions, and action items. Omit redundant details.",
+    messages: P(e),
+    tools: [],
+    signal: s
+  };
+  return (await t.generate(o)).content.filter((a) => a.type === "text").map((a) => a.text).join(`
+`) || "[Context summarized]";
+}
+async function qe(t, e) {
+  const s = t.logger ?? S("engine");
+  let o;
+  if (t.store) {
+    const r = await t.store.loadSession(t.sessionId);
+    r && (o = new J().deserialize(r), o ? s.info("Session snapshot loaded", { sessionId: t.sessionId }) : s.warn("Session snapshot version mismatch, starting fresh", { sessionId: t.sessionId }));
+  }
+  return F(t, o);
+}
+function Be(t) {
+  t.destroy();
+}
+async function Je(t, e, s, o, r, n) {
+  const a = e.logger ?? S("engine"), i = K(s), l = new oe(), c = l.createRunState(), d = new Pe(), u = Q(e.tools), f = X(e), p = d.build(u, f, e.sessionId), m = d.getLlmTools(u);
+  a.info("Running agent turn", {
+    sessionId: e.sessionId,
+    toolCount: m.length,
+    messageLength: typeof s == "string" ? s.length : s.text.length
+  });
+  const h = {
+    call: async (g, y) => {
+      const x = y || r;
+      n.onStatus({ state: "calling_model", message: "Calling model..." }), a.info("Calling model", { model: e.model.id ?? "custom" });
+      const w = {
+        instructions: g.system_prompt,
+        messages: P(g.messages),
+        tools: m.map((j) => ({
+          name: j.name,
+          description: j.description,
+          inputSchema: j.parameters,
+          run: () => null
+        })),
+        signal: x,
+        metadata: ee(s, o == null ? void 0 : o.metadata)
+      };
+      if (e.model.generateStream)
+        return a.debug("Using streaming model"), Ne(
+          e.model.generateStream(w, x),
+          x,
+          c
+        );
+      a.debug("Using non-streaming model");
+      const R = await e.model.generate(w);
+      return R.usage && (c.usage = R.usage, a.info("Model usage", { usage: R.usage })), De(R, x);
+    },
+    summarize: e.model.summarize ? async (g, y) => {
+      var w, R;
+      a.info("Calling model summarizer");
+      const x = P(g);
+      return (R = (w = e.model).summarize) == null ? void 0 : R.call(w, x, y);
+    } : async (g, y) => (a.info("Using default summarizer"), ze(e.model, g, y))
+  };
+  try {
+    const g = await V(t, i, {
+      llm: h,
+      tools: p,
+      llmTools: m,
+      logger: a,
+      onEvent: (y) => {
+        const x = l.map(y, c);
+        for (const w of x)
+          n.onEvent(w);
+      },
+      onMarkers: (y) => {
+        const x = l.processMarkers(y, c);
+        for (const w of x)
+          n.onEvent(w);
+      },
+      onPersist: async (y) => {
+        if (n.onStatus({ state: "saving", message: "Saving session..." }), a.info("Persisting session", { sessionId: e.sessionId }), e.store) {
+          const w = new J().serialize(y);
+          await e.store.saveSession(e.sessionId, w), a.info("Session saved", { sessionId: e.sessionId });
+        }
+        n.onStatus({ state: "completed" });
+      },
+      artifactStore: f,
+      prepareToolCalls: e.prepareToolCalls,
+      signal: r
+    });
+    return g.aborted ? (a.info("Turn aborted"), n.onStatus({ state: "aborted", message: "Stopped by user" })) : a.info("Turn completed", { status: "completed" }), l.buildRunResult(c, g);
+  } catch (g) {
+    throw a.error("Turn failed", { error: g instanceof Error ? g.message : String(g) }), g;
+  }
+}
+async function We(t, e) {
+  const s = typeof e == "string" ? e : e.text;
+  t.steer({
+    role: "user",
+    content: [{ type: "text", text: s }],
+    timestamp: Date.now()
+  });
+}
+async function Ue(t) {
+  Y(Z(t.handle));
+}
+class nt {
+  constructor(e) {
+    b(this, "config");
+    b(this, "emitter");
+    b(this, "status", { state: "idle" });
+    b(this, "currentRun", null);
+    b(this, "currentAbortController", null);
+    b(this, "disposed", !1);
+    b(this, "engineAgent", null);
+    b(this, "logger");
+    this.config = e, this.emitter = new se(), this.logger = e.logger ?? S("agent");
+  }
+  on(e, s) {
+    return this.disposed ? () => {
+    } : this.emitter.on(e, s);
+  }
+  async run(e, s) {
+    if (this.disposed) {
+      this.logger.warn("Run called on disposed agent");
+      const n = _("agent_disposed", "Agent has been disposed", { recoverable: !1 }), a = {
+        status: "failed",
+        text: "",
+        toolCalls: [],
+        artifacts: [],
+        error: n
+      };
+      return this.emitter.emit("error", n), this.emitter.emit("status", { state: "failed", message: n.message }), this.emitter.emit("done", a), a;
+    }
+    if (this.currentRun) {
+      this.logger.warn("Run called while agent is busy");
+      const n = _("agent_busy", "Agent is already running a turn", { recoverable: !0 }), a = {
+        status: "failed",
+        text: "",
+        toolCalls: [],
+        artifacts: [],
+        error: n
+      };
+      return this.emitter.emit("error", n), this.emitter.emit("status", { state: "failed", message: n.message }), this.emitter.emit("done", a), a;
+    }
+    const o = new AbortController();
+    this.currentAbortController = o, this.logger.info("Starting run", { sessionId: this.config.sessionId }), s != null && s.signal && (s.signal.aborted ? o.abort(s.signal.reason) : s.signal.addEventListener(
+      "abort",
+      () => {
+        var n;
+        o.abort((n = s.signal) == null ? void 0 : n.reason);
+      },
+      { once: !0 }
+    ));
+    const r = this._doRun(e, s, o.signal);
+    this.currentRun = r;
+    try {
+      const n = await r;
+      return this.logger.info("Run completed", { status: n.status }), this.emitter.emit("done", n), n;
+    } catch (n) {
+      this.logger.error("Run failed", { error: n instanceof Error ? n.message : String(n) });
+      const a = _("internal_error", n instanceof Error ? n.message : String(n), {
+        cause: n,
+        recoverable: !1
+      }), i = {
+        status: "failed",
+        text: "",
+        toolCalls: [],
+        artifacts: [],
+        error: a
+      };
+      return this.emitter.emit("error", a), this.emitter.emit("status", { state: "failed", message: a.message }), this.emitter.emit("done", i), i;
+    } finally {
+      this.currentRun = null, this.currentAbortController = null;
+    }
+  }
+  async _doRun(e, s, o) {
+    this.engineAgent || (this.engineAgent = await qe(this.config));
+    try {
+      return await Je(this.engineAgent, this.config, e, s, o, {
+        onEvent: (r) => this.emitter.emit(r.type, r.payload),
+        onStatus: (r) => {
+          this.status = r, this.emitter.emit("status", r);
+        }
+      });
+    } catch (r) {
+      if (o.aborted || r instanceof Error && r.name === "AbortError" || r instanceof Error && r.message.includes("user_aborted")) {
+        const c = {
+          status: "aborted",
+          text: "",
+          toolCalls: [],
+          artifacts: []
+        };
+        return this.emitter.emit("status", {
+          state: "aborted",
+          message: "Stopped by user"
+        }), c;
+      }
+      const a = r instanceof Error && "code" in r && typeof r.code == "string" ? r.code : "internal_error", i = _(a, r instanceof Error ? r.message : String(r), {
+        cause: r,
+        recoverable: !1
+      }), l = {
+        status: "failed",
+        text: "",
+        toolCalls: [],
+        artifacts: [],
+        error: i
+      };
+      return this.emitter.emit("error", i), this.emitter.emit("status", { state: "failed", message: i.message }), l;
+    }
+  }
+  stop(e) {
+    this.disposed || !this.currentAbortController || (this.logger.info("Stopping agent", { reason: e ?? "user-requested" }), this.currentAbortController.abort(e ?? "user-requested"));
+  }
+  async steer(e) {
+    if (this.disposed)
+      throw this.logger.warn("Steer called on disposed agent"), _("agent_disposed", "Agent has been disposed", { recoverable: !1 });
+    if (!this.engineAgent)
+      throw this.logger.warn("Steer called on uninitialized agent"), _("agent_not_initialized", "Agent has not been run yet", { recoverable: !0 });
+    return this.logger.info("Steering agent", { sessionId: this.config.sessionId }), We(this.engineAgent, e);
+  }
+  async reset() {
+    if (this.disposed)
+      throw this.logger.warn("Reset called on disposed agent"), _("agent_disposed", "Agent has been disposed", { recoverable: !1 });
+    this.logger.info("Resetting agent", { sessionId: this.config.sessionId }), this.engineAgent && (await Ue(this.engineAgent), this.engineAgent = null), this.currentRun = null, this.currentAbortController = null, this.status = { state: "idle" }, this.emitter.emit("status", this.status);
+  }
+  dispose() {
+    this.disposed || (this.logger.info("Disposing agent", { sessionId: this.config.sessionId }), this.disposed = !0, this.currentAbortController && (this.currentAbortController.abort("disposed"), this.currentAbortController = null), this.engineAgent && (Be(this.engineAgent), this.engineAgent = null), this.emitter.clear(), this.currentRun = null);
+  }
+  getStatus() {
+    return this.status;
+  }
+}
+function He(t) {
+  const e = [];
+  let s = 0;
+  for (; s < t.length; ) {
+    const o = t[s];
+    switch (o.role) {
+      case "user": {
+        const r = B(o.content);
+        e.push({ role: "user", content: r }), s++;
+        break;
+      }
+      case "assistant": {
+        const r = [];
+        for (const n of o.content)
+          n.type === "text" && n.text !== void 0 ? r.push({ type: "text", text: n.text }) : n.type === "tool_call" && n.id && n.name && r.push({
+            type: "tool_use",
+            id: n.id,
+            name: n.name,
+            input: n.arguments ?? {}
+          });
+        e.push({ role: "assistant", content: r }), s++;
+        break;
+      }
+      case "tool_result": {
+        const r = [];
+        for (; s < t.length && t[s].role === "tool_result"; ) {
+          const n = t[s], a = B(n.content);
+          r.push({
+            type: "tool_result",
+            tool_use_id: n.tool_call_id,
+            content: a,
+            is_error: n.is_error
+          }), s++;
+        }
+        e.push({ role: "user", content: r });
+        break;
+      }
+    }
+  }
+  return e;
+}
+function Ge(t) {
+  return t.map((e) => ({
+    name: e.name,
+    description: `${e.label}: ${e.description}`,
+    input_schema: e.parameters
+  }));
+}
+function Fe(t, e, s) {
+  const o = [];
+  for (const l of t.content)
+    l.type === "text" ? o.push({ type: "text", text: l.text }) : l.type === "tool_use" && o.push({
+      type: "tool_call",
+      id: l.id,
+      name: l.name,
+      arguments: l.input
+    });
+  const r = t.stop_reason === "tool_use" ? "tool_use" : "end_turn", n = {
+    input: t.usage.input_tokens,
+    output: t.usage.output_tokens,
+    cache_read: t.usage.cache_read_input_tokens ?? 0,
+    cache_write: t.usage.cache_creation_input_tokens ?? 0,
+    total_tokens: t.usage.input_tokens + t.usage.output_tokens
+  }, a = {
+    content: o,
+    api: e,
+    provider: e,
+    model: s,
+    stop_reason: r,
+    error_message: null,
+    timestamp: Date.now(),
+    usage: n
+  }, i = [];
+  i.push({
+    kind: "start",
+    content: [{ type: "text", text: "" }],
+    api: e,
+    provider: e,
+    model: s,
+    stop_reason: r,
+    error_message: null,
+    timestamp: 0,
+    usage: {
+      input: 0,
+      output: 0,
+      cache_read: 0,
+      cache_write: 0,
+      total_tokens: 0
+    }
+  });
+  for (const l of t.content)
+    l.type === "text" && l.text.length > 0 && i.push({ kind: "text_delta", text: l.text });
+  return {
+    llmResult: { Ok: a },
+    chunks: i
+  };
+}
+async function Ke(t, e) {
+  var c;
+  const s = [], o = "anthropic", r = {
+    model: e.model,
+    max_tokens: e.maxTokens ?? 4096,
+    system: t.system_prompt,
+    messages: He(t.messages),
+    tools: Ge(t.tools)
+  };
+  s.push(`anthropic_request: model=${e.model}, messages=${r.messages.length}, tools=${r.tools.length}`);
+  let n;
+  try {
+    n = await fetch(`${e.baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": e.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify(r)
+    });
+  } catch (d) {
+    const u = d instanceof Error ? d.message : String(d);
+    return s.push(`anthropic_network_error: ${u}`), {
+      llmResult: {
+        Err: { error: { code: "network_error", message: u }, aborted: !1 }
+      },
+      chunks: [],
+      log: s
+    };
+  }
+  if (!n.ok) {
+    let d = null;
+    try {
+      d = await n.json();
+    } catch {
+    }
+    const u = `http_${n.status}`, f = ((c = d == null ? void 0 : d.error) == null ? void 0 : c.message) ?? `HTTP ${n.status}: ${n.statusText}`;
+    return s.push(`anthropic_error: ${u} - ${f}`), {
+      llmResult: {
+        Err: { error: { code: u, message: f }, aborted: !1 }
+      },
+      chunks: [],
+      log: s
+    };
+  }
+  const a = await n.json();
+  s.push(`anthropic_response: stop_reason=${a.stop_reason}, content_blocks=${a.content.length}`);
+  const { llmResult: i, chunks: l } = Fe(a, o, e.model);
+  return { llmResult: i, chunks: l, log: s };
+}
+function rt(t) {
+  const e = S("anthropic"), s = {
+    apiKey: t.apiKey,
+    baseUrl: t.baseUrl ?? "https://api.anthropic.com",
+    model: t.model,
+    maxTokens: t.maxTokens
+  };
+  return {
+    id: t.model,
+    contextWindow: 2e5,
+    maxTokens: t.maxTokens ?? 4096,
+    capabilities: {
+      vision: t.model.includes("vision") || t.model.startsWith("claude-3-5"),
+      jsonMode: !0,
+      functionCalling: !0,
+      streaming: !0
+    },
+    async generate(o) {
+      e.info("Anthropic generate", { model: t.model, messageCount: o.messages.length });
+      const r = {
+        system_prompt: o.instructions,
+        messages: o.messages.map((n) => {
+          var l, c, d;
+          const a = n.content.map((u) => u.type === "text" ? { type: "text", text: u.text } : u.type === "tool_call" ? { type: "tool_call", id: u.id, name: u.name, arguments: v(u.arguments) ? u.arguments : {} } : u.type === "image" ? { type: "image", media_type: u.mimeType, data: u.data } : { type: "text", text: "" }), i = n.timestamp ?? Date.now();
+          return n.role === "user" ? { role: "user", content: a, timestamp: i } : n.role === "assistant" ? {
+            role: "assistant",
+            content: a,
+            api: "sdk",
+            provider: "sdk",
+            model: ((l = o.tools[0]) == null ? void 0 : l.name) ?? "sdk-model",
+            stop_reason: "end_turn",
+            error_message: null,
+            timestamp: i,
+            usage: { input: 0, output: 0, cache_read: 0, cache_write: 0, total_tokens: 0 }
+          } : {
+            role: "tool_result",
+            tool_call_id: n.tool_call_id ?? "",
+            tool_name: ((d = (c = n.content.find((u) => u.type === "text")) == null ? void 0 : c.text) == null ? void 0 : d.slice(0, 50)) ?? "unknown",
+            content: a,
+            details: {},
+            is_error: !1,
+            timestamp: i
+          };
+        }),
+        tools: o.tools.map((n) => ({
+          name: n.name,
+          label: n.name,
+          description: n.description,
+          parameters: v(n.inputSchema) ? n.inputSchema : { type: "object", properties: {} },
+          execution_mode: "parallel"
+        }))
+      };
+      try {
+        const n = await Ke(r, s);
+        if ("Err" in n.llmResult) {
+          const i = n.llmResult.Err.error;
+          throw e.warn("Anthropic API error", { code: i.code, message: i.message }), _(
+            i.code === "network_error" ? "model_unavailable" : i.code.startsWith("http_401") ? "model_auth_failed" : i.code.startsWith("http_429") ? "model_rate_limited" : "model_unavailable",
+            i.message,
+            { recoverable: i.code === "http_429" }
+          );
+        }
+        const a = n.llmResult.Ok;
+        return e.info("Anthropic response", { stopReason: a.stop_reason, contentBlocks: a.content.length }), {
+          content: a.content.map((i) => i.type === "text" ? { type: "text", text: i.text ?? "" } : i.type === "tool_call" ? { type: "tool_call", id: i.id ?? "", name: i.name ?? "", arguments: i.arguments ?? {} } : { type: "text", text: "" }),
+          stopReason: a.stop_reason === "tool_use" ? "tool_call" : "end",
+          usage: a.usage,
+          model: t.model,
+          raw: n
+        };
+      } catch (n) {
+        throw n && typeof n == "object" && "code" in n ? n : (e.error("Anthropic request failed", { error: n instanceof Error ? n.message : String(n) }), _("model_unavailable", n instanceof Error ? n.message : String(n), {
+          cause: n,
+          recoverable: !1
+        }));
+      }
+    }
+  };
+}
+function B(t) {
+  return t.filter((e) => e.type === "text" && e.text !== void 0).map((e) => e.text).join(`
+`);
+}
+function Qe(t) {
+  const e = S("openai");
+  return {
+    id: t.model,
+    contextWindow: 128e3,
+    maxTokens: t.maxTokens ?? 4096,
+    capabilities: {
+      vision: t.model.includes("vision") || t.model.includes("gpt-4o"),
+      jsonMode: !0,
+      functionCalling: !0,
+      streaming: !0
+    },
+    async generate(s) {
+      var a, i;
+      e.info("OpenAI generate", { model: t.model, messageCount: s.messages.length });
+      const o = s.messages.map((l) => {
+        switch (l.role) {
+          case "user":
+            return { role: "user", content: l.content.filter((d) => d.type === "text").map((d) => d.text).join(`
+`) };
+          case "assistant": {
+            const c = l.content.filter((u) => u.type === "text").map((u) => u.text).join(""), d = l.content.filter(
+              (u) => u.type === "tool_call"
+            ).map((u) => ({
+              id: u.id,
+              type: "function",
+              function: {
+                name: u.name,
+                arguments: JSON.stringify(u.arguments)
+              }
+            }));
+            return {
+              role: "assistant",
+              content: c || null,
+              tool_calls: d.length > 0 ? d : void 0
+            };
+          }
+          case "tool_result": {
+            const c = l.content.filter((d) => d.type === "text").map((d) => d.text).join(`
+`);
+            return {
+              role: "tool",
+              tool_call_id: l.tool_call_id ?? "",
+              content: c
+            };
+          }
+          default:
+            return { role: "user", content: "" };
+        }
+      }), r = s.tools.map((l) => ({
+        type: "function",
+        function: {
+          name: l.name,
+          description: l.description,
+          parameters: v(l.inputSchema) ? l.inputSchema : { type: "object", properties: {} }
+        }
+      })), n = {
+        model: t.model,
+        messages: o,
+        tools: r.length > 0 ? r : void 0,
+        max_tokens: t.maxTokens
+      };
+      try {
+        const l = await fetch(`${t.baseUrl.replace(/\/+$/, "")}/v1/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${t.apiKey}`
+          },
+          body: JSON.stringify(n),
+          signal: s.signal
+        });
+        if (!l.ok) {
+          const p = l.status, m = await l.text();
+          throw e.warn("OpenAI API error", { status: p, body: m.slice(0, 500) }), _(
+            p === 401 ? "model_auth_failed" : p === 429 ? "model_rate_limited" : "model_unavailable",
+            `HTTP ${p}: ${m}`,
+            { recoverable: p === 429 }
+          );
+        }
+        const c = await l.json(), d = (a = c.choices) == null ? void 0 : a[0], u = d == null ? void 0 : d.message;
+        e.info("OpenAI response", { finishReason: d == null ? void 0 : d.finish_reason, model: c.model });
+        const f = [];
+        if (u != null && u.content && typeof u.content == "string" && f.push({ type: "text", text: u.content }), u != null && u.tool_calls && Array.isArray(u.tool_calls))
+          for (const p of u.tool_calls)
+            p.type === "function" && f.push({
+              type: "tool_call",
+              id: p.id ?? "",
+              name: ((i = p.function) == null ? void 0 : i.name) ?? "",
+              arguments: (() => {
+                var m;
+                try {
+                  return JSON.parse(((m = p.function) == null ? void 0 : m.arguments) ?? "{}");
+                } catch {
+                  return {};
+                }
+              })()
+            });
+        return {
+          content: f,
+          stopReason: (d == null ? void 0 : d.finish_reason) === "tool_calls" ? "tool_call" : (d == null ? void 0 : d.finish_reason) === "stop" ? "end" : (d == null ? void 0 : d.finish_reason) === "length" ? "length" : "error",
+          usage: c.usage ? {
+            input: c.usage.prompt_tokens,
+            output: c.usage.completion_tokens,
+            cache_read: 0,
+            cache_write: 0,
+            total_tokens: c.usage.total_tokens
+          } : void 0,
+          model: t.model,
+          raw: c
+        };
+      } catch (l) {
+        throw l && typeof l == "object" && "code" in l ? l : (e.error("OpenAI request failed", { error: l instanceof Error ? l.message : String(l) }), _("model_unavailable", l instanceof Error ? l.message : String(l), {
+          cause: l,
+          recoverable: !1
+        }));
+      }
+    }
+  };
+}
+function at(t) {
+  return Qe({
+    apiKey: t.apiKey,
+    baseUrl: "https://api.openai.com",
+    model: t.model,
+    maxTokens: t.maxTokens
+  });
+}
+function it() {
+  return {
+    definitions: Ie.map((e) => ({
+      name: e.name,
+      description: e.description,
+      inputSchema: e.parameters,
+      run: () => {
+        throw new Error("artifactTools handlers are wired at build time by ToolRegistryBuilder");
+      }
+    })),
+    getHandler() {
+      return null;
+    }
+  };
+}
+function lt(t) {
+  var e, s, o, r;
+  return {
+    id: t.id ?? "custom-model",
+    contextWindow: t.contextWindow ?? 1e5,
+    maxTokens: t.maxTokens ?? 4096,
+    capabilities: {
+      vision: ((e = t.capabilities) == null ? void 0 : e.vision) ?? !1,
+      jsonMode: ((s = t.capabilities) == null ? void 0 : s.jsonMode) ?? !0,
+      functionCalling: ((o = t.capabilities) == null ? void 0 : o.functionCalling) ?? !0,
+      streaming: ((r = t.capabilities) == null ? void 0 : r.streaming) ?? !0
+    },
+    generate: t.generate,
+    generateStream: t.generateStream,
+    summarize: t.summarize
+  };
+}
+const Xe = "pi-oxide-browser-agent", Ve = 3, A = "sessions";
+class Ye {
+  constructor() {
+    b(this, "dbPromise");
+    this.dbPromise = this.openDB();
+  }
+  openDB() {
+    return new Promise((e, s) => {
+      const o = indexedDB.open(Xe, Ve);
+      o.onupgradeneeded = () => {
+        const r = o.result;
+        r.objectStoreNames.contains("session") && r.deleteObjectStore("session"), r.objectStoreNames.contains("artifacts") && r.deleteObjectStore("artifacts"), r.objectStoreNames.contains(A) || r.createObjectStore(A, { keyPath: "sessionId" });
+      }, o.onsuccess = () => e(o.result), o.onerror = () => s(o.error);
+    });
+  }
+  async save(e, s) {
+    const o = await this.dbPromise;
+    return new Promise((r, n) => {
+      const a = o.transaction(A, "readwrite");
+      a.objectStore(A).put({
+        sessionId: e,
+        state: s,
+        updatedAt: Date.now()
+      }), a.oncomplete = () => r(), a.onerror = () => n(a.error);
+    });
+  }
+  async load(e) {
+    const s = await this.dbPromise;
+    return new Promise((o, r) => {
+      const a = s.transaction(A, "readonly").objectStore(A).get(e);
+      a.onsuccess = () => {
+        const i = a.result;
+        o((i == null ? void 0 : i.state) ?? null);
+      }, a.onerror = () => r(a.error);
+    });
+  }
+}
+function Ze() {
+  const t = new Ye();
+  return {
+    async loadSession(e) {
+      const s = await t.load(e);
+      return s ? { version: 1, data: s } : null;
+    },
+    async saveSession(e, s) {
+      await t.save(e, s.data);
+    }
+    // Artifact methods are not supported by the raw IndexedDBSessionBackend.
+    // If artifact support is needed, use a store that implements them.
+  };
+}
+function ct() {
+  return Ze();
+}
+function ut() {
+  const t = /* @__PURE__ */ new Map();
+  return {
+    async loadSession(e) {
+      return t.get(e) ?? null;
+    },
+    async saveSession(e, s) {
+      t.set(e, s);
+    }
+  };
+}
+function dt() {
+  return {
+    async loadSession(t) {
+      const e = localStorage.getItem(`pi-oxide-session-${t}`);
+      return e ? JSON.parse(e) : null;
+    },
+    async saveSession(t, e) {
+      localStorage.setItem(`pi-oxide-session-${t}`, JSON.stringify(e));
+    }
+  };
+}
+function mt(t) {
+  const e = t.baseUrl.replace(/\/+$/, "");
+  return {
+    async loadSession(s) {
+      const o = await fetch(`${e}/sessions/${s}`);
+      return o.ok ? o.json() : null;
+    },
+    async saveSession(s, o) {
+      await fetch(`${e}/sessions/${s}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(o)
+      });
+    }
+  };
+}
+function pt(t) {
+  return {
+    name: "",
+    description: t.description,
+    inputSchema: t.input,
+    run: t.run,
+    details: t.details ? t.details : void 0
+  };
+}
+function gt(t) {
+  const e = Object.entries(t).map(([s, o]) => ({
+    ...o,
+    name: s
+  }));
+  return {
+    definitions: e,
+    getHandler(s) {
+      const o = e.find((r) => r.name === s);
+      return (o == null ? void 0 : o.run) ?? null;
+    }
+  };
+}
+export {
+  nt as Agent,
+  _t as CallbackLogger,
+  yt as ConsoleLogger,
+  G as HostError,
+  bt as NoopLogger,
+  rt as anthropic,
+  it as artifactTools,
+  ot as browserTools,
+  xt as clearLoggers,
+  _ as createAgentError,
+  lt as defineModel,
+  gt as defineTools,
+  wt as ensureInit,
+  St as getGlobalLogLevel,
+  S as getLogger,
+  mt as httpStore,
+  ct as indexedDbStore,
+  dt as localStorageStore,
+  ut as memoryStore,
+  at as openai,
+  Qe as openaiCompatible,
+  kt as setGlobalLogLevel,
+  vt as setLogger,
+  pt as tool,
+  Rt as toolResult,
+  Y as unwrap
+};