@invergent/website-widget 1.4.3

package/dist/index.js

@@ -0,0 +1,694 @@
+import { EventType, AbstractAgent, AGUIError } from '@ag-ui/client';
+export { AbstractAgent, EventType } from '@ag-ui/client';
+import { Observable } from 'rxjs';
+
+// src/agent.ts
+
+// src/constants.ts
+var PROTOCOL_VERSION = 1;
+var SDK_VERSION = "0.1.0";
+var CSRF_HEADER = "X-CSRF-Token";
+var VERSION_HEADER = "X-Surogates-Widget-Version";
+var PATH_BOOTSTRAP = "/v1/website/sessions";
+var PATH_MESSAGES = (sessionId) => `/v1/website/sessions/${sessionId}/messages`;
+var PATH_EVENTS = (sessionId, after) => `/v1/website/sessions/${sessionId}/events?after=${after}`;
+var PATH_END = (sessionId) => `/v1/website/sessions/${sessionId}/end`;
+var SURG_EVENT = {
+  USER_MESSAGE: "user.message",
+  LLM_REQUEST: "llm.request",
+  LLM_RESPONSE: "llm.response",
+  LLM_THINKING: "llm.thinking",
+  LLM_DELTA: "llm.delta",
+  TOOL_CALL: "tool.call",
+  TOOL_RESULT: "tool.result",
+  SANDBOX_PROVISION: "sandbox.provision",
+  SANDBOX_EXECUTE: "sandbox.execute",
+  SANDBOX_RESULT: "sandbox.result",
+  SANDBOX_DESTROY: "sandbox.destroy",
+  SESSION_START: "session.start",
+  SESSION_PAUSE: "session.pause",
+  SESSION_RESUME: "session.resume",
+  SESSION_COMPLETE: "session.complete",
+  SESSION_FAIL: "session.fail",
+  SESSION_DONE: "session.done",
+  CONTEXT_COMPACT: "context.compact",
+  MEMORY_UPDATE: "memory.update",
+  EXPERT_DELEGATION: "expert.delegation",
+  EXPERT_RESULT: "expert.result",
+  EXPERT_FAILURE: "expert.failure",
+  POLICY_DENIED: "policy.denied",
+  POLICY_ALLOWED: "policy.allowed",
+  HARNESS_CRASH: "harness.crash"
+};
+
+// src/errors.ts
+var SurogatesError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "SurogatesError";
+    if (opts?.status !== void 0) this.status = opts.status;
+    if (opts?.detail !== void 0) this.detail = opts.detail;
+    if (opts?.cause !== void 0) this.cause = opts.cause;
+  }
+};
+var SurogatesAuthError = class extends SurogatesError {
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "SurogatesAuthError";
+  }
+};
+var SurogatesRateLimitError = class extends SurogatesError {
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "SurogatesRateLimitError";
+    if (opts?.retryAfter !== void 0) this.retryAfter = opts.retryAfter;
+  }
+};
+var SurogatesProtocolError = class extends SurogatesError {
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "SurogatesProtocolError";
+  }
+};
+var SurogatesNetworkError = class extends SurogatesError {
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "SurogatesNetworkError";
+  }
+};
+
+// src/protocol.ts
+async function doFetch(url, init) {
+  let response;
+  try {
+    response = await fetch(url, {
+      ...init,
+      credentials: "include",
+      headers: {
+        ...init.headers,
+        [VERSION_HEADER]: SDK_VERSION
+      }
+    });
+  } catch (cause) {
+    throw new SurogatesNetworkError("Network request failed", { cause });
+  }
+  return response;
+}
+async function extractDetail(response) {
+  try {
+    const body = await response.json();
+    return typeof body.detail === "string" ? body.detail : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function raiseForStatus(response, action) {
+  const detail = await extractDetail(response);
+  if (response.status === 401 || response.status === 403) {
+    throw new SurogatesAuthError(`${action} rejected (${response.status})`, {
+      status: response.status,
+      ...detail !== void 0 && { detail }
+    });
+  }
+  if (response.status === 429) {
+    const retryAfterHeader = response.headers.get("Retry-After");
+    const retryAfter = retryAfterHeader ? Number(retryAfterHeader) : void 0;
+    throw new SurogatesRateLimitError(`${action} rate-limited`, {
+      status: response.status,
+      ...retryAfter !== void 0 && Number.isFinite(retryAfter) && { retryAfter },
+      ...detail !== void 0 && { detail }
+    });
+  }
+  if (response.status >= 500) {
+    throw new SurogatesNetworkError(
+      `${action} failed (${response.status}${detail ? `: ${detail}` : ""})`
+    );
+  }
+  throw new SurogatesProtocolError(`${action} failed (${response.status})`, {
+    status: response.status,
+    ...detail !== void 0 && { detail }
+  });
+}
+async function bootstrap(apiUrl, publishableKey) {
+  const response = await doFetch(apiUrl + PATH_BOOTSTRAP, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${publishableKey}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    await raiseForStatus(response, "Bootstrap");
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (cause) {
+    throw new SurogatesProtocolError("Bootstrap returned non-JSON body", { cause });
+  }
+  if (!body || typeof body.session_id !== "string" || typeof body.csrf_token !== "string") {
+    throw new SurogatesProtocolError("Bootstrap response missing required fields");
+  }
+  return {
+    sessionId: body.session_id,
+    csrfToken: body.csrf_token,
+    expiresAt: Number(body.expires_at) || 0,
+    agentName: body.agent_name ?? ""
+  };
+}
+async function sendMessage(apiUrl, sessionId, csrfToken, content) {
+  const response = await doFetch(apiUrl + PATH_MESSAGES(sessionId), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      [CSRF_HEADER]: csrfToken
+    },
+    body: JSON.stringify({ content })
+  });
+  if (!response.ok) {
+    await raiseForStatus(response, "Send message");
+  }
+  const body = await response.json().catch(() => ({}));
+  return { eventId: Number(body.event_id ?? 0) };
+}
+async function endSession(apiUrl, sessionId, csrfToken) {
+  try {
+    await doFetch(apiUrl + PATH_END(sessionId), {
+      method: "POST",
+      headers: { [CSRF_HEADER]: csrfToken }
+    });
+  } catch {
+  }
+}
+function openEventStream(apiUrl, sessionId, cursor) {
+  const url = apiUrl + PATH_EVENTS(sessionId, cursor);
+  return new EventSource(url, { withCredentials: true });
+}
+var END_OF_TURN_FINISH_REASONS = /* @__PURE__ */ new Set(["stop", "end_turn", "length"]);
+var CONTINUATION_FINISH_REASONS = /* @__PURE__ */ new Set(["tool_calls", "function_call", "tool_use"]);
+var Translator = class {
+  constructor() {
+    /**
+     * Tool calls that have been announced (``TOOL_CALL_CHUNK`` emitted)
+     * but have not yet received a matching ``tool.result``.  Non-empty
+     * means the turn is mid-execution even if an ``llm.response`` looks
+     * final.
+     */
+    this.pendingToolCalls = /* @__PURE__ */ new Set();
+    /** Set once we've seen an end-of-turn signal. */
+    this._turnComplete = false;
+  }
+  get isTurnComplete() {
+    return this._turnComplete;
+  }
+  /**
+   * Translate one SSE frame into zero or more AG-UI events.
+   *
+   * Returns an empty array when the frame carries no user-visible
+   * information (internal bookkeeping events like ``harness.wake``).
+   * Returns multiple events when a single Surogates event corresponds
+   * to a chunk triad that the AG-UI client can't reconstruct on its
+   * own -- though we try to use chunk events to keep this to one
+   * output event per input in the common path.
+   */
+  translate(frame) {
+    switch (frame.type) {
+      case SURG_EVENT.LLM_DELTA:
+        return this.handleLlmDelta(frame);
+      case SURG_EVENT.LLM_RESPONSE:
+        return this.handleLlmResponse(frame);
+      case SURG_EVENT.LLM_THINKING:
+        return this.handleLlmThinking(frame);
+      case SURG_EVENT.TOOL_CALL:
+        return this.handleToolCall(frame);
+      case SURG_EVENT.TOOL_RESULT:
+        return this.handleToolResult(frame);
+      case SURG_EVENT.POLICY_DENIED:
+        return this.handlePolicyDenied(frame);
+      case SURG_EVENT.EXPERT_DELEGATION:
+        return this.handleExpertDelegation(frame);
+      case SURG_EVENT.EXPERT_RESULT:
+        return this.handleExpertResult(frame);
+      case SURG_EVENT.EXPERT_FAILURE:
+        return this.asCustom(frame);
+      case SURG_EVENT.SESSION_FAIL:
+      case SURG_EVENT.HARNESS_CRASH:
+        return this.handleTerminalFailure(frame);
+      case SURG_EVENT.SESSION_DONE:
+      case SURG_EVENT.SESSION_COMPLETE:
+        this._turnComplete = true;
+        return [];
+      // Frames we do not surface to AG-UI consumers: internal
+      // orchestration (``user.message`` is already in the consumer's
+      // own ``agent.messages``; ``llm.request``, ``session.start``,
+      // ``sandbox.*``, ``harness.wake`` are implementation details).
+      case SURG_EVENT.USER_MESSAGE:
+      case SURG_EVENT.LLM_REQUEST:
+      case SURG_EVENT.SESSION_START:
+      case SURG_EVENT.SESSION_PAUSE:
+      case SURG_EVENT.SESSION_RESUME:
+      case SURG_EVENT.SANDBOX_PROVISION:
+      case SURG_EVENT.SANDBOX_EXECUTE:
+      case SURG_EVENT.SANDBOX_RESULT:
+      case SURG_EVENT.SANDBOX_DESTROY:
+      case SURG_EVENT.POLICY_ALLOWED:
+        return [];
+      // Everything else (``memory.update``, ``context.compact``,
+      // saga events, future server additions) is forwarded as CUSTOM
+      // so advanced consumers that want that visibility can still
+      // subscribe -- without us pre-committing to a particular AG-UI
+      // shape for a Surogates-specific event that might evolve.
+      default:
+        return this.asCustom(frame);
+    }
+  }
+  // ------------------------------------------------------------------
+  // Individual handlers
+  // ------------------------------------------------------------------
+  handleLlmDelta(frame) {
+    const payload = frame.data ?? {};
+    const delta = payload.delta ?? payload.content ?? "";
+    if (!delta) return [];
+    const messageId = this.currentMessageId ?? payload.message_id ?? this.mintMessageId(frame.id);
+    this.currentMessageId = messageId;
+    return [
+      {
+        type: EventType.TEXT_MESSAGE_CHUNK,
+        messageId,
+        role: "assistant",
+        delta
+      }
+    ];
+  }
+  handleLlmResponse(frame) {
+    const payload = frame.data ?? {};
+    const events = [];
+    if (!this.currentMessageId && payload.content) {
+      const messageId = payload.message_id ?? payload.id ?? this.mintMessageId(frame.id);
+      events.push({
+        type: EventType.TEXT_MESSAGE_CHUNK,
+        messageId,
+        role: "assistant",
+        delta: payload.content
+      });
+    }
+    this.currentMessageId = void 0;
+    const toolCalls = Array.isArray(payload.tool_calls) ? payload.tool_calls : [];
+    const finish = payload.finish_reason ?? payload.stop_reason ?? "";
+    if (CONTINUATION_FINISH_REASONS.has(finish)) {
+      return events;
+    }
+    const modelDone = toolCalls.length === 0 && (finish === "" || END_OF_TURN_FINISH_REASONS.has(finish));
+    if (modelDone && this.pendingToolCalls.size === 0) {
+      this._turnComplete = true;
+    }
+    return events;
+  }
+  handleLlmThinking(frame) {
+    const payload = frame.data ?? {};
+    const delta = payload.delta ?? payload.content ?? "";
+    if (!delta) return [];
+    const messageId = this.currentReasoningId ?? payload.message_id ?? this.mintMessageId(frame.id);
+    const isNew = this.currentReasoningId !== messageId;
+    this.currentReasoningId = messageId;
+    const events = [];
+    if (isNew) {
+      events.push({
+        type: EventType.REASONING_START,
+        messageId
+      });
+      events.push({
+        type: EventType.REASONING_MESSAGE_START,
+        messageId,
+        role: "reasoning"
+      });
+    }
+    events.push({
+      type: EventType.REASONING_MESSAGE_CONTENT,
+      messageId,
+      delta
+    });
+    return events;
+  }
+  handleToolCall(frame) {
+    const payload = frame.data ?? {};
+    const toolCallId = payload.tool_call_id ?? `tc-${frame.id}`;
+    const toolCallName = payload.name ?? "unknown_tool";
+    this.currentMessageId = void 0;
+    this.currentReasoningId = void 0;
+    this.pendingToolCalls.add(toolCallId);
+    const args = typeof payload.arguments === "string" ? payload.arguments : JSON.stringify(payload.arguments ?? {});
+    return [
+      {
+        type: EventType.TOOL_CALL_CHUNK,
+        toolCallId,
+        toolCallName,
+        delta: args
+      }
+    ];
+  }
+  handleToolResult(frame) {
+    const payload = frame.data ?? {};
+    const toolCallId = payload.tool_call_id ?? `tc-${frame.id}`;
+    const content = payload.content ?? "";
+    this.pendingToolCalls.delete(toolCallId);
+    return [
+      {
+        type: EventType.TOOL_CALL_RESULT,
+        messageId: `tr-${frame.id}`,
+        toolCallId,
+        content,
+        role: "tool"
+      }
+    ];
+  }
+  handlePolicyDenied(frame) {
+    const payload = frame.data ?? {};
+    return [
+      {
+        type: EventType.CUSTOM,
+        name: SURG_EVENT.POLICY_DENIED,
+        value: { tool: payload.tool, reason: payload.reason }
+      }
+    ];
+  }
+  handleExpertDelegation(frame) {
+    const payload = frame.data ?? {};
+    const name = payload.expert_name ?? "expert";
+    return [
+      {
+        type: EventType.STEP_STARTED,
+        stepName: `expert:${name}`
+      }
+    ];
+  }
+  handleExpertResult(frame) {
+    const payload = frame.data ?? {};
+    const name = payload.expert_name ?? "expert";
+    return [
+      {
+        type: EventType.STEP_FINISHED,
+        stepName: `expert:${name}`
+      }
+    ];
+  }
+  handleTerminalFailure(frame) {
+    this._turnComplete = true;
+    const payload = frame.data ?? {};
+    const message = payload.error ?? payload.message ?? `${frame.type} fired`;
+    return [
+      {
+        type: EventType.RUN_ERROR,
+        message,
+        code: frame.type
+      }
+    ];
+  }
+  asCustom(frame) {
+    return [
+      {
+        type: EventType.CUSTOM,
+        name: frame.type,
+        value: frame.data
+      }
+    ];
+  }
+  /**
+   * Generate a stable message id derived from the triggering frame's
+   * event id.  The event id is globally unique per session, so using
+   * it as a suffix guarantees uniqueness without pulling in ``uuid``.
+   */
+  mintMessageId(frameId) {
+    return `msg-${frameId}`;
+  }
+};
+
+// src/agent.ts
+var SURG_EVENT_NAMES = Object.values(SURG_EVENT);
+var DRAIN_WINDOW_MS = 250;
+var WebsiteAgent = class extends AbstractAgent {
+  constructor(config) {
+    super(config);
+    /** Monotonic cursor across runs.  Passed to the SSE ``?after=`` param. */
+    this.cursor = 0;
+    if (!config.apiUrl) {
+      throw new AGUIError('WebsiteAgent: "apiUrl" is required.');
+    }
+    if (!config.publishableKey) {
+      throw new AGUIError('WebsiteAgent: "publishableKey" is required.');
+    }
+    this.apiUrl = config.apiUrl.replace(/\/+$/, "");
+    this.publishableKey = config.publishableKey;
+  }
+  /**
+   * Ensure we have a live session cookie + CSRF token.
+   *
+   * Idempotent; returns the cached result when one already exists.
+   * ``bootstrap()`` is the only call that requires the publishable
+   * key to travel in an Authorization header, so callers that want
+   * to eagerly validate their configuration (e.g. to surface a
+   * setup error at widget-load time) can invoke this directly.
+   */
+  async ensureBootstrapped() {
+    if (this.bootstrapResult) return this.bootstrapResult;
+    this.bootstrapResult = await bootstrap(this.apiUrl, this.publishableKey);
+    return this.bootstrapResult;
+  }
+  /**
+   * Close the current session on the server side and drop local state.
+   *
+   * Callers should invoke this when the visitor closes the chat UI
+   * so the server can mark the session complete instead of waiting
+   * for the idle-reset timer.  Safe to call when no session has been
+   * bootstrapped yet.
+   */
+  async end() {
+    const current = this.bootstrapResult;
+    if (!current) return;
+    this.bootstrapResult = void 0;
+    this.cursor = 0;
+    await endSession(this.apiUrl, current.sessionId, current.csrfToken);
+  }
+  /**
+   * Implementation of the AG-UI ``run()`` contract.
+   *
+   * Returns a cold observable: one subscription per run.  AG-UI's
+   * ``runAgent`` pipeline pipes this through chunk transformation,
+   * verification, and subscriber notifications before updating
+   * ``this.messages``.
+   */
+  run(input) {
+    return new Observable((subscriber) => {
+      const ctx = {
+        terminated: false,
+        source: void 0,
+        drainTimer: void 0
+      };
+      void this.driveRun(input, subscriber, ctx).catch((err) => {
+        if (!ctx.terminated) {
+          ctx.terminated = true;
+          subscriber.error(err);
+        }
+      });
+      return () => {
+        ctx.terminated = true;
+        if (ctx.drainTimer !== void 0) return;
+        closeEventSource(ctx.source);
+        ctx.source = void 0;
+      };
+    });
+  }
+  /**
+   * Async body of the observable factory.
+   *
+   * Emits ``RUN_STARTED`` up front so every downstream failure is
+   * well-bracketed by the AG-UI lifecycle.  ``RUN_FINISHED`` is
+   * emitted by the SSE listeners when the translator detects end-of-
+   * turn; ``RUN_ERROR`` is emitted from the catch below when bootstrap
+   * or message-send fails before the SSE has any chance to close out.
+   *
+   * The ``ctx.terminated`` guard is the single enforcement point for
+   * AG-UI's "exactly one terminal event" invariant.  Every emission
+   * site checks it before calling ``subscriber.next`` with RUN_FINISHED
+   * or RUN_ERROR, and every terminal call sets it to true first.
+   */
+  async driveRun(input, subscriber, ctx) {
+    if (ctx.terminated) return;
+    subscriber.next({
+      type: EventType.RUN_STARTED,
+      threadId: input.threadId,
+      runId: input.runId
+    });
+    try {
+      const userText = this.extractUserText(input.messages);
+      const boot = await this.ensureBootstrapped();
+      this.replaceStreamSource(
+        ctx,
+        boot.sessionId,
+        this.cursor,
+        new Translator(),
+        subscriber,
+        input
+      );
+      await this.sendWithCookieRecovery(boot, userText, (fresh) => {
+        this.replaceStreamSource(
+          ctx,
+          fresh.sessionId,
+          0,
+          new Translator(),
+          subscriber,
+          input
+        );
+      });
+    } catch (err) {
+      if (ctx.terminated) return;
+      ctx.terminated = true;
+      const message = err instanceof Error ? err.message : String(err);
+      const code = err instanceof SurogatesAuthError ? "auth" : "error";
+      subscriber.next({
+        type: EventType.RUN_ERROR,
+        message,
+        code
+      });
+      closeEventSource(ctx.source);
+      ctx.source = void 0;
+      subscriber.complete();
+    }
+  }
+  /**
+   * Tear down whatever EventSource is currently live on ``ctx`` and
+   * open a fresh one against *sessionId* starting at *after*.  Called
+   * both for the initial stream and after cookie recovery.  Always
+   * clears the stale ``onerror`` first so the old source can't race
+   * a ``RUN_ERROR`` into the subscriber after it's been replaced.
+   */
+  replaceStreamSource(ctx, sessionId, after, translator, subscriber, input) {
+    closeEventSource(ctx.source);
+    const source = openEventStream(this.apiUrl, sessionId, after);
+    ctx.source = source;
+    this.attachStreamListeners(source, translator, subscriber, input, ctx);
+  }
+  /**
+   * Try ``sendMessage``; on auth failure re-bootstrap once and retry.
+   *
+   * The re-bootstrap mints a new session id, so the caller passes an
+   * ``onRebootstrap`` callback that reopens the SSE stream against the
+   * fresh session before the retry.  Visitor continuity across
+   * bootstraps is a deliberate non-feature for v1; the new session
+   * starts empty.  Only frames emitted on the OLD session between
+   * SSE-open and send-failure are lost -- and those are always
+   * previous-turn events, since the current turn's ``sendMessage`` is
+   * what 401-ed.
+   */
+  async sendWithCookieRecovery(boot, content, onRebootstrap) {
+    try {
+      await sendMessage(this.apiUrl, boot.sessionId, boot.csrfToken, content);
+      return;
+    } catch (err) {
+      if (!(err instanceof SurogatesAuthError)) throw err;
+      this.bootstrapResult = void 0;
+      this.cursor = 0;
+      const fresh = await this.ensureBootstrapped();
+      onRebootstrap(fresh);
+      await sendMessage(this.apiUrl, fresh.sessionId, fresh.csrfToken, content);
+    }
+  }
+  /**
+   * Wire up the EventSource to translate and forward every frame,
+   * and terminate the observable when the translator flags
+   * end-of-turn or a transport failure occurs.
+   *
+   * After the translator flips end-of-turn we emit ``RUN_FINISHED``
+   * immediately, then keep the stream open for ``DRAIN_WINDOW_MS``
+   * so trailing frames (late ``memory.update``, the sentinel
+   * ``session.done``) advance ``this.cursor`` rather than arriving
+   * on the next run.  The ``ctx.terminated`` gate stops additional
+   * subscriber emissions during the drain.
+   */
+  attachStreamListeners(source, translator, subscriber, input, ctx) {
+    const scheduleDrainClose = () => {
+      if (ctx.drainTimer !== void 0) globalThis.clearTimeout(ctx.drainTimer);
+      ctx.drainTimer = globalThis.setTimeout(() => {
+        ctx.drainTimer = void 0;
+        closeEventSource(source);
+      }, DRAIN_WINDOW_MS);
+    };
+    const finish = () => {
+      if (ctx.terminated) return;
+      ctx.terminated = true;
+      subscriber.next({
+        type: EventType.RUN_FINISHED,
+        threadId: input.threadId,
+        runId: input.runId
+      });
+      scheduleDrainClose();
+      subscriber.complete();
+    };
+    const handleFrame = (name, data, lastEventId) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        parsed = data;
+      }
+      const frame = {
+        id: Number(lastEventId) || 0,
+        type: name,
+        data: parsed
+      };
+      if (frame.id > this.cursor) this.cursor = frame.id;
+      if (ctx.terminated) return;
+      const events = translator.translate(frame);
+      for (const e of events) subscriber.next(e);
+      if (translator.isTurnComplete) finish();
+    };
+    for (const name of SURG_EVENT_NAMES) {
+      source.addEventListener(name, (ev) => {
+        handleFrame(name, ev.data, ev.lastEventId);
+      });
+    }
+    source.onerror = () => {
+      if (source.readyState !== 2) return;
+      if (ctx.terminated) return;
+      ctx.terminated = true;
+      subscriber.next({
+        type: EventType.RUN_ERROR,
+        message: "SSE connection closed",
+        code: "sse_closed"
+      });
+      subscriber.complete();
+    };
+  }
+  /**
+   * Find the last user-authored message body to post.  AG-UI supports
+   * multimodal content arrays; this v1 only handles string content
+   * (the website channel's ``POST /messages`` endpoint accepts plain
+   * text).  Multimodal support lands once the server grows a media
+   * upload path.
+   */
+  extractUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i];
+      if (!m || m.role !== "user") continue;
+      const content = m.content;
+      if (typeof content === "string" && content.trim().length > 0) {
+        return content;
+      }
+    }
+    throw new AGUIError(
+      "WebsiteAgent: no user message with string content found in input.messages."
+    );
+  }
+};
+function closeEventSource(source) {
+  if (!source) return;
+  try {
+    source.onerror = null;
+  } catch {
+  }
+  source.close();
+}
+
+export { PROTOCOL_VERSION, SDK_VERSION, SURG_EVENT, SurogatesAuthError, SurogatesError, SurogatesNetworkError, SurogatesProtocolError, SurogatesRateLimitError, Translator, WebsiteAgent };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map