@frontera-sdk/chat 1.52.45 → 1.52.47

package/dist/frontera-chat.iife.js

@@ -0,0 +1,27 @@
+"use strict";var FronteraChat=(()=>{var m=Object.defineProperty;var _=Object.getOwnPropertyDescriptor;var L=Object.getOwnPropertyNames;var B=Object.prototype.hasOwnProperty;var U=(e,r,t)=>r in e?m(e,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[r]=t;var M=(e,r)=>{for(var t in r)m(e,t,{get:r[t],enumerable:!0})},q=(e,r,t,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of L(r))!B.call(e,o)&&o!==t&&m(e,o,{get:()=>r[o],enumerable:!(n=_(r,o))||n.enumerable});return e};var H=e=>q(m({},"__esModule",{value:!0}),e);var d=(e,r,t)=>U(e,typeof r!="symbol"?r+"":r,t);var ie={};M(ie,{CHAT_ERROR_CODES:()=>R,FronteraChatElement:()=>h,PublicChat:()=>u,chatErrorCode:()=>g,defineFronteraChat:()=>w,mintPublicChatToken:()=>x,visitorErrorWords:()=>y});var p=class extends Error{constructor(t,n){super(t);d(this,"code");d(this,"status");d(this,"details");this.name="FronteraError",this.code=n.code,this.status=n.status,this.details=n.details}},T={400:"BAD_REQUEST",401:"UNAUTHORIZED",403:"FORBIDDEN",404:"NOT_FOUND",409:"CONFLICT",429:"RATE_LIMITED"};function G(e){return typeof e=="object"&&e!==null&&e.error===!0}function f(e,r){return G(r)?new p(r.message??`request failed with ${e}`,{code:r.code??T[e]??"INTERNAL_ERROR",status:e,details:r}):new p(`request failed with ${e}`,{code:T[e]??"INTERNAL_ERROR",status:e,details:r??void 0})}var R={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 g(e){let r=e instanceof p?e.code:null;return r&&r in R?r:"INTERNAL_ERROR"}function y(e){let r=g(e);return r==="RATE_LIMITED"&&e instanceof p?e.message:r==="UNAUTHORIZED"?"This chat stopped working. Reload the page to start again.":r==="FORBIDDEN"?"This chat isn\u2019t available on this page.":r==="QUOTA_EXCEEDED"||r==="SERVICE_UNAVAILABLE"?"The assistant is unavailable right now. Please try again later.":"The message couldn\u2019t be sent. Please try again."}function K(){return globalThis.__FRONTERA_CONFIG__??{}}function j(){return K()}function v(e){throw new p(`Frontera SDK is not configured: ${e} is missing. Pass it explicitly, or set the matching FRONTERA_* environment variable.`,{code:"CONFIG_MISSING"})}function C(e,r=typeof process>"u"?{}:process.env){let t=j(),n=e?.apiBaseUrl??t.apiBaseUrl??r.FRONTERA_API_URL;n||v("apiBaseUrl");let o=e?.credential??(r.FRONTERA_TOKEN?{kind:"apiKey",key:r.FRONTERA_TOKEN}:void 0);return o||v("credential"),{apiBaseUrl:n.replace(/\/+$/,""),orgId:e?.orgId??t.orgId??r.FRONTERA_ORG_ID,workspaceId:e?.workspaceId??t.workspaceId??r.FRONTERA_WORKSPACE_ID,credential:o}}function k(e){let t={authorization:`Bearer ${e.credential.kind==="apiKey"?e.credential.key:e.credential.token}`};return e.orgId&&(t["x-org-id"]=e.orgId),e.workspaceId&&(t["x-workspace-id"]=e.workspaceId),t}function $(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)&&e.error===!1&&"data"in e?e.data:e}function I(e){return e?Object.fromEntries(Object.entries(e).map(([r,t])=>[r.toLowerCase(),t])):{}}function O(e,r,t){let n=new URL(`${e.apiBaseUrl}${r.startsWith("/")?r:`/${r}`}`);if(t)for(let[o,s]of Object.entries(t))s!==void 0&&n.searchParams.set(o,String(s));return n.toString()}async function E(e,r,t={},n=fetch){let o={...I(t.headers),...k(e)},s=typeof FormData<"u"&&t.body instanceof FormData;t.body!==void 0&&!s&&(o["content-type"]="application/json");let a=await n(O(e,r,t.query),{method:t.method??"GET",headers:o,body:t.body===void 0?void 0:s?t.body:JSON.stringify(t.body),signal:t.signal});if(!a.ok){let c=await a.text(),i=null;if(c.length>0)try{i=JSON.parse(c)}catch{i=c}throw f(a.status,i)}return a}async function A(e,r,t={},n=fetch){let s=await(await E(e,r,t,n)).text();if(s.length===0)return null;try{return JSON.parse(s)}catch{return s}}async function F(e,r,t={},n=fetch){let o={...I(t.headers),...k(e),accept:"application/json"},s=typeof FormData<"u"&&t.body instanceof FormData;t.body!==void 0&&!s&&(o["content-type"]="application/json");let a=await n(O(e,r,t.query),{method:t.method??"GET",headers:o,body:t.body===void 0?void 0:s?t.body:JSON.stringify(t.body),signal:t.signal}),c=await a.text(),i=null;if(c.length>0)try{i=JSON.parse(c)}catch{i=c}if(!a.ok)throw f(a.status,i);return $(i)}var b=class e{constructor(r,t=fetch){d(this,"config");d(this,"fetchImpl");this.config=C(r),this.fetchImpl=t}request(r,t={}){return F(this.config,r,t,this.fetchImpl)}requestRaw(r,t={}){return E(this.config,r,t,this.fetchImpl)}requestEnvelope(r,t={}){return A(this.config,r,t,this.fetchImpl)}withCredential(r){return new e({...this.config,credential:r},this.fetchImpl)}};function W(){try{return typeof navigator>"u"?void 0:navigator.language||void 0}catch{return}}function J(e){return`frontera:visitor:${e.slice(0,12)}`}function z(){try{return typeof localStorage>"u"?null:localStorage}catch{return null}}function V(e,r){try{return e?.getItem(r)??null}catch{return null}}function Z(e,r,t){try{e?.setItem(r,t)}catch{}}async function x(e){let r=e.storage===void 0?z():e.storage,t=J(e.publishableKey),n=V(r,t),o=e.language??W(),s=await(e.fetchImpl??fetch)(`${e.apiBaseUrl}/v1/chat-tokens/public`,{method:"POST",headers:{"content-type":"application/json"},credentials:"omit",body:JSON.stringify({publishableKey:e.publishableKey,...n?{visitorPass:n}:{},...o?{language:o}:{}})}),a=await s.json().catch(()=>null);if(!s.ok||!a?.data)throw f(s.status,a);return a.data.visitorPass&&Z(r,t,a.data.visitorPass),{token:a.data.token,expiresAt:a.data.expiresAt,...a.data.openingMessage?{openingMessage:a.data.openingMessage}:{}}}async function N(e,r,t={}){let n=await e.requestRaw("/v1/chat",{method:"POST",body:r,signal:t.signal}),o=n.headers.get("x-conversation-id"),s=n.headers.get("x-workflow-run-id");if(!o||!s)throw new p("chat response is missing run identification headers",{code:"PROTOCOL_ERROR",status:n.status});return{conversationId:o,runId:s,runtime:n.headers.get("x-agent-runtime")??"pi",quotaWarning:n.headers.get("x-quota-warning")??void 0,response:n}}function P(){return typeof crypto<"u"&&"randomUUID"in crypto?crypto.randomUUID():`m-${Date.now()}-${Math.random().toString(36).slice(2)}`}async function*Q(e){if(!e.body)return;let r=e.body.getReader(),t=new TextDecoder,n="",o=a=>{let c=a.split(`
+`).filter(i=>i.startsWith("data:")).map(i=>i.slice(5).trimStart()).join(`
+`);if(!c||c==="[DONE]")return null;try{let i=JSON.parse(c);return i&&typeof i=="object"?i:null}catch{return null}};for(;;){let{done:a,value:c}=await r.read();c&&(n+=t.decode(c,{stream:!0}));let i=n.indexOf(`
+
+`);for(;i!==-1;){let l=o(n.slice(0,i));n=n.slice(i+2),l&&(yield l),i=n.indexOf(`
+
+`)}if(a)break}let s=o(n);s&&(yield s)}var u=class{constructor(r){d(this,"options",r);d(this,"token",null);d(this,"conversationId",null);d(this,"openingMessage",null);d(this,"opened",!1)}async open(){let r=await x({...this.options,...this.options.fetchImpl?{fetchImpl:this.options.fetchImpl}:{}});return this.token=r.token,this.opened||(this.openingMessage=r.openingMessage??null),this.opened=!0,{openingMessage:this.openingMessage}}client(){return new b({apiBaseUrl:this.options.apiBaseUrl,credential:{kind:"token",token:this.token}},this.options.fetchImpl??fetch)}messagesFor(r){let t={id:P(),role:"user",parts:[{type:"text",text:r}]};return this.conversationId||!this.openingMessage?[t]:[{id:P(),role:"assistant",parts:[{type:"text",text:this.openingMessage}]},t]}async*send(r,t){yield{type:"waiting"};let n;try{this.token||await this.open();let c=()=>N(this.client(),{messages:this.messagesFor(r),...this.conversationId?{conversationId:this.conversationId}:{}},{signal:t}),i;try{i=await c()}catch(l){if(g(l)!=="UNAUTHORIZED")throw l;await this.open(),i=await c()}this.conversationId=i.conversationId,n=i.response}catch(c){yield{type:"error",error:S(c)};return}let o=new Map,s=[],a=()=>s.map(c=>o.get(c)??"").filter(Boolean).join(`
+
+`);try{for await(let c of Q(n))if(c.type==="text-delta"&&typeof c.delta=="string"){let i=typeof c.id=="string"?c.id:"text";o.has(i)||s.push(i),o.set(i,(o.get(i)??"")+c.delta),yield{type:"text",text:a()}}else if(c.type==="error"){let i=typeof c.errorText=="string"?c.errorText:"The reply failed.";yield{type:"error",error:new p(i,{code:"INTERNAL_ERROR"})};return}}catch(c){yield{type:"error",error:S(c)};return}yield{type:"done"}}};function S(e){return e instanceof p?e:new p(e instanceof Error?e.message:String(e),{code:"INTERNAL_ERROR"})}var X=/\s?\[([^\]]*)\]\(\/cite\/[^)\s]*\)/g;function Y(e){return e.replace(X,(r,t)=>/^\s*\d+\s*$/.test(t)?"":r.startsWith(" ")?` ${t}`:t)}function ee(e){return/^(https?:\/\/|mailto:)/i.test(e.trim())?e.trim():null}var te=/\*\*([^*]+)\*\*|\[([^\]]+)\]\(([^)\s]+)\)/g;function re(e){let r=[],t=0;for(let n of e.matchAll(te)){if(n.index>t&&r.push({kind:"text",text:e.slice(t,n.index)}),n[1]!==void 0)r.push({kind:"bold",text:n[1]});else{let o=ee(n[3]);r.push(o?{kind:"link",text:n[2],href:o}:{kind:"text",text:n[2]})}t=n.index+n[0].length}return t<e.length&&r.push({kind:"text",text:e.slice(t)}),r}function D(e,r={}){return(r.showSources?e:Y(e)).split(/\n\s*\n/).map(n=>n.trim()).filter(Boolean).map(n=>n.split(`
+`).map(o=>re(o.replace(/^\s*[-*]\s+/,"\u2022 "))))}var ne=`
+: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; }
+`,oe=typeof HTMLElement>"u"?class{}:HTMLElement,h=class extends oe{constructor(){super(...arguments);d(this,"chat",null);d(this,"log");d(this,"input");d(this,"sendButton");d(this,"header");d(this,"busy",!1)}connectedCallback(){if(this.chat)return;let t=this.shadowRoot??this.attachShadow({mode:"open"}),n=this.ownerDocument,o=n.createElement("style");o.textContent=ne;let s=n.createElement("div");s.className="frame",this.header=n.createElement("header"),this.log=n.createElement("div"),this.log.className="log",this.log.setAttribute("role","log"),this.log.setAttribute("aria-live","polite");let a=n.createElement("form");this.input=n.createElement("textarea"),this.input.rows=1,this.input.setAttribute("aria-label","Message"),this.sendButton=n.createElement("button"),this.sendButton.type="submit",this.sendButton.textContent="Send",a.append(this.input,this.sendButton),s.append(this.header,this.log,a),t.replaceChildren(o,s),this.applyAttributes(),a.addEventListener("submit",l=>{l.preventDefault(),this.submit()}),this.input.addEventListener("keydown",l=>{l.key==="Enter"&&!l.shiftKey&&(l.preventDefault(),this.submit())});let c=this.getAttribute("api-base-url")?.replace(/\/+$/,""),i=this.getAttribute("publishable-key");if(!c||!i){this.note("This chat is missing its api-base-url or publishable-key."),this.setBusy(!0);return}this.chat=new u({apiBaseUrl:c,publishableKey:i}),this.chat.open().then(({openingMessage:l})=>{l&&this.agentBubble().replaceChildren(...this.render(l))}).catch(()=>{})}attributeChangedCallback(){this.header&&this.applyAttributes()}applyAttributes(){let t=this.getAttribute("chat-title");this.header.textContent=t??"",this.header.hidden=!t,this.input.placeholder=this.getAttribute("placeholder")??"Type a message"}setBusy(t){this.busy=t,this.sendButton.disabled=t}note(t){let n=this.ownerDocument.createElement("div");n.className="note",n.textContent=t,this.log.append(n)}agentBubble(){let t=this.ownerDocument.createElement("div");return t.className="msg agent",this.log.append(t),t}render(t){let n=this.ownerDocument;return D(t,{showSources:this.hasAttribute("show-sources")}).map(o=>{let s=n.createElement("p");return o.forEach((a,c)=>{c>0&&s.append(n.createElement("br"));for(let i of a)if(i.kind==="text")s.append(n.createTextNode(i.text));else if(i.kind==="bold"){let l=n.createElement("strong");l.textContent=i.text,s.append(l)}else{let l=n.createElement("a");l.href=i.href,l.textContent=i.text,l.target="_blank",l.rel="noopener noreferrer",s.append(l)}}),s})}async submit(){let t=this.input.value.trim();if(!t||this.busy||!this.chat)return;this.input.value="";let n=this.ownerDocument.createElement("div");n.className="msg visitor",n.textContent=t,this.log.append(n),this.setBusy(!0);let o=this.ownerDocument.createElement("div");o.className="typing",o.textContent="Typing\u2026";let s=null;try{for await(let a of this.chat.send(t))a.type==="waiting"?this.log.append(o):a.type==="text"?(o.remove(),s??(s=this.agentBubble()),s.replaceChildren(...this.render(a.text))):a.type==="error"&&(o.remove(),this.note(y(a.error)),this.dispatchEvent(new CustomEvent("frontera-chat-error",{detail:{code:a.error.code,message:a.error.message}}))),this.log.scrollTop=this.log.scrollHeight}finally{o.remove(),this.setBusy(!1),this.input.focus()}}};d(h,"observedAttributes",["chat-title","placeholder"]);function w(e="frontera-chat"){typeof customElements>"u"||customElements.get(e)||customElements.define(e,class extends h{})}w();return H(ie);})();
+//# sourceMappingURL=frontera-chat.iife.js.map

