@frontera-sdk/chat 1.52.45 → 1.52.47

package/dist/chunk-W25Q2DQA.js

@@ -0,0 +1,32 @@
+// src/reply-text.ts
+var CITATION = /\s?\[([^\]]*)\]\(\/cite\/[^)\s]*\)/g;
+function withoutCitations(text) {
+  return text.replace(CITATION, (match, label) => /^\s*\d+\s*$/.test(label) ? "" : match.startsWith(" ") ? ` ${label}` : label);
+}
+function safeHref(href) {
+  return /^(https?:\/\/|mailto:)/i.test(href.trim()) ? href.trim() : null;
+}
+var INLINE = /\*\*([^*]+)\*\*|\[([^\]]+)\]\(([^)\s]+)\)/g;
+function pieces(line) {
+  const out = [];
+  let at = 0;
+  for (const m of line.matchAll(INLINE)) {
+    if (m.index > at) out.push({ kind: "text", text: line.slice(at, m.index) });
+    if (m[1] !== void 0) out.push({ kind: "bold", text: m[1] });
+    else {
+      const href = safeHref(m[3]);
+      out.push(href ? { kind: "link", text: m[2], href } : { kind: "text", text: m[2] });
+    }
+    at = m.index + m[0].length;
+  }
+  if (at < line.length) out.push({ kind: "text", text: line.slice(at) });
+  return out;
+}
+function replyParagraphs(text, options = {}) {
+  const shown = options.showSources ? text : withoutCitations(text);
+  return shown.split(/\n\s*\n/).map((p) => p.trim()).filter(Boolean).map((p) => p.split("\n").map((line) => pieces(line.replace(/^\s*[-*]\s+/, "\u2022 "))));
+}
+
+export { replyParagraphs, withoutCitations };
+//# sourceMappingURL=chunk-W25Q2DQA.js.map
+//# sourceMappingURL=chunk-W25Q2DQA.js.map

package/dist/chunk-YKQ5Z5EK.js

@@ -0,0 +1,32 @@
+import { FronteraError } from '@frontera-sdk/core/errors';
+
+// src/chat-errors.ts
+var CHAT_ERROR_CODES = {
+  UNAUTHORIZED: "The key or token was not accepted: it is disabled, removed, mistyped or expired. Mint a new token; if that fails too, check the key.",
+  FORBIDDEN: "The credential may not do this: the page is not on the key\u2019s allowed websites, or a visitor asked for something a public chat cannot do.",
+  NOT_FOUND: "The conversation or run is not this credential\u2019s, or no longer exists.",
+  VALIDATION_ERROR: "The request was malformed, for example an empty message or more than five messages.",
+  RATE_LIMITED: "Too many messages or new chats in a short time. Wait the number of seconds the message names, then try again.",
+  QUOTA_EXCEEDED: "The organization\u2019s usage limit is reached. An administrator raises it.",
+  SERVICE_UNAVAILABLE: "The platform can\u2019t take the request right now. Try again shortly.",
+  INTERNAL_ERROR: "Something failed on the platform. Try again; if it keeps failing, the message names what to report.",
+  PROTOCOL_ERROR: "The response wasn\u2019t a chat stream: the API origin is likely wrong, or a proxy changed the response.",
+  FORBIDDEN_LOCAL: "Your own `authorizeConversation` callback denied access to the conversation.",
+  CONFIG_MISSING: "The client has no API origin or credential."
+};
+function chatErrorCode(err) {
+  const code = err instanceof FronteraError ? err.code : null;
+  return code && code in CHAT_ERROR_CODES ? code : "INTERNAL_ERROR";
+}
+function visitorErrorWords(err) {
+  const code = chatErrorCode(err);
+  if (code === "RATE_LIMITED" && err instanceof FronteraError) return err.message;
+  if (code === "UNAUTHORIZED") return "This chat stopped working. Reload the page to start again.";
+  if (code === "FORBIDDEN") return "This chat isn\u2019t available on this page.";
+  if (code === "QUOTA_EXCEEDED" || code === "SERVICE_UNAVAILABLE") return "The assistant is unavailable right now. Please try again later.";
+  return "The message couldn\u2019t be sent. Please try again.";
+}
+
+export { CHAT_ERROR_CODES, chatErrorCode, visitorErrorWords };
+//# sourceMappingURL=chunk-YKQ5Z5EK.js.map
+//# sourceMappingURL=chunk-YKQ5Z5EK.js.map

