@useago/sdk 1.5.0 → 1.5.2

package/dist/AgoClient-DXrH2AMi.js

@@ -0,0 +1,964 @@
+var m = class extends Error {
+  constructor(t, e, s) {
+    super(t), this.code = e, this.statusCode = s, this.name = "AgoError";
+  }
+}, p = class x extends m {
+  constructor(e, s, i, n, o, a) {
+    super(e, s, i), this.type = n, this.param = o, this.docUrl = a, this.name = "AgoApiError";
+  }
+  static fromResponse(e, s) {
+    const i = e.error;
+    return new x(i.doc_url ? `${i.message} See ${i.doc_url}` : i.message, i.code, s, i.type, i.param, i.doc_url);
+  }
+}, v = class extends m {
+  constructor(t, e) {
+    super(t, "network_error"), this.originalError = e, this.name = "AgoNetworkError";
+  }
+}, _ = class extends m {
+  constructor(t, e = "stream_error") {
+    super(t, e), this.name = "AgoStreamError";
+  }
+}, E = class extends m {
+  constructor(t, e, s) {
+    super(t, "function_error"), this.functionName = e, this.originalError = s, this.name = "AgoFunctionError";
+  }
+}, F = class {
+  constructor(t = !1) {
+    this.enabled = t;
+  }
+  enable() {
+    this.enabled = !0;
+  }
+  disable() {
+    this.enabled = !1;
+  }
+  log(...t) {
+    this.enabled && console.log("[AGO SDK]", ...t);
+  }
+  warn(...t) {
+    this.enabled && console.warn("[AGO SDK]", ...t);
+  }
+  error(...t) {
+    console.error("[AGO SDK]", ...t);
+  }
+  debug(...t) {
+    this.enabled && console.debug("[AGO SDK]", ...t);
+  }
+}, c = new F(), R = "ago_widget_id";
+function I() {
+  if (typeof localStorage < "u") {
+    const e = localStorage.getItem(R);
+    if (e) return e;
+  }
+  const t = typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : `ago-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
+  if (typeof localStorage < "u") try {
+    localStorage.setItem(R, t);
+  } catch {
+  }
+  return t;
+}
+var U = class {
+  constructor(t) {
+    this.baseUrl = t.baseUrl.replace(/\/$/, ""), this.headers = { "X-User-Anon-Id": t.widgetId || I() }, t.userEmail && (this.headers["X-User-Email"] = t.userEmail), t.userJwt && (this.headers.Authorization = `Bearer ${t.userJwt}`), t.permission && (this.headers["X-Widget-Permission"] = t.permission);
+  }
+  updateConfig(t) {
+    t.baseUrl && (this.baseUrl = t.baseUrl.replace(/\/$/, "")), t.widgetId && (this.headers["X-User-Anon-Id"] = t.widgetId), t.userEmail && (this.headers["X-User-Email"] = t.userEmail), t.userJwt && (this.headers.Authorization = `Bearer ${t.userJwt}`), t.permission !== void 0 && (t.permission ? this.headers["X-Widget-Permission"] = t.permission : delete this.headers["X-Widget-Permission"]);
+  }
+  async get(t) {
+    return this.request("GET", t);
+  }
+  async post(t, e) {
+    return this.request("POST", t, e);
+  }
+  async postStream(t, e) {
+    const s = `${this.baseUrl}${t}`;
+    c.debug("POST (stream)", s, e);
+    try {
+      const i = await fetch(s, {
+        method: "POST",
+        headers: {
+          ...this.headers,
+          "Content-Type": "application/json"
+        },
+        body: e ? JSON.stringify(e) : void 0
+      });
+      return i.ok || await this.handleErrorResponse(i), i;
+    } catch (i) {
+      throw i instanceof p ? i : new v(`Network error: ${i instanceof Error ? i.message : "Unknown error"}. Check that \`baseUrl\` is reachable and includes the protocol (https://).`, i instanceof Error ? i : void 0);
+    }
+  }
+  async postFormData(t, e) {
+    const s = `${this.baseUrl}${t}`;
+    c.debug("POST (formData)", s);
+    const i = { ...this.headers };
+    try {
+      const n = await fetch(s, {
+        method: "POST",
+        headers: i,
+        body: e
+      });
+      return n.ok || await this.handleErrorResponse(n), n;
+    } catch (n) {
+      throw n instanceof p ? n : new v(`Network error: ${n instanceof Error ? n.message : "Unknown error"}. Check that \`baseUrl\` is reachable and includes the protocol (https://).`, n instanceof Error ? n : void 0);
+    }
+  }
+  async request(t, e, s) {
+    const i = `${this.baseUrl}${e}`;
+    c.debug(t, i, s);
+    try {
+      const n = await fetch(i, {
+        method: t,
+        headers: {
+          ...this.headers,
+          "Content-Type": "application/json"
+        },
+        body: s ? JSON.stringify(s) : void 0
+      });
+      return n.ok || await this.handleErrorResponse(n), n.status === 204 ? void 0 : n.json();
+    } catch (n) {
+      throw n instanceof p ? n : new v(`Network error: ${n instanceof Error ? n.message : "Unknown error"}. Check that \`baseUrl\` is reachable and includes the protocol (https://).`, n instanceof Error ? n : void 0);
+    }
+  }
+  async handleErrorResponse(t) {
+    let e;
+    try {
+      e = await t.json();
+    } catch {
+    }
+    if (e?.error) throw p.fromResponse(e, t.status);
+    let s = "";
+    throw t.status === 401 || t.status === 403 ? s = " Check `userJwt` (and that it has not expired)." : t.status === 404 && (s = " Check that `baseUrl` points at your AGO API root."), new p(`HTTP ${t.status}: ${t.statusText}.${s}`, "http_error", t.status, "api_error");
+  }
+}, N = 5e4, T = 2e4, D = 2e3, P = class {
+  constructor(t) {
+    this.functions = /* @__PURE__ */ new Map(), this.defaultMaxResultBytes = t?.maxResultBytes ?? N;
+  }
+  setDefaultMaxResultBytes(t) {
+    this.defaultMaxResultBytes = t;
+  }
+  register(t, e, s) {
+    if (typeof t == "object") {
+      const { name: r, handler: l, description: u, parameters: h, maxResultBytes: d, requiresApproval: g } = t;
+      return this.register(r, l, {
+        description: u,
+        parameters: h,
+        maxResultBytes: d,
+        requiresApproval: g
+      });
+    }
+    const i = t;
+    if (!e || !s) throw new m(`registerFunction("${i}"): both a handler and a schema are required. Pass them as arguments or use the single-object form: registerFunction({ name, parameters, handler }).`, "function_invalid_registration");
+    this.functions.has(i) && c.warn(`Function "${i}" is being overwritten`);
+    const { maxResultBytes: n, requiresApproval: o, ...a } = s;
+    this.functions.set(i, {
+      schema: {
+        ...a,
+        name: i
+      },
+      handler: e,
+      maxResultBytes: n,
+      requiresApproval: o
+    }), c.log(`Registered function: ${i}`);
+  }
+  unregister(t) {
+    const e = this.functions.delete(t);
+    return e && c.log(`Unregistered function: ${t}`), e;
+  }
+  get(t) {
+    return this.functions.get(t);
+  }
+  has(t) {
+    return this.functions.has(t);
+  }
+  getSchemas() {
+    return Array.from(this.functions.values()).map((t) => t.schema);
+  }
+  async execute(t, e) {
+    const s = this.functions.get(t);
+    if (!s) throw new E(`Function "${t}" is not registered`, t);
+    c.log(`Executing function: ${t}`, e);
+    try {
+      const i = await s.handler(e);
+      return c.log(`Function ${t} completed:`, i), this.guardResultSize(t, i, s.maxResultBytes);
+    } catch (i) {
+      throw c.error(`Function ${t} failed:`, i), new E(`Function "${t}" execution failed: ${i instanceof Error ? i.message : "Unknown error"}`, t, i instanceof Error ? i : void 0);
+    }
+  }
+  guardResultSize(t, e, s) {
+    let i;
+    try {
+      i = JSON.stringify(e);
+    } catch {
+      return e;
+    }
+    if (i === void 0) return e;
+    const n = new TextEncoder().encode(i).length, o = s ?? this.defaultMaxResultBytes;
+    return n > o ? (c.warn(`Function "${t}" result is ${n} bytes, over the ${o}-byte limit; a truncated preview was sent to the agent instead. Return fewer fields, paginate, or raise maxResultBytes for this function.`), {
+      truncated: !0,
+      originalBytes: n,
+      maxBytes: o,
+      preview: i.slice(0, D),
+      hint: `The result of "${t}" exceeded the ${o}-byte limit and was truncated. Request less data (use limit or filter parameters if available), or tell the user the result is too large to process.`
+    }) : (n > T && c.warn(`Function "${t}" returned a large result (${Math.round(n / 1024)} KB). Large results consume LLM context: return fewer fields, paginate, or push the data to the UI and return a summary.`), e);
+  }
+  clear() {
+    this.functions.clear(), c.log("Cleared all registered functions");
+  }
+  get size() {
+    return this.functions.size;
+  }
+}, j = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map(), this.dynamicProviders = /* @__PURE__ */ new Map();
+  }
+  set(t, e) {
+    this.entries.set(t, e), c.log(`ClientContext set: ${t}`);
+  }
+  remove(t) {
+    const e = this.entries.delete(t);
+    return e && c.log(`ClientContext removed: ${t}`), e;
+  }
+  addDynamicProvider(t, e) {
+    this.dynamicProviders.set(t, e), c.log(`DynamicContext provider added: ${t}`);
+  }
+  removeDynamicProvider(t) {
+    const e = this.dynamicProviders.delete(t);
+    return e && c.log(`DynamicContext provider removed: ${t}`), e;
+  }
+  getSnapshot() {
+    if (this.entries.size === 0 && this.dynamicProviders.size === 0) return null;
+    const t = {};
+    for (const [e, s] of this.entries) t[e] = s;
+    for (const [e, s] of this.dynamicProviders) try {
+      const i = s();
+      i && (t[e] = i);
+    } catch (i) {
+      c.error(`DynamicContext provider "${e}" threw:`, i);
+    }
+    return Object.keys(t).length === 0 ? null : { entries: t };
+  }
+  clear() {
+    this.entries.clear(), this.dynamicProviders.clear(), c.log("ClientContext cleared");
+  }
+};
+function b(t) {
+  return t === null || typeof t != "object" ? JSON.stringify(t) ?? "null" : Array.isArray(t) ? `[${t.map(b).join(",")}]` : `{${Object.keys(t).sort().map((e) => `${JSON.stringify(e)}:${b(t[e])}`).join(",")}}`;
+}
+var M = class {
+  constructor(t) {
+    this.callbacks = t, this.buffer = "", this.message = {}, this.toolCalls = [], this.sources = [], this.followUpReplies = [], this.isFirstChunk = !0, this.answerCompleteEmitted = !1, this.waitingClientEmitted = !1, this.firedClientFunctions = /* @__PURE__ */ new Set();
+  }
+  async processStream(t) {
+    if (!t.body) throw new _("Response has no body. The endpoint did not return a stream: check that `baseUrl` points at an AGO API and nothing (proxy, mock) strips the SSE body.", "stream_no_body");
+    const e = t.body.getReader(), s = new TextDecoder();
+    try {
+      for (; ; ) {
+        const { done: i, value: n } = await e.read();
+        if (i) break;
+        const o = s.decode(n, { stream: !0 });
+        this.buffer += o, this.processBuffer();
+      }
+      return this.buffer.trim() && this.processBuffer(), this.buildFinalMessage();
+    } catch (i) {
+      const n = i instanceof Error ? i : new _("Stream processing failed mid-flight. The connection may have dropped; retry the message.");
+      throw this.callbacks.onError?.(n), n;
+    } finally {
+      e.releaseLock();
+    }
+  }
+  processBuffer() {
+    const t = this.buffer.split(`
+
+`);
+    this.buffer = t.pop() || "";
+    for (const e of t) {
+      if (!e.trim()) continue;
+      const s = e.split(`
+`);
+      for (const i of s)
+        if (!i.startsWith(": ") && i.startsWith("data: ")) {
+          const n = i.slice(6);
+          try {
+            const o = JSON.parse(n);
+            this.handleChunk(o);
+          } catch (o) {
+            c.warn("Failed to parse SSE data:", n, o);
+          }
+        }
+    }
+  }
+  handleChunk(t) {
+    if (this.callbacks.onRawChunk?.(t), t.message_id && !this.message.id && (this.message.id = t.message_id), t.thread?.id && (this.message.conversationId = t.thread.id, this.isFirstChunk && this.message.id && (this.isFirstChunk = !1, this.callbacks.onStart?.({
+      conversationId: this.message.conversationId,
+      messageId: this.message.id
+    }))), t.content !== void 0 && (this.message.content = (this.message.content || "") + t.content, this.message.conversationId && this.message.id && this.callbacks.onChunk?.({
+      content: t.content,
+      conversationId: this.message.conversationId,
+      messageId: this.message.id
+    })), t.full_content !== void 0 && (this.message.content = t.full_content), t.status && (this.message.status = t.status), t.agent && (this.message.agent = {
+      id: t.agent.id,
+      name: t.agent.name,
+      displayName: t.agent.display_name
+    }), t.knowledge_sources && (this.sources = t.knowledge_sources.map((e) => {
+      const s = e.knowledge_document;
+      return {
+        id: s.id,
+        title: s.title,
+        url: s.use_external_link ? s.external_link_url : s.internal_link_url
+      };
+    })), t.type === "client_function" && t.function_name) {
+      const e = `${t.function_name}::${b(t.arguments ?? {})}`;
+      this.firedClientFunctions.has(e) || (this.firedClientFunctions.add(e), this.callbacks.onClientFunction?.({
+        invocationId: t.id || "",
+        functionName: t.function_name,
+        arguments: t.arguments || {},
+        conversationId: this.message.conversationId || ""
+      }));
+    }
+    if (t.tool_call_data && t.type && t.type !== "client_function") {
+      const e = this.parseToolCall(t);
+      this.callbacks.onToolCall?.(e);
+      const s = this.toolCalls.findIndex((i) => i.id === e.id);
+      s >= 0 ? this.toolCalls[s] = e : this.toolCalls.push(e);
+    }
+    t.follow_up_replies && (this.followUpReplies = t.follow_up_replies), this.message.status === "DONE" && !this.answerCompleteEmitted && this.message.id && (this.answerCompleteEmitted = !0, this.callbacks.onAnswerComplete?.(this.buildMessage())), this.message.status === "WAITING_CLIENT" && !this.waitingClientEmitted && this.message.id && (this.waitingClientEmitted = !0, this.callbacks.onWaitingClient?.({
+      conversationId: this.message.conversationId || "",
+      messageId: this.message.id,
+      waitingToolCallIds: t.waiting_tool_call_ids ?? []
+    }));
+  }
+  parseToolCall(t) {
+    return {
+      id: t.id || "",
+      type: t.type || "status_message",
+      status: t.status || "unknown",
+      toolName: t.tool_name || "",
+      toolDisplayName: t.tool_display_name,
+      message: t.message,
+      formSchema: t.form_schema,
+      data: t.data,
+      functionName: t.function_name,
+      arguments: t.arguments
+    };
+  }
+  buildMessage() {
+    return {
+      id: this.message.id || "",
+      conversationId: this.message.conversationId || "",
+      content: this.message.content || "",
+      role: "assistant",
+      status: this.message.status || "DONE",
+      agent: this.message.agent,
+      sources: this.sources.length > 0 ? this.sources : void 0,
+      toolCalls: this.toolCalls.length > 0 ? this.toolCalls : void 0,
+      followUpReplies: this.followUpReplies.length > 0 ? this.followUpReplies : void 0,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+  buildFinalMessage() {
+    const t = this.buildMessage();
+    return t.status !== "WAITING_CLIENT" && this.callbacks.onComplete?.(t), t;
+  }
+};
+function H(t) {
+  const e = t.message.toLowerCase();
+  return e.includes("load failed") || e.includes("failed to fetch") || e.includes("network") || e.includes("abort");
+}
+var O = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/bmp",
+  "image/tiff"
+]);
+function B(t) {
+  if (!t) return;
+  const e = typeof window < "u" && window.location ? window.location.href : "https://ago.local/";
+  try {
+    const s = new URL(t, e);
+    if (s.protocol === "http:" || s.protocol === "https:" || s.protocol === "blob:") return t;
+  } catch {
+  }
+}
+function K(t) {
+  return t.isSafeImage === !0 && typeof t.contentType == "string" && t.contentType.startsWith("image/") && B(t.url) !== void 0;
+}
+function X(t) {
+  if (t == null || t < 0) return "";
+  if (t < 1024) return `${t} B`;
+  const e = t / 1024;
+  return e < 1024 ? `${e.toFixed(1)} KB` : `${(e / 1024).toFixed(1)} MB`;
+}
+function L(t) {
+  return {
+    id: String(t.id ?? ""),
+    name: typeof t.name == "string" && t.name ? t.name : "file",
+    contentType: typeof t.content_type == "string" ? t.content_type : void 0,
+    fileSize: typeof t.file_size == "number" ? t.file_size : void 0,
+    url: typeof t.file_url == "string" ? t.file_url : void 0,
+    isSafeImage: t.is_safe_image === !0
+  };
+}
+function Y(t) {
+  return t.map((e, s) => ({
+    id: `local-${s}-${e.name}`,
+    name: e.name,
+    contentType: e.type || void 0,
+    fileSize: e.size,
+    url: typeof URL < "u" && URL.createObjectURL ? URL.createObjectURL(e) : void 0,
+    isSafeImage: O.has(e.type)
+  }));
+}
+var G = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  on(t, e) {
+    this.handlers.has(t) || this.handlers.set(t, /* @__PURE__ */ new Set()), this.handlers.get(t).add(e);
+  }
+  off(t, e) {
+    const s = this.handlers.get(t);
+    s && s.delete(e);
+  }
+  emit(t, e) {
+    const s = this.handlers.get(t);
+    s && s.forEach((i) => {
+      try {
+        i(e);
+      } catch (n) {
+        console.error(`Error in event handler for ${String(t)}:`, n);
+      }
+    });
+  }
+  once(t, e) {
+    const s = ((i) => {
+      this.off(t, s), e(i);
+    });
+    this.on(t, s);
+  }
+  waitFor(t, e) {
+    return new Promise((s, i) => {
+      let n;
+      const o = ((a) => {
+        n && clearTimeout(n), s(a);
+      });
+      this.once(t, o), e?.timeout && (n = setTimeout(() => {
+        this.off(t, o), i(/* @__PURE__ */ new Error(`waitFor("${String(t)}") timed out after ${e.timeout}ms`));
+      }, e.timeout));
+    });
+  }
+  removeAllListeners(t) {
+    t ? this.handlers.delete(t) : this.handlers.clear();
+  }
+}, S = '`baseUrl` is required, e.g. new AgoClient({ baseUrl: "https://YOUR-DOMAIN.api.useago.com" }). Try the live demo endpoint https://playground.api.useago.com. See docs/general/configuration.md#error-codes (config_missing_base_url).', W = /^[a-z][a-z0-9+.-]*:\/\//i, $ = !1;
+function A(t, e = "AgoClient") {
+  if (typeof t != "object" || t === null) throw new m(`${e}: ${S}`, "config_missing_base_url");
+  const s = t.baseUrl;
+  if (typeof s != "string" || s.trim() === "") throw new m(`${e}: ${S}`, "config_missing_base_url");
+  !s.startsWith("/") && !W.test(s) && ($ || ($ = !0, console.warn(`[AGO] ${e}: \`baseUrl\` has no protocol and is not a relative path (config_suspect_base_url). Requests will fail: Node throws a URL parse error, browsers fetch it as a relative path. Use "https://..." (or a "/path" for a same-origin proxy).`)));
+}
+function q(t) {
+  return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function C(t) {
+  return t.split("/").filter((e) => e.startsWith(":")).map((e) => e.slice(1));
+}
+function z(t, e) {
+  const s = [];
+  return {
+    path: t.split("/").map((i) => {
+      if (!i.startsWith(":")) return i;
+      const n = i.slice(1), o = e[n];
+      return o == null || o === "" ? (s.push(n), i) : encodeURIComponent(String(o));
+    }).join("/"),
+    missing: s
+  };
+}
+function J(t, e) {
+  const s = e.find((n) => n.path === t);
+  if (s) return s;
+  const i = e.find((n) => {
+    if (!n.path.includes(":")) return !1;
+    const o = "^" + n.path.split("/").map((a) => a.startsWith(":") ? "[^/]+" : q(a)).join("/") + "/?$";
+    return new RegExp(o).test(t);
+  });
+  return i || e.filter((n) => n.path !== "/" && t.startsWith(n.path)).sort((n, o) => o.path.length - n.path.length)[0];
+}
+var V = class k {
+  constructor(e) {
+    this.warnedEmptyConversations = /* @__PURE__ */ new Set(), this.pendingResumes = /* @__PURE__ */ new Map(), this.pendingApprovals = /* @__PURE__ */ new Map(), this.resumeGate = null, A(e, "AgoClient"), this.config = e, this.httpClient = new U(e), this.functionRegistry = new P({ maxResultBytes: e.maxFunctionResultBytes }), this.contextRegistry = new j(), this.eventEmitter = new G(), e.debug && c.enable(), c.log("AgoClient initialized");
+  }
+  async sendMessage(e, s) {
+    const i = this.functionRegistry.getSchemas(), n = this.contextRegistry.getSnapshot(), o = this.config.agent || this.config.defaultAgentId, a = this.resolveClientFunctionsMode(s), r = {
+      content: e,
+      conversation_id: s?.conversationId,
+      agent_id: s?.agentId || o
+    };
+    i.length > 0 && (r.client_functions = i, a === "pause" && (r.client_functions_mode = a)), n && (r.client_context = n), s?.hidden && (r.hidden = !0);
+    let l;
+    if (s?.files && s.files.length > 0) {
+      const u = new FormData();
+      u.append("content", e), s.conversationId && u.append("conversation_id", s.conversationId), (s.agentId || o) && u.append("agent_id", s.agentId || o || ""), i.length > 0 && (u.append("client_functions", JSON.stringify(i)), a === "pause" && u.append("client_functions_mode", a)), n && u.append("client_context", JSON.stringify(n)), s.hidden && u.append("hidden", "true");
+      for (const h of s.files) u.append("files", h);
+      l = await this.httpClient.postFormData("/api/sdk/v1/messages", u);
+    } else l = await this.httpClient.postStream("/api/sdk/v1/messages", r);
+    return this.processSSEResponse(l);
+  }
+  async processSSEResponse(e) {
+    let s = !1;
+    const i = await new M({
+      onRawChunk: (n) => {
+        this.eventEmitter.emit("stream:message", n);
+      },
+      onStart: (n) => {
+        this.eventEmitter.emit("message:start", n);
+      },
+      onChunk: (n) => {
+        this.eventEmitter.emit("message:chunk", n);
+      },
+      onToolCall: (n) => {
+        this.eventEmitter.emit("toolCall:received", n), n.type === "form" && this.eventEmitter.emit("toolCall:form", n);
+      },
+      onClientFunction: async (n) => {
+        if (s = !0, this.eventEmitter.emit("function:invoke", n), n.invocationId && this.requiresApproval(n)) {
+          this.pendingApprovals.set(n.invocationId, n), this.eventEmitter.emit("function:awaiting-approval", n);
+          return;
+        }
+        await this.handleClientFunctionInvocation(n);
+      },
+      onAnswerComplete: (n) => {
+        this.eventEmitter.emit("message:answer-complete", n);
+      },
+      onWaitingClient: (n) => {
+        this.eventEmitter.emit("message:waiting-client", n), this.markResumeSignal(n.messageId, n.conversationId, "waitingConfirmed");
+      },
+      onComplete: (n) => {
+        this.eventEmitter.emit("message:complete", n);
+      },
+      onError: (n) => {
+        this.eventEmitter.emit("message:error", {
+          error: n.message,
+          code: n instanceof m ? n.code : void 0
+        });
+      }
+    }).processStream(e);
+    return i.status !== "WAITING_CLIENT" && this.maybeFlagEmptyReply(i, s), i;
+  }
+  resolveClientFunctionsMode(e) {
+    return e?.clientFunctionsMode ?? this.config.clientFunctionsMode ?? "pause";
+  }
+  registerResumeGate(e) {
+    return this.resumeGate = e, () => {
+      this.resumeGate === e && (this.resumeGate = null);
+    };
+  }
+  async continueMessage(e) {
+    const s = this.functionRegistry.getSchemas(), i = this.contextRegistry.getSnapshot(), n = {};
+    s.length > 0 && (n.client_functions = s), i && (n.client_context = i);
+    const o = await this.httpClient.postStream(`/api/sdk/v1/messages/${e}/continue`, n);
+    return this.processSSEResponse(o);
+  }
+  markResumeSignal(e, s, i) {
+    if (!e) return;
+    const n = this.pendingResumes.get(e) ?? {
+      conversationId: s,
+      waitingConfirmed: !1,
+      resultsReady: !1,
+      started: !1
+    };
+    n[i] = !0, s && (n.conversationId = s), this.pendingResumes.set(e, n), !(!n.waitingConfirmed || !n.resultsReady || n.started) && (n.started = !0, this.runAutoResume(e, n.conversationId));
+  }
+  async runAutoResume(e, s) {
+    try {
+      this.resumeGate && await this.resumeGate({
+        conversationId: s,
+        messageId: e
+      });
+    } catch (i) {
+      c.warn("Resume gate threw; resuming anyway:", i);
+    }
+    this.pendingResumes.delete(e);
+    try {
+      await this.continueMessage(e);
+    } catch (i) {
+      c.warn("Auto-resume of paused turn failed:", i);
+    }
+  }
+  maybeFlagEmptyReply(e, s) {
+    e.status === "DONE" && (e.content ?? "").trim() === "" && !s && !(e.toolCalls && e.toolCalls.length > 0) && !(e.followUpReplies && e.followUpReplies.length > 0) && setTimeout(() => {
+      if (this.eventEmitter.emit("message:empty", {
+        conversationId: e.conversationId ?? "",
+        messageId: e.id ?? ""
+      }), this.config.warnOnEmptyReply === !1) return;
+      const i = e.conversationId || "(no conversation)";
+      if (this.warnedEmptyConversations.has(i)) return;
+      this.warnedEmptyConversations.add(i);
+      const n = this.config.agent || this.config.defaultAgentId;
+      e.id ? console.warn("[AGO] Reply completed with empty content. Possible causes: " + (n ? `the agent "${n}" may not exist for this tenant, ` : "an unknown `agent` slug, ") + "or the agent replied with no text. Listen for the `message:empty` event to handle this in your app; silence this warning with `warnOnEmptyReply: false`.") : console.warn("[AGO] The stream completed without any message data. Possible causes: " + (n ? `the agent "${n}" may not exist for this tenant, or ` : "") + "`baseUrl` does not point at an AGO endpoint that returns server-sent events. Listen for the `message:empty` event to handle this in your app; silence this warning with `warnOnEmptyReply: false`.");
+    }, 0);
+  }
+  async handleClientFunctionInvocation(e) {
+    let s, i;
+    try {
+      s = await this.functionRegistry.execute(e.functionName, e.arguments);
+    } catch (n) {
+      i = n instanceof Error ? n.message : "Unknown error", c.error("Client function execution failed:", n);
+    }
+    if (e.invocationId) try {
+      const n = await this.submitToolCallForm(e.invocationId, {
+        result: s,
+        error: i,
+        _type: "client_function_result"
+      });
+      n?.resume?.ready && this.markResumeSignal(n.resume.message_id, e.conversationId, "resultsReady");
+    } catch (n) {
+      c.error("Failed to submit function result:", n);
+    }
+    this.eventEmitter.emit("function:result", {
+      invocationId: e.invocationId,
+      result: s,
+      error: i
+    });
+  }
+  requiresApproval(e) {
+    const s = this.config.approvalPolicy;
+    if (s) try {
+      if (s(e)) return !0;
+    } catch (i) {
+      c.warn("approvalPolicy threw; not gating this call:", i);
+    }
+    return this.functionRegistry.get(e.functionName)?.requiresApproval === !0;
+  }
+  async approveFunction(e) {
+    const s = this.pendingApprovals.get(e);
+    s && (this.pendingApprovals.delete(e), await this.handleClientFunctionInvocation(s));
+  }
+  async rejectFunction(e) {
+    const s = this.pendingApprovals.get(e);
+    if (!s) return;
+    this.pendingApprovals.delete(e);
+    const i = {
+      approved: !1,
+      reason: "user_rejected"
+    };
+    try {
+      const n = await this.submitToolCallForm(e, {
+        result: i,
+        _type: "client_function_result"
+      });
+      n?.resume?.ready && this.markResumeSignal(n.resume.message_id, s.conversationId, "resultsReady");
+    } catch (n) {
+      c.error("Failed to submit function rejection:", n);
+    }
+    this.eventEmitter.emit("function:result", {
+      invocationId: e,
+      result: i
+    });
+  }
+  async getConversations() {
+    return (await this.httpClient.get("/api/sdk/v1/conversations")).items.map((e) => ({
+      id: e.id,
+      title: e.title,
+      lastMessageDate: new Date(e.last_message_date)
+    }));
+  }
+  async getConversation(e) {
+    const s = await this.httpClient.get(`/api/sdk/v1/conversations/${e}`), i = {
+      id: s.id,
+      title: s.title,
+      lastMessageDate: new Date(s.last_message_date),
+      messages: s.messages.map((n) => ({
+        id: n.id,
+        conversationId: s.id,
+        content: n.content,
+        role: n.role,
+        status: n.status,
+        createdAt: new Date(n.created_at),
+        hidden: n.hidden,
+        toolCalls: k.mapPersistedToolCalls(n.tool_call_data),
+        attachments: n.attachments && n.attachments.length > 0 ? n.attachments.map(L) : void 0
+      }))
+    };
+    return this.eventEmitter.emit("conversation:loaded", i), i;
+  }
+  static mapPersistedToolCalls(e) {
+    if (!(!e || e.length === 0))
+      return e.map((s) => ({
+        id: String(s.id ?? ""),
+        type: s.type ?? "status_message",
+        status: String(s.status ?? "unknown"),
+        toolName: s.tool_name ?? "",
+        toolDisplayName: s.tool_display_name,
+        message: s.message,
+        formSchema: s.form_schema,
+        data: s.data,
+        functionName: s.function_name,
+        arguments: s.arguments
+      }));
+  }
+  async getMessages(e) {
+    return (await this.getConversation(e)).messages || [];
+  }
+  async resumePendingClientFunctions(e) {
+    const s = [...e.messages ?? []].reverse().find((r) => r.role === "assistant" && r.status === "WAITING_CLIENT");
+    if (!s) return null;
+    const i = (s.toolCalls ?? []).filter((r) => r.type === "client_function" && r.status === "waiting_input" && r.functionName), n = new Set(this.functionRegistry.getSchemas().map((r) => r.name)), o = i.filter((r) => !n.has(r.functionName));
+    if (o.length > 0)
+      return c.warn("Cannot resume paused turn: function(s) not registered on this page:", o.map((r) => r.functionName)), null;
+    let a = i.length === 0;
+    for (const r of i) {
+      const l = {
+        invocationId: r.id,
+        functionName: r.functionName,
+        arguments: r.arguments ?? {},
+        conversationId: e.id
+      };
+      if (this.requiresApproval(l)) {
+        this.pendingApprovals.set(r.id, l), this.markResumeSignal(s.id, e.id, "waitingConfirmed"), this.eventEmitter.emit("function:awaiting-approval", l), a = !1;
+        continue;
+      }
+      let u, h;
+      try {
+        u = await this.functionRegistry.execute(r.functionName, r.arguments ?? {});
+      } catch (d) {
+        h = d instanceof Error ? d.message : "Unknown error", c.error("Client function execution failed:", d);
+      }
+      a = (await this.submitToolCallForm(r.id, {
+        result: u,
+        error: h,
+        _type: "client_function_result"
+      }))?.resume?.ready ?? a;
+    }
+    return a ? this.continueMessage(s.id) : null;
+  }
+  async submitToolCallForm(e, s) {
+    return this.httpClient.post(`/api/sdk/v1/tool-calls/${e}/submit`, { formData: s });
+  }
+  async confirmToolCall(e) {
+    await this.httpClient.post(`/api/tool-calls/${e}/confirm/`);
+  }
+  async rejectToolCall(e) {
+    await this.httpClient.post(`/api/tool-calls/${e}/reject/`);
+  }
+  async getFormCollector(e) {
+    const s = await this.httpClient.get(`/api/sdk/v1/forms/${encodeURIComponent(e)}`);
+    return {
+      name: s.name,
+      description: s.description,
+      schema: s.schema,
+      submit: s.submit ?? void 0
+    };
+  }
+  async submitFormCollector(e, s) {
+    return this.httpClient.post("/api/sdk/v1/forms/submit", {
+      name: e,
+      values: s
+    });
+  }
+  async submitFeedback(e, s) {
+    await this.httpClient.post(`/api/sdk/v1/messages/${e}/feedback`, { rating: s });
+  }
+  registerFunction(e, s, i) {
+    typeof e == "object" ? this.functionRegistry.register(e) : this.functionRegistry.register(e, s, i);
+  }
+  register(e) {
+    if (Array.isArray(e)) for (const s of e) this.functionRegistry.register(s);
+    else this.functionRegistry.register(e);
+  }
+  unregisterFunction(e) {
+    return this.functionRegistry.unregister(e);
+  }
+  getRegisteredFunctions() {
+    return this.functionRegistry.getSchemas();
+  }
+  registerNavigationFunction(e, s) {
+    const i = s.map((r) => r.name), n = s.map((r) => {
+      const l = C(r.path), u = l.length > 0 ? ` (requires ${l.map((h) => `"${h}"`).join(", ")})` : "";
+      return `- "${r.name}"${u}: ${r.description}`;
+    }).join(`
+`), o = /* @__PURE__ */ new Map();
+    for (const r of s) for (const l of C(r.path)) o.set(l, [...o.get(l) ?? [], r.name]);
+    const a = { page: {
+      type: "string",
+      description: "The page to navigate to",
+      enum: i
+    } };
+    for (const [r, l] of o) {
+      if (r === "page") {
+        c.error('registerNavigationFunction: a ":page" placeholder collides with the "page" argument and is ignored. Rename the placeholder.');
+        continue;
+      }
+      a[r] = {
+        type: "string",
+        description: `Value for ":${r}" in the page path. Required when page is ${l.map((u) => `"${u}"`).join(" or ")}.`
+      };
+    }
+    this.registerFunction("navigateToPage", async (r) => {
+      const l = r.page, u = s.find((f) => f.name === l);
+      if (!u) return {
+        success: !1,
+        error: `Unknown page: ${l}`
+      };
+      let h = {};
+      if (typeof r.params == "string") try {
+        h = JSON.parse(r.params);
+      } catch {
+      }
+      else r.params && typeof r.params == "object" && (h = r.params);
+      const d = {};
+      for (const f of C(u.path)) d[f] = r[f] ?? h[f];
+      const { path: g, missing: y } = z(u.path, d);
+      if (y.length > 0) {
+        const f = y.map((w) => `"${w}": "..."`).join(", ");
+        return {
+          success: !1,
+          error: `Page "${l}" needs ${y.map((w) => `"${w}"`).join(", ")}. Retry with { "page": "${l}", ${f} }.`
+        };
+      }
+      return e(g), {
+        success: !0,
+        navigatedTo: g
+      };
+    }, {
+      description: `Navigate the user to a page in the application. Available pages:
+${n}`,
+      parameters: {
+        type: "object",
+        properties: a,
+        required: ["page"]
+      }
+    }), this.addDynamicContext("current-page", () => {
+      if (typeof window > "u" || !window.location) return null;
+      const r = window.location.href, l = typeof document < "u" ? document.title : void 0, u = J(window.location.pathname, s), h = { url: r };
+      return u && (h.page = u.name), l && (h.title = l), {
+        name: "Current page",
+        description: "The page the user is currently viewing.",
+        data: h
+      };
+    });
+  }
+  unregisterNavigationFunction() {
+    this.unregisterFunction("navigateToPage"), this.removeDynamicContext("current-page");
+  }
+  registerPageStateFunction(e, s) {
+    const i = s?.functionName ?? "setPageState", n = new Map(e.map((a) => [a.name, a])), o = e.map((a) => `- "${a.name}": ${a.description}`).join(`
+`);
+    this.registerFunction(i, async (a) => {
+      const r = {};
+      for (const [l, u] of Object.entries(a)) {
+        if (u === void 0) continue;
+        const h = n.get(l);
+        h && (await h.set(u), r[l] = u);
+      }
+      return {
+        success: !0,
+        applied: r
+      };
+    }, {
+      description: `Change the state of the current page. Set ONLY the controls the user explicitly asked for; leave the others unset. Available controls:
+${o}`,
+      parameters: {
+        type: "object",
+        properties: Object.fromEntries(e.map((a) => [a.name, {
+          ...a.schema,
+          description: a.description
+        }]))
+      },
+      requiresApproval: s?.requiresApproval
+    }), this.addDynamicContext(`page-state:${i}`, () => {
+      const a = e.filter((l) => typeof l.get == "function");
+      if (a.length === 0) return null;
+      const r = {};
+      for (const l of a) r[l.name] = l.get();
+      return {
+        name: "Page state",
+        description: "Current, editable state of the page the user is viewing.",
+        data: r
+      };
+    });
+  }
+  unregisterPageStateFunction(e) {
+    const s = e ?? "setPageState";
+    this.unregisterFunction(s), this.removeDynamicContext(`page-state:${s}`);
+  }
+  setContext(e, s) {
+    this.contextRegistry.set(e, s), this.notifyContextChanged();
+  }
+  removeContext(e) {
+    const s = this.contextRegistry.remove(e);
+    return s && this.notifyContextChanged(), s;
+  }
+  addDynamicContext(e, s) {
+    this.contextRegistry.addDynamicProvider(e, s), this.notifyContextChanged();
+  }
+  removeDynamicContext(e) {
+    const s = this.contextRegistry.removeDynamicProvider(e);
+    return s && this.notifyContextChanged(), s;
+  }
+  notifyContextChanged() {
+    this.eventEmitter.emit("context:changed", this.contextRegistry.getSnapshot());
+  }
+  emitFormEvent(e, s) {
+    this.eventEmitter.emit(e, s);
+  }
+  enableAutoPageContext() {
+    this.addDynamicContext("browser-page", () => {
+      const e = typeof window < "u" ? window.location.href : void 0, s = typeof document < "u" ? document.title : void 0;
+      return !e && !s ? null : {
+        name: "Browser page",
+        description: "Current page the user is viewing",
+        data: {
+          url: e,
+          title: s
+        }
+      };
+    });
+  }
+  getContextSnapshot() {
+    return this.contextRegistry.getSnapshot();
+  }
+  on(e, s) {
+    this.eventEmitter.on(e, s);
+  }
+  off(e, s) {
+    this.eventEmitter.off(e, s);
+  }
+  once(e, s) {
+    this.eventEmitter.once(e, s);
+  }
+  waitFor(e, s) {
+    return this.eventEmitter.waitFor(e, s);
+  }
+  updateConfig(e) {
+    const s = {};
+    for (const [n, o] of Object.entries(e)) o !== void 0 && (s[n] = o);
+    const i = {
+      ...this.config,
+      ...s
+    };
+    A(i, "AgoClient.updateConfig"), this.config = i, this.httpClient.updateConfig(s), s.debug !== void 0 && (s.debug ? c.enable() : c.disable()), s.maxFunctionResultBytes !== void 0 && this.functionRegistry.setDefaultMaxResultBytes(s.maxFunctionResultBytes);
+  }
+  destroy() {
+    this.eventEmitter.removeAllListeners(), this.functionRegistry.clear(), this.contextRegistry.clear(), this.pendingResumes.clear(), this.pendingApprovals.clear(), this.resumeGate = null, c.log("AgoClient destroyed");
+  }
+};
+export {
+  _,
+  K as a,
+  M as c,
+  P as d,
+  c as f,
+  v as g,
+  E as h,
+  Y as i,
+  H as l,
+  m,
+  A as n,
+  X as o,
+  p,
+  G as r,
+  B as s,
+  V as t,
+  j as u
+};