package/dist/hooks.d.ts

@@ -0,0 +1,88 @@
+import * as react from 'react';
+import { UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { ChatClient } from './chat-client.js';
+import { ListSessionsQuery, Session, CreateSessionRequest, PendingApproval, ApprovalDecision, SessionMessage, Paginated, UpdateSessionRequest } from './types.js';
+import '@frontera-sdk/core/client';
+import './stream.js';
+
+/**
+ * Query-key factory, same convention as `blueprintKeys`: requests serialise
+ * into the key so structurally equal requests share a cache entry.
+ */
+declare const chatKeys: {
+    all: readonly ["chat"];
+    sessions: (query?: ListSessionsQuery) => readonly ["chat", "sessions", string];
+    session: (id: string) => readonly ["chat", "session", string];
+    messages: (id: string) => readonly ["chat", "messages", string];
+    followUps: (conversationId: string, messageId: string) => readonly ["chat", "follow-ups", string, string];
+    approvals: (conversationId: string) => readonly ["chat", "approvals", string];
+};
+declare const FronteraChatContext: react.Context<ChatClient | null>;
+declare function useChatClient(): ChatClient;
+type ReadOptions<TData> = Omit<UseQueryOptions<TData, Error>, 'queryKey' | 'queryFn' | 'select'>;
+type WriteOptions<TData, TVariables> = Omit<UseMutationOptions<TData, Error, TVariables>, 'mutationFn'>;
+/**
+ * These hooks cover PERSISTED state (sessions, history). Live streaming state
+ * belongs to `useChat` from `@ai-sdk/react` with `createChatTransport` — there
+ * is deliberately no second streaming state machine here.
+ */
+declare function useSessions(query?: ListSessionsQuery, options?: ReadOptions<Paginated<Session>>): UseQueryResult<Paginated<Session>, Error>;
+declare function useSession(id: string, options?: ReadOptions<Session>): UseQueryResult<Session, Error>;
+declare function useSessionMessages(id: string, options?: ReadOptions<SessionMessage[]>): UseQueryResult<SessionMessage[], Error>;
+declare function useFollowUps(conversationId: string, messageId: string, options?: ReadOptions<{
+    suggestions: unknown[];
+}>): UseQueryResult<{
+    suggestions: unknown[];
+}, Error>;
+declare function useCreateSession(options?: WriteOptions<Session, CreateSessionRequest>): UseMutationResult<Session, Error, CreateSessionRequest>;
+declare function useUpdateSession(options?: WriteOptions<{
+    success: boolean;
+}, {
+    id: string;
+    patch: UpdateSessionRequest;
+}>): UseMutationResult<{
+    success: boolean;
+}, Error, {
+    id: string;
+    patch: UpdateSessionRequest;
+}>;
+/**
+ * The parked tool calls of one conversation.
+ *
+ * Polling is on by default while the tab is visible, and that is the point: an
+ * approval appears mid-run, from the agent's side, so a query that only ran on
+ * mount would leave the user staring at a stalled conversation. Pass
+ * `refetchInterval: false` if you drive it from the stream instead.
+ */
+declare function usePendingApprovals(conversationId: string, options?: ReadOptions<PendingApproval[]>): UseQueryResult<PendingApproval[], Error>;
+declare function useRespondToApproval(conversationId: string, options?: WriteOptions<{
+    id: string;
+    status: string;
+}, {
+    approvalId: string;
+    decision: ApprovalDecision;
+}>): UseMutationResult<{
+    id: string;
+    status: string;
+}, Error, {
+    approvalId: string;
+    decision: ApprovalDecision;
+}>;
+declare function useCancelRun(options?: WriteOptions<{
+    success: true;
+}, string>): UseMutationResult<{
+    success: true;
+}, Error, string>;
+declare function useSteerRun(options?: WriteOptions<{
+    success: true;
+}, {
+    runId: string;
+    message: string;
+}>): UseMutationResult<{
+    success: true;
+}, Error, {
+    runId: string;
+    message: string;
+}>;
+
+export { FronteraChatContext, chatKeys, useCancelRun, useChatClient, useCreateSession, useFollowUps, usePendingApprovals, useRespondToApproval, useSession, useSessionMessages, useSessions, useSteerRun, useUpdateSession };

package/dist/hooks.js

@@ -0,0 +1,3 @@
+export { FronteraChatContext, chatKeys, useCancelRun, useChatClient, useCreateSession, useFollowUps, usePendingApprovals, useRespondToApproval, useSession, useSessionMessages, useSessions, useSteerRun, useUpdateSession } from './chunk-CMMWTCYS.js';
+//# sourceMappingURL=hooks.js.map
+//# sourceMappingURL=hooks.js.map

package/dist/provider.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+import { FronteraClient } from '@frontera-sdk/core/client';
+
+/**
+ * Plug chat into `createFronteraApp` — Frontera Apps only:
+ *
+ * ```tsx
+ * createFronteraApp(<App />, { providers: [blueprintProvider, chatProvider] })
+ * ```
+ *
+ * External applications don't use this: they construct their own
+ * `FronteraClient` and either use `ChatClient` directly or wrap
+ * `FronteraChatContext.Provider` themselves. The client is rebuilt whenever
+ * the host rotates the credential, same as `blueprintProvider`.
+ */
+declare function chatProvider(value: {
+    client: FronteraClient;
+}, children: ReactNode): ReactNode;
+
+export { chatProvider };

package/dist/provider.js

@@ -0,0 +1,13 @@
+import { ChatClient } from './chunk-RLHHRJWS.js';
+import './chunk-VWUR3ECR.js';
+import './chunk-KZEGEV3P.js';
+import { FronteraChatContext } from './chunk-CMMWTCYS.js';
+import { jsx } from 'react/jsx-runtime';
+
+function chatProvider(value, children) {
+  return /* @__PURE__ */ jsx(FronteraChatContext.Provider, { value: new ChatClient(value.client), children });
+}
+
+export { chatProvider };
+//# sourceMappingURL=provider.js.map
+//# sourceMappingURL=provider.js.map

package/dist/public-chat.d.ts

@@ -0,0 +1,50 @@
+import { FronteraError } from '@frontera-sdk/core/errors';
+import { PublicChatTokenOptions } from './public-token.js';
+import './types.js';
+
+/**
+ * A website visitor's conversation without React or the AI SDK (Forge
+ * improvement plan L4): mint the visitor's token, send a message, read the
+ * reply as it arrives. `<frontera-chat>` is built on it; use it directly for a
+ * chat of your own design.
+ *
+ * Under the Agent's reply checks the platform holds a reply until it is
+ * checked, so it can arrive in one piece after a pause: `waiting` says the
+ * Agent is working, and the text follows once it may be shown.
+ */
+type PublicChatEvent = {
+    type: 'waiting';
+} | {
+    type: 'text';
+    text: string;
+} | {
+    type: 'done';
+} | {
+    type: 'error';
+    error: FronteraError;
+};
+interface PublicChatOptions extends Omit<PublicChatTokenOptions, 'fetchImpl'> {
+    /** Test seam. Defaults to the global. */
+    fetchImpl?: typeof fetch;
+}
+/** The JSON events of a chat's server-sent event stream, the keepalive comments and the terminator left out. */
+declare function chatEvents(response: Response): AsyncGenerator<Record<string, unknown>>;
+declare class PublicChat {
+    private readonly options;
+    private token;
+    private conversationId;
+    /** Shown before the first message; sent back with it, so the conversation keeps it. */
+    openingMessage: string | null;
+    private opened;
+    constructor(options: PublicChatOptions);
+    /** Mint the visitor's token, and learn the Agent's opening message. Called by `send` when needed. */
+    open(): Promise<{
+        openingMessage: string | null;
+    }>;
+    private client;
+    private messagesFor;
+    /** Send one message and read the reply: `waiting`, then the reply's text as it grows, then `done` (or `error`). */
+    send(text: string, signal?: AbortSignal): AsyncGenerator<PublicChatEvent>;
+}
+
+export { PublicChat, type PublicChatEvent, type PublicChatOptions, chatEvents };

package/dist/public-chat.js

@@ -0,0 +1,6 @@
+export { PublicChat, chatEvents } from './chunk-LS26G2N6.js';
+import './chunk-UCUVHMJC.js';
+import './chunk-KZEGEV3P.js';
+import './chunk-YKQ5Z5EK.js';
+//# sourceMappingURL=public-chat.js.map
+//# sourceMappingURL=public-chat.js.map

package/dist/public-token.d.ts

@@ -0,0 +1,46 @@
+import { ChatToken } from './types.js';
+
+/**
+ * Start a chat for an anonymous visitor of a public website, from the browser.
+ *
+ * A public website key (`fpk_…`) is made to sit in page JavaScript: it reaches
+ * one Agent, only from the origins listed on it, and only to mint a short-lived
+ * token that chats and does nothing else. So, unlike the server exchange in
+ * `auth.ts`, this runs where the visitor is and needs no backend of your own.
+ *
+ * The platform names the visitor, not the page. What comes back with the first
+ * token is a visitor pass; this keeps it in `localStorage` and shows it at the
+ * next mint, so a returning visitor gets their conversations back. Storage can
+ * be unavailable (a private window, blocked site data) — the chat then still
+ * works, and each page load is simply a new visitor.
+ */
+
+interface PublicChatTokenOptions {
+    /** Your deployment's API origin, for example `https://api.acme.example`. */
+    apiBaseUrl: string;
+    /** The Agent's public website key, `fpk_…`. */
+    publishableKey: string;
+    /** Test seam. Defaults to the global. */
+    fetchImpl?: typeof fetch;
+    /** Test seam. Defaults to `localStorage`, when there is one. */
+    storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'> | null;
+    /**
+     * The visitor's language (`en-GB`, `id`), for the Agent's opening message.
+     * Defaults to the browser's (`navigator.language`).
+     */
+    language?: string;
+}
+/** A visitor's token, with what the Agent says first when it has an opening message. */
+interface PublicChatToken extends ChatToken {
+    /**
+     * The Agent's opening message in the visitor's language, to show before they
+     * type. Send it back unchanged as an `assistant` message before the
+     * visitor's first message, and the conversation keeps it as the Agent's.
+     */
+    openingMessage?: string;
+}
+/** One pass per key, so two Agents on one site never share a visitor. */
+declare function visitorPassStorageKey(publishableKey: string): string;
+declare function mintPublicChatToken(options: PublicChatTokenOptions): Promise<PublicChatToken>;
+
+export { type PublicChatToken, type PublicChatTokenOptions, mintPublicChatToken, visitorPassStorageKey };

package/dist/public-token.js

@@ -0,0 +1,3 @@
+export { mintPublicChatToken, visitorPassStorageKey } from './chunk-UCUVHMJC.js';
+//# sourceMappingURL=public-token.js.map
+//# sourceMappingURL=public-token.js.map

package/dist/reply-text.d.ts

@@ -0,0 +1,25 @@
+/**
+ * An Agent's reply as a page without a Markdown renderer shows it (Forge
+ * improvement plan L4): citation links out unless the page shows sources,
+ * then paragraphs of plain text, bold and links. No HTML is ever produced
+ * from the reply; the element builds DOM nodes from these pieces.
+ */
+/** The reply without its citations: a numbered one goes, a named one keeps its name. */
+declare function withoutCitations(text: string): string;
+type ReplyPiece = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'bold';
+    text: string;
+} | {
+    kind: 'link';
+    text: string;
+    href: string;
+};
+/** Paragraphs (split on blank lines), each a list of lines, each line its pieces. */
+declare function replyParagraphs(text: string, options?: {
+    showSources?: boolean;
+}): ReplyPiece[][][];
+
+export { type ReplyPiece, replyParagraphs, withoutCitations };