package/dist/connect-popup.d.ts

@@ -0,0 +1,150 @@
+import { ChatClient } from './chat-client.js';
+import { ResumeToolCallResult } from './types.js';
+import '@frontera-sdk/core/client';
+import './stream.js';
+
+/**
+ * The browser half of connecting an end user's own account.
+ *
+ * The server side of this flow is three calls (`startAppConnection`,
+ * `completeAppConnection`, `resumeToolCall`) with a consent screen in the
+ * middle. What is fiddly is not the calls — it is the middle: opening a popup,
+ * knowing when it came back, telling "the user finished" apart from "the user
+ * closed the window", and not leaving a listener attached forever when neither
+ * happens.
+ *
+ * That is what lives here. It is deliberately not part of `ChatClient`: the
+ * client is transport, and this touches `window`.
+ */
+
+/** What a callback page sends back to the window that opened it. */
+declare const CONNECT_MESSAGE_TYPE = "frontera:oauth-callback";
+interface ConnectCallbackMessage {
+    type: typeof CONNECT_MESSAGE_TYPE;
+    code?: string;
+    state?: string;
+    /** The provider's own refusal — the user pressed Cancel, typically. */
+    error?: string;
+}
+/**
+ * Call this FROM YOUR CALLBACK PAGE — the one you registered as the OAuth
+ * redirect URI. It is the page's entire implementation:
+ *
+ * ```ts
+ * // app/frontera/oauth/callback/page.tsx
+ * import { postConnectResultToOpener } from '@frontera-sdk/chat/connect-popup'
+ * postConnectResultToOpener(window.location.search)
+ * ```
+ *
+ * It handles both ways a connect can arrive back. In a popup it posts to the
+ * opener and closes. In a redirected tab — which is what mobile gets, because
+ * popups are blocked or mangled in iOS Safari and in-app browsers — there is no
+ * opener, so it navigates back to where the chat was with the result attached.
+ *
+ * `targetOrigin` defaults to this page's own origin, correct when the chat and
+ * the callback are the same app. Never `'*'`: the message carries an
+ * authorization code.
+ */
+declare function postConnectResultToOpener(search: string, targetOrigin?: string): void;
+interface RunAppConnectionOptions {
+    /**
+     * The parked call's id — what gets resumed once the account exists.
+     *
+     * Omit for a VOLUNTARY connect: someone connecting an account from the
+     * composer before asking anything has no parked call, and there is nothing
+     * to resume. The account still lands the same way; only the last step
+     * differs.
+     */
+    pendingToolCallId?: string;
+    /** Which app. Take `installId` from the parked call. */
+    installId?: string;
+    catalogKind?: string;
+    /** Your callback page, registered with your OAuth client AND allowlisted. */
+    redirectUri: string;
+    /**
+     * Origin the callback message must come from. Defaults to `redirectUri`'s
+     * origin, which is where your callback page runs.
+     */
+    expectedOrigin?: string;
+    /** How long to wait for the user before giving up. Default 5 minutes. */
+    timeoutMs?: number;
+    /** Popup geometry, if the defaults do not suit your layout. */
+    features?: string;
+    /**
+     * How to send the person to the provider.
+     *
+     * `auto` (default) tries a popup and falls back to redirecting this tab when
+     * the browser refuses one — which is the normal case on mobile: iOS Safari
+     * and in-app browsers (Instagram, LinkedIn, Slack) block or mangle
+     * `window.open`. A popup-only integration has a dead Connect button for
+     * every one of those users.
+     *
+     * `redirect` always navigates. `popup` never does, and reports the block.
+     */
+    mode?: 'auto' | 'popup' | 'redirect';
+    /**
+     * Where to come back to after a redirect. Defaults to the current URL, so
+     * the person lands where they left. Its ORIGIN must be on the workspace's
+     * embed allowlist.
+     */
+    returnTo?: string;
+}
+type RunAppConnectionResult = 
+/**
+ * The popup path completed here.
+ *
+ * `resume` is absent when nothing was parked — the plugins button connects
+ * an account with no tool call waiting on it, and the connect was the whole
+ * errand. Present only when a parked call was released by this connection.
+ */
+{
+    status: 'connected';
+    resume?: ResumeToolCallResult;
+} | {
+    status: 'cancelled';
+    reason: 'closed' | 'denied' | 'timeout';
+    error?: string;
+}
+/**
+ * The tab is navigating to the provider. Nothing after this call runs — the
+ * flow continues in `completeRedirectedConnection` when the person comes
+ * back.
+ */
+ | {
+    status: 'redirecting';
+};
+/**
+ * Run the whole thing: open the consent popup, wait for your callback to post
+ * the code back, exchange it, and re-run the parked tool call.
+ *
+ * Resolves rather than throwing when the person simply declines — a closed
+ * popup is an ordinary outcome and reads badly as an exception. Genuine
+ * failures (a refused start, a rejected exchange) still throw `FronteraError`
+ * with the server's code.
+ *
+ * The resume is included on purpose. Connecting without it leaves the agent
+ * exactly as blocked as before: it is waiting on a tool RESULT, not on an
+ * account.
+ */
+declare function runAppConnection(chat: ChatClient, options: RunAppConnectionOptions): Promise<RunAppConnectionResult>;
+/**
+ * Finish a connect that came back as a page load rather than a popup message.
+ *
+ * Call it once when your chat mounts. It does nothing — cheaply, synchronously
+ * — unless this page load is a return from a provider, so it is safe to call
+ * unconditionally:
+ *
+ * ```ts
+ * useEffect(() => { void completeRedirectedConnection(chat) }, [chat])
+ * ```
+ *
+ * Without it the redirect path stops one step short: the account gets
+ * connected and the parked tool call is never re-run, which looks exactly like
+ * the freeze the whole flow exists to prevent. It also tidies the query string,
+ * so a refresh does not try to redeem a code that is already spent.
+ */
+declare function completeRedirectedConnection(chat: ChatClient, options?: {
+    search?: string;
+}): Promise<RunAppConnectionResult | null>;
+
+export { CONNECT_MESSAGE_TYPE, type ConnectCallbackMessage, type RunAppConnectionOptions, type RunAppConnectionResult, completeRedirectedConnection, postConnectResultToOpener, runAppConnection };