package/dist/reply-text.js

@@ -0,0 +1,3 @@
+export { replyParagraphs, withoutCitations } from './chunk-W25Q2DQA.js';
+//# sourceMappingURL=reply-text.js.map
+//# sourceMappingURL=reply-text.js.map

package/dist/stream.d.ts

@@ -0,0 +1,25 @@
+import { FronteraClient } from '@frontera-sdk/core/client';
+import { StartChatRequest, StartChatResult } from './types.js';
+
+interface ChatStreamOptions {
+    signal?: AbortSignal;
+}
+/**
+ * Start a run. The returned `response.body` is an AI SDK v6 UI-message SSE
+ * stream — hand it to `readUIMessageStream` from `ai`, or use
+ * `createChatTransport` with `useChat` instead of calling this directly.
+ *
+ * The server interleaves `: ping` SSE comment frames every 15s as keepalive;
+ * standard SSE parsers (including the AI SDK's) ignore them.
+ */
+declare function startChat(client: FronteraClient, request: StartChatRequest, options?: ChatStreamOptions): Promise<StartChatResult>;
+/**
+ * Re-attach to a running (or just-finished) run's stream. `startIndex` is the
+ * journal index to replay from — pass the count of chunks already consumed to
+ * resume without duplicates.
+ */
+declare function resumeStream(client: FronteraClient, runId: string, options?: {
+    startIndex?: number;
+} & ChatStreamOptions): Promise<Response>;
+
+export { type ChatStreamOptions, resumeStream, startChat };