package/dist/connect-popup.js

@@ -0,0 +1,138 @@
+// src/connect-popup.ts
+var CONNECT_MESSAGE_TYPE = "frontera:oauth-callback";
+var PENDING_KEY = "frontera:connect-pending";
+var RETURN_CODE = "frontera_code";
+var RETURN_STATE = "frontera_state";
+var RETURN_ERROR = "frontera_error";
+function postConnectResultToOpener(search, targetOrigin) {
+  const params = new URLSearchParams(search);
+  const code = params.get("code") ?? void 0;
+  const state = params.get("state") ?? void 0;
+  const error = params.get("error") ?? void 0;
+  if (window.opener) {
+    const message = { type: CONNECT_MESSAGE_TYPE, code, state, error };
+    window.opener.postMessage(message, targetOrigin ?? window.location.origin);
+    window.close();
+    return;
+  }
+  const pending = readPending();
+  const target = new URL(pending?.returnTo ?? window.location.origin);
+  if (code) target.searchParams.set(RETURN_CODE, code);
+  if (state) target.searchParams.set(RETURN_STATE, state);
+  if (error) target.searchParams.set(RETURN_ERROR, error);
+  window.location.replace(target.toString());
+}
+function readPending() {
+  try {
+    const raw = window.sessionStorage.getItem(PENDING_KEY);
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function writePending(value) {
+  try {
+    if (value) window.sessionStorage.setItem(PENDING_KEY, JSON.stringify(value));
+    else window.sessionStorage.removeItem(PENDING_KEY);
+  } catch {
+  }
+}
+var DEFAULT_TIMEOUT_MS = 5 * 6e4;
+var DEFAULT_FEATURES = "width=520,height=680,menubar=no,toolbar=no";
+async function runAppConnection(chat, options) {
+  const mode = options.mode ?? "auto";
+  const returnTo = options.returnTo ?? window.location.href;
+  const { authUrl } = await chat.startAppConnection({
+    installId: options.installId,
+    catalogKind: options.catalogKind,
+    redirectUri: options.redirectUri,
+    returnTo
+  });
+  const expectedOrigin = options.expectedOrigin ?? new URL(options.redirectUri).origin;
+  const goByRedirect = () => {
+    writePending({ pendingToolCallId: options.pendingToolCallId ?? null, returnTo });
+    window.location.assign(authUrl);
+    return { status: "redirecting" };
+  };
+  if (mode === "redirect") return goByRedirect();
+  const popup = window.open(authUrl, "frontera-connect", options.features ?? DEFAULT_FEATURES);
+  if (!popup) {
+    if (mode === "auto") return goByRedirect();
+    throw new Error(
+      "The connection window was blocked. Open it from a direct click, or allow popups for this site."
+    );
+  }
+  const outcome = await waitForCallback(popup, expectedOrigin, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  if (outcome.status !== "received") return { status: "cancelled", reason: outcome.reason, error: outcome.error };
+  await chat.completeAppConnection({ code: outcome.code, state: outcome.state });
+  if (!options.pendingToolCallId) return { status: "connected" };
+  const resume = await chat.resumeToolCall(options.pendingToolCallId);
+  return { status: "connected", resume };
+}
+async function completeRedirectedConnection(chat, options = {}) {
+  if (typeof window === "undefined") return null;
+  const params = new URLSearchParams(options.search ?? window.location.search);
+  const code = params.get(RETURN_CODE);
+  const state = params.get(RETURN_STATE);
+  const error = params.get(RETURN_ERROR);
+  if (!code && !state && !error) return null;
+  const pending = readPending();
+  writePending(null);
+  clearReturnParams(params);
+  if (error || !code || !state) {
+    return { status: "cancelled", reason: "denied", error: error ?? "callback carried no code" };
+  }
+  if (!pending) {
+    await chat.completeAppConnection({ code, state });
+    return { status: "connected", resume: { ok: true } };
+  }
+  await chat.completeAppConnection({ code, state });
+  if (!pending.pendingToolCallId) return { status: "connected" };
+  const resume = await chat.resumeToolCall(pending.pendingToolCallId);
+  return { status: "connected", resume };
+}
+function clearReturnParams(params) {
+  params.delete(RETURN_CODE);
+  params.delete(RETURN_STATE);
+  params.delete(RETURN_ERROR);
+  const query = params.toString();
+  window.history.replaceState(
+    window.history.state,
+    "",
+    `${window.location.pathname}${query ? `?${query}` : ""}${window.location.hash}`
+  );
+}
+function waitForCallback(popup, expectedOrigin, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled) return;
+      settled = true;
+      window.removeEventListener("message", onMessage);
+      clearInterval(closeTimer);
+      clearTimeout(timeoutTimer);
+      resolve(outcome);
+    };
+    const onMessage = (event) => {
+      if (event.origin !== expectedOrigin) return;
+      const data = event.data;
+      if (!data || data.type !== CONNECT_MESSAGE_TYPE) return;
+      if (data.error) return finish({ status: "cancelled", reason: "denied", error: data.error });
+      if (!data.code || !data.state) {
+        return finish({ status: "cancelled", reason: "denied", error: "callback carried no code" });
+      }
+      finish({ status: "received", code: data.code, state: data.state });
+    };
+    window.addEventListener("message", onMessage);
+    const closeTimer = setInterval(() => {
+      if (popup.closed) finish({ status: "cancelled", reason: "closed" });
+    }, 400);
+    const timeoutTimer = setTimeout(() => {
+      finish({ status: "cancelled", reason: "timeout" });
+    }, timeoutMs);
+  });
+}
+
+export { CONNECT_MESSAGE_TYPE, completeRedirectedConnection, postConnectResultToOpener, runAppConnection };
+//# sourceMappingURL=connect-popup.js.map
+//# sourceMappingURL=connect-popup.js.map