package/dist/stream.js

@@ -0,0 +1,3 @@
+export { resumeStream, startChat } from './chunk-KZEGEV3P.js';
+//# sourceMappingURL=stream.js.map
+//# sourceMappingURL=stream.js.map

package/dist/token-session.d.ts

@@ -0,0 +1,66 @@
+import { FronteraClient } from '@frontera-sdk/core/client';
+import { ChatToken } from './types.js';
+
+/**
+ * A chat credential that keeps itself alive.
+ *
+ * The alternative — what an integration writes by hand — is a timer that calls
+ * their own backend, plus a 401 handler, plus the knowledge that both are
+ * needed. Every one of those is a place to be subtly wrong: refresh too late
+ * and a send fails; forget the 401 path and a laptop reopened after lunch
+ * shows a chat that quietly cannot send.
+ *
+ * So the session owns it. It renews against the platform (one signature check,
+ * no round trip to the customer's backend), falls back to `getToken` when
+ * renewal is no longer allowed, and hands the current credential to whoever
+ * asks. Nothing else in the SDK needs to know a token can expire.
+ */
+
+interface TokenSessionOptions {
+    apiBaseUrl: string;
+    /**
+     * Fetches a token from YOUR backend. Called once at the start, and again
+     * whenever renewal is no longer possible — a session that has run past its
+     * ceiling, or a token that expired while the tab was asleep.
+     */
+    getToken: () => Promise<ChatToken | string>;
+    /**
+     * A token you already have — typically the one whose expiry told you which
+     * `apiBaseUrl` to use. Supplying it skips the opening fetch, so a mount does
+     * not mint twice for the same person.
+     */
+    initialToken?: ChatToken;
+    /**
+     * Renew this long before expiry, as a fraction of the token's lifetime.
+     * 0.8 leaves a fifth of the lifetime as slack — enough for a slow network or
+     * a suspended tab to recover without a single failed request.
+     */
+    renewAt?: number;
+    /** Called after every successful renewal. Handy for persisting the token. */
+    onToken?: (token: ChatToken) => void;
+    /**
+     * Called when the session cannot be kept alive at all — both renewal and
+     * `getToken` failed. The chat is dead until something changes, and the host
+     * is the only one that can say so on screen.
+     */
+    onExpired?: (error: unknown) => void;
+    /** Test seam. Defaults to the global. */
+    fetchImpl?: typeof fetch;
+}
+interface TokenSession {
+    /** The client to hand to `ChatClient` and `createChatTransport`. */
+    getClient: () => FronteraClient;
+    /** The credential right now, mostly for diagnostics. */
+    current: () => ChatToken | null;
+    /**
+     * Force a refresh — call it when a request comes back `UNAUTHORIZED`. Safe to
+     * call concurrently: overlapping callers share one in-flight refresh rather
+     * than racing to mint several tokens for the same person.
+     */
+    refresh: () => Promise<ChatToken>;
+    /** Stop the timer. Call it when the chat unmounts. */
+    dispose: () => void;
+}
+declare function createTokenSession(options: TokenSessionOptions): TokenSession;
+
+export { type TokenSession, type TokenSessionOptions, createTokenSession };

package/dist/token-session.js

@@ -0,0 +1,99 @@
+import { FronteraClient } from '@frontera-sdk/core/client';
+import { FronteraError } from '@frontera-sdk/core/errors';
+
+// src/token-session.ts
+var DEFAULT_RENEW_AT = 0.8;
+var MIN_DELAY_MS = 5e3;
+function asToken(value) {
+  return typeof value === "string" ? (
+    // A bare string has no expiry to plan around. Treated as one hour — the
+    // platform default — so the session still refreshes rather than waiting
+    // for a failure. Return the full object from your backend to be exact.
+    { token: value, expiresAt: new Date(Date.now() + 36e5).toISOString() }
+  ) : value;
+}
+function createTokenSession(options) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const renewAt = options.renewAt ?? DEFAULT_RENEW_AT;
+  let token = null;
+  let timer = null;
+  let inFlight = null;
+  let disposed = false;
+  const client = () => new FronteraClient(
+    {
+      apiBaseUrl: options.apiBaseUrl,
+      credential: { kind: "token", token: token?.token ?? "" }
+    },
+    fetchImpl
+  );
+  const schedule = (current) => {
+    if (timer) clearTimeout(timer);
+    if (disposed) return;
+    const lifetime = new Date(current.expiresAt).getTime() - Date.now();
+    if (!Number.isFinite(lifetime)) return;
+    const delay = Math.max(MIN_DELAY_MS, lifetime * renewAt);
+    timer = setTimeout(() => {
+      void refresh().catch(() => {
+      });
+    }, delay);
+    timer.unref?.();
+  };
+  const renew = async () => {
+    if (!token) throw new Error("no token to renew");
+    const response = await fetchImpl(`${options.apiBaseUrl}/v1/chat-tokens/renew`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token.token}` }
+    });
+    if (!response.ok) {
+      throw new FronteraError(`renewal refused with ${response.status}`, {
+        code: response.status === 401 ? "UNAUTHORIZED" : "RENEWAL_FAILED",
+        status: response.status
+      });
+    }
+    const body = await response.json();
+    return body.data ?? body;
+  };
+  const refresh = () => {
+    inFlight ??= (async () => {
+      try {
+        let next;
+        try {
+          next = token ? await renew() : asToken(await options.getToken());
+        } catch {
+          next = asToken(await options.getToken());
+        }
+        token = next;
+        options.onToken?.(next);
+        schedule(next);
+        return next;
+      } catch (error) {
+        options.onExpired?.(error);
+        throw error;
+      } finally {
+        inFlight = null;
+      }
+    })();
+    return inFlight;
+  };
+  if (options.initialToken) {
+    token = options.initialToken;
+    schedule(token);
+  } else {
+    void refresh().catch(() => {
+    });
+  }
+  return {
+    getClient: client,
+    current: () => token,
+    refresh,
+    dispose: () => {
+      disposed = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+    }
+  };
+}
+
+export { createTokenSession };
+//# sourceMappingURL=token-session.js.map
+//# sourceMappingURL=token-session.js.map

package/dist/transport.d.ts

@@ -0,0 +1,60 @@
+import { ChatTransport, UIMessage } from 'ai';
+import { FronteraClient } from '@frontera-sdk/core/client';
+import { StartChatRequest } from './types.js';
+
+/** The id of the Agent's opening message a chat shows before the person's first message (L4). */
+declare const OPENING_MESSAGE_ID = "frontera-opening";
+interface ChatTransportOptions {
+    /** Continue an existing conversation. Omit to let the server create one. */
+    conversationId?: string;
+    /**
+     * Send only the last user message (default true). The server rehydrates the
+     * rest of the conversation from its own store, which keeps request bodies
+     * small — the platform web app does the same.
+     */
+    lastMessageOnly?: boolean;
+    /**
+     * Extra body fields merged into every send (agentName, modelMode, …).
+     *
+     * Pass a FUNCTION for anything that can change while the chat is mounted.
+     * An object is read once, at construction: `useChat` keeps the transport it
+     * was first handed, so rebuilding this one with new options never reaches
+     * the request, and the send goes out with whatever was true at first render.
+     * That is how a conversation ends up with a different agent than the one on
+     * screen.
+     */
+    body?: Partial<Omit<StartChatRequest, 'messages' | 'conversationId'>> | (() => Partial<Omit<StartChatRequest, 'messages' | 'conversationId'>>);
+    /**
+     * Fired once per run with the identifiers from the response headers. The
+     * `runId` is what `resumeStream`/`cancelRun`/`steerRun` take, and
+     * `conversationId` is how a fresh conversation learns its id.
+     */
+    onStart?: (info: {
+        conversationId: string;
+        runId: string;
+        runtime: string;
+        quotaWarning?: string;
+    }) => void;
+    /**
+     * Called once when a request comes back `401`, before it is retried.
+     *
+     * Pass `session.refresh` from `createTokenSession` and an expired credential
+     * stops being a visible failure: the send is replayed with the new token and
+     * the person never learns there was one. Without it, a chat left open past
+     * the token's lifetime fails on the next message with nothing on screen
+     * explaining why.
+     */
+    onUnauthorized?: () => Promise<unknown>;
+}
+/**
+ * An AI SDK `ChatTransport` for `useChat` that speaks the platform's chat
+ * wire protocol: auth from the `FronteraClient`'s credential, last-message-only
+ * sends, and reconnects via the run's replay stream.
+ *
+ * Browser use requires a browser-safe credential (an end-user `cht_` token, or
+ * an `apiBaseUrl` pointing at your own proxy) — never ship a `sak_` key to a
+ * browser.
+ */
+declare function createChatTransport(client: FronteraClient | (() => FronteraClient), options?: ChatTransportOptions): ChatTransport<UIMessage>;
+
+export { type ChatTransportOptions, OPENING_MESSAGE_ID, createChatTransport };