package/dist/doctor.d.ts

@@ -0,0 +1,71 @@
+/**
+ * A development-time watchdog for the ways a chat goes quiet.
+ *
+ * The failure this exists for looks like nothing at all: the agent stops
+ * mid-turn because it is waiting for a person, the integration does not render
+ * the card that would let them answer, and the run sits there until it lapses.
+ * No error, no rejected promise, no failed request — which is precisely why it
+ * reaches production. The first anyone hears of it is a user saying "it froze".
+ *
+ * So the SDK watches its own stream in development. When something parks and
+ * nothing settles it within a grace period, this says so, in the integrator's
+ * console, naming the call they are missing. Silence becomes a message at the
+ * moment it happens rather than a support ticket a week later.
+ *
+ * Off in production, always: it tees the response body to read it, and that is
+ * a cost worth paying for a warning nobody in production would see.
+ */
+type DoctorConcern = 'approval' | 'connect' | 'unauthorized';
+interface ChatDoctorOptions {
+    /** Force on or off. Defaults to on outside production. */
+    enabled?: boolean;
+    /**
+     * How long a parked run may go unanswered before it is worth mentioning.
+     *
+     * Long enough that a UI fetching its pending list on the next tick is never
+     * scolded; short enough to land while the developer is still looking at the
+     * screen that caused it.
+     */
+    graceMs?: number;
+    /** Where warnings go. Defaults to `console.warn`. */
+    onWarn?: (concern: DoctorConcern, message: string) => void;
+}
+declare class ChatDoctor {
+    private options;
+    private timers;
+    configure(options: ChatDoctorOptions): void;
+    get enabled(): boolean;
+    private warn;
+    /**
+     * Something parked. Start counting; `resolved` before the grace period ends
+     * cancels it.
+     */
+    parked(concern: DoctorConcern): void;
+    /** The integration did the thing. Nothing to warn about. */
+    resolved(concern: DoctorConcern): void;
+    /** Immediate, not timed: nothing about a missing refresh improves by waiting. */
+    noticed(concern: DoctorConcern): void;
+    /** For tests, and for a host that unmounts a chat mid-run. */
+    reset(): void;
+    /**
+     * Watch a chat stream for the two things that park a run.
+     *
+     * The body is teed rather than parsed: this reads a copy as text and matches
+     * two markers, leaving the real stream untouched for the AI SDK. A full parse
+     * here would be a second implementation of the protocol, kept in step with
+     * the first by hope.
+     */
+    observe(response: Response): Response;
+    private scan;
+}
+/**
+ * The instance the SDK reports into. Exported so a host can quieten it, widen
+ * the grace period, or route warnings into their own logger:
+ *
+ * ```ts
+ * chatDoctor.configure({ enabled: false })
+ * ```
+ */
+declare const chatDoctor: ChatDoctor;
+
+export { type ChatDoctorOptions, type DoctorConcern, chatDoctor };

package/dist/doctor.js

@@ -0,0 +1,3 @@
+export { chatDoctor } from './chunk-VWUR3ECR.js';
+//# sourceMappingURL=doctor.js.map
+//# sourceMappingURL=doctor.js.map

package/dist/element.d.ts

@@ -0,0 +1,23 @@
+declare const Base: typeof HTMLElement;
+declare class FronteraChatElement extends Base {
+    static observedAttributes: string[];
+    private chat;
+    private log;
+    private input;
+    private sendButton;
+    private header;
+    private busy;
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    private applyAttributes;
+    private setBusy;
+    private note;
+    private agentBubble;
+    /** The reply as paragraphs of text, bold and links, built as nodes: nothing from the reply becomes HTML. */
+    private render;
+    private submit;
+}
+/** Register the element under `tag` (once); the script-tag build calls it for you. */
+declare function defineFronteraChat(tag?: string): void;
+
+export { FronteraChatElement, defineFronteraChat };

package/dist/element.js

@@ -0,0 +1,175 @@
+import { PublicChat } from './chunk-LS26G2N6.js';
+import './chunk-UCUVHMJC.js';
+import { replyParagraphs } from './chunk-W25Q2DQA.js';
+import './chunk-KZEGEV3P.js';
+import { visitorErrorWords } from './chunk-YKQ5Z5EK.js';
+
+// src/element.ts
+var STYLE = `
+:host { display: block; height: 100%; font: 14px/1.45 var(--frontera-chat-font, system-ui, sans-serif); color: var(--frontera-chat-text, #1b1b1f); }
+.frame { display: flex; flex-direction: column; height: 100%; min-height: 320px; background: var(--frontera-chat-surface, #fff); border: 1px solid var(--frontera-chat-border, #e3e3e8); border-radius: var(--frontera-chat-radius, 12px); overflow: hidden; }
+header { padding: 12px 16px; font-weight: 600; border-bottom: 1px solid var(--frontera-chat-border, #e3e3e8); }
+.log { flex: 1; overflow-y: auto; padding: 16px; display: flex; flex-direction: column; gap: 10px; }
+.msg { max-width: 85%; padding: 8px 12px; border-radius: 12px; white-space: normal; overflow-wrap: anywhere; }
+.msg p { margin: 0 0 8px; } .msg p:last-child { margin: 0; }
+.agent { align-self: flex-start; background: var(--frontera-chat-agent-bubble, #f1f1f4); }
+.visitor { align-self: flex-end; background: var(--frontera-chat-accent, #2f5bea); color: var(--frontera-chat-accent-text, #fff); }
+.note { align-self: center; font-size: 12px; color: var(--frontera-chat-muted, #6b6b76); }
+.typing { align-self: flex-start; color: var(--frontera-chat-muted, #6b6b76); font-size: 12px; }
+a { color: inherit; }
+form { display: flex; gap: 8px; padding: 12px; border-top: 1px solid var(--frontera-chat-border, #e3e3e8); }
+textarea { flex: 1; resize: none; font: inherit; padding: 8px 10px; border: 1px solid var(--frontera-chat-border, #e3e3e8); border-radius: 8px; min-height: 20px; max-height: 120px; }
+button { font: inherit; padding: 0 14px; border: 0; border-radius: 8px; background: var(--frontera-chat-accent, #2f5bea); color: var(--frontera-chat-accent-text, #fff); cursor: pointer; }
+button:disabled { opacity: .5; cursor: default; }
+`;
+var Base = typeof HTMLElement === "undefined" ? class {
+} : HTMLElement;
+var FronteraChatElement = class extends Base {
+  static observedAttributes = ["chat-title", "placeholder"];
+  chat = null;
+  log;
+  input;
+  sendButton;
+  header;
+  busy = false;
+  connectedCallback() {
+    if (this.chat) return;
+    const root = this.shadowRoot ?? this.attachShadow({ mode: "open" });
+    const doc = this.ownerDocument;
+    const style = doc.createElement("style");
+    style.textContent = STYLE;
+    const frame = doc.createElement("div");
+    frame.className = "frame";
+    this.header = doc.createElement("header");
+    this.log = doc.createElement("div");
+    this.log.className = "log";
+    this.log.setAttribute("role", "log");
+    this.log.setAttribute("aria-live", "polite");
+    const form = doc.createElement("form");
+    this.input = doc.createElement("textarea");
+    this.input.rows = 1;
+    this.input.setAttribute("aria-label", "Message");
+    this.sendButton = doc.createElement("button");
+    this.sendButton.type = "submit";
+    this.sendButton.textContent = "Send";
+    form.append(this.input, this.sendButton);
+    frame.append(this.header, this.log, form);
+    root.replaceChildren(style, frame);
+    this.applyAttributes();
+    form.addEventListener("submit", (e) => {
+      e.preventDefault();
+      void this.submit();
+    });
+    this.input.addEventListener("keydown", (e) => {
+      if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        void this.submit();
+      }
+    });
+    const apiBaseUrl = this.getAttribute("api-base-url")?.replace(/\/+$/, "");
+    const publishableKey = this.getAttribute("publishable-key");
+    if (!apiBaseUrl || !publishableKey) {
+      this.note("This chat is missing its api-base-url or publishable-key.");
+      this.setBusy(true);
+      return;
+    }
+    this.chat = new PublicChat({ apiBaseUrl, publishableKey });
+    this.chat.open().then(({ openingMessage }) => {
+      if (openingMessage) this.agentBubble().replaceChildren(...this.render(openingMessage));
+    }).catch(() => {
+    });
+  }
+  attributeChangedCallback() {
+    if (this.header) this.applyAttributes();
+  }
+  applyAttributes() {
+    const title = this.getAttribute("chat-title");
+    this.header.textContent = title ?? "";
+    this.header.hidden = !title;
+    this.input.placeholder = this.getAttribute("placeholder") ?? "Type a message";
+  }
+  setBusy(busy) {
+    this.busy = busy;
+    this.sendButton.disabled = busy;
+  }
+  note(text) {
+    const el = this.ownerDocument.createElement("div");
+    el.className = "note";
+    el.textContent = text;
+    this.log.append(el);
+  }
+  agentBubble() {
+    const el = this.ownerDocument.createElement("div");
+    el.className = "msg agent";
+    this.log.append(el);
+    return el;
+  }
+  /** The reply as paragraphs of text, bold and links, built as nodes: nothing from the reply becomes HTML. */
+  render(text) {
+    const doc = this.ownerDocument;
+    return replyParagraphs(text, { showSources: this.hasAttribute("show-sources") }).map((lines) => {
+      const p = doc.createElement("p");
+      lines.forEach((pieces, i) => {
+        if (i > 0) p.append(doc.createElement("br"));
+        for (const piece of pieces) {
+          if (piece.kind === "text") p.append(doc.createTextNode(piece.text));
+          else if (piece.kind === "bold") {
+            const b = doc.createElement("strong");
+            b.textContent = piece.text;
+            p.append(b);
+          } else {
+            const a = doc.createElement("a");
+            a.href = piece.href;
+            a.textContent = piece.text;
+            a.target = "_blank";
+            a.rel = "noopener noreferrer";
+            p.append(a);
+          }
+        }
+      });
+      return p;
+    });
+  }
+  async submit() {
+    const text = this.input.value.trim();
+    if (!text || this.busy || !this.chat) return;
+    this.input.value = "";
+    const mine = this.ownerDocument.createElement("div");
+    mine.className = "msg visitor";
+    mine.textContent = text;
+    this.log.append(mine);
+    this.setBusy(true);
+    const typing = this.ownerDocument.createElement("div");
+    typing.className = "typing";
+    typing.textContent = "Typing\u2026";
+    let bubble = null;
+    try {
+      for await (const event of this.chat.send(text)) {
+        if (event.type === "waiting") this.log.append(typing);
+        else if (event.type === "text") {
+          typing.remove();
+          bubble ??= this.agentBubble();
+          bubble.replaceChildren(...this.render(event.text));
+        } else if (event.type === "error") {
+          typing.remove();
+          this.note(visitorErrorWords(event.error));
+          this.dispatchEvent(new CustomEvent("frontera-chat-error", { detail: { code: event.error.code, message: event.error.message } }));
+        }
+        this.log.scrollTop = this.log.scrollHeight;
+      }
+    } finally {
+      typing.remove();
+      this.setBusy(false);
+      this.input.focus();
+    }
+  }
+};
+function defineFronteraChat(tag = "frontera-chat") {
+  if (typeof customElements === "undefined" || customElements.get(tag)) return;
+  customElements.define(tag, class extends FronteraChatElement {
+  });
+}
+
+export { FronteraChatElement, defineFronteraChat };
+//# sourceMappingURL=element.js.map
+//# sourceMappingURL=element.js.map