@frontera-sdk/chat 1.52.45 → 1.52.47

package/dist/auth.d.ts

@@ -0,0 +1,20 @@
+import { FronteraClient } from '@frontera-sdk/core/client';
+import { ExchangeTokenRequest, ChatToken } from './types.js';
+
+/**
+ * Exchange an agent API key (`sak_`) plus your user's identity for a
+ * short-lived scoped chat token (`cht_`). Server-side only: the client passed
+ * here must carry the `sak_` credential, which must never reach a browser.
+ *
+ * The token is safe to hand to your frontend — it is scoped to one workspace,
+ * one agent and one external user, and Sebati enforces session isolation per
+ * external user.
+ *
+ * Requires a deployment with the `/v1/chat-tokens` endpoint; older deployments
+ * answer 404, surfaced as a `FronteraError` with code `NOT_FOUND`.
+ */
+declare function exchangeChatToken(client: FronteraClient, request: ExchangeTokenRequest): Promise<ChatToken>;
+/** A client that authenticates with the exchanged end-user token. */
+declare function withChatToken(client: FronteraClient, token: ChatToken): FronteraClient;
+
+export { exchangeChatToken, withChatToken };

package/dist/auth.js

@@ -0,0 +1,11 @@
+// src/auth.ts
+function exchangeChatToken(client, request) {
+  return client.request("/v1/chat-tokens", { method: "POST", body: request });
+}
+function withChatToken(client, token) {
+  return client.withCredential({ kind: "token", token: token.token });
+}
+
+export { exchangeChatToken, withChatToken };
+//# sourceMappingURL=auth.js.map
+//# sourceMappingURL=auth.js.map

package/dist/callback-page.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The OAuth callback page, as a string of HTML.
+ *
+ * The callback has to live on YOUR domain — a provider only authorises
+ * redirect URIs under a domain its project owner has verified — so this is one
+ * page every integration must host, and the only page in the whole flow they
+ * cannot get from us pre-built. What it does is small and entirely mechanical:
+ * take `code` and `state` off its own URL and hand them back to the chat.
+ *
+ * So we ship the mechanism instead of the instructions. Any JS server can
+ * serve this — a Next route handler, Express, Hono, Fastify, Workers, Bun,
+ * Deno — and a backend in another language can serve the same markup as a
+ * static file (`bunx frontera-chat-callback > callback.html`, or copy it from
+ * the docs).
+ *
+ * No import runs on the page itself: the script is inlined, because a callback
+ * page that has to load a bundle is a callback page that can fail to load one
+ * while holding an authorization code.
+ */
+interface ConnectCallbackPageOptions {
+    /**
+     * Origin allowed to receive the code in popup mode. Defaults to the page's
+     * own origin, correct when the chat and the callback are the same app.
+     *
+     * Never `'*'`. The message carries an authorization code, and any page that
+     * can guess your callback could otherwise listen for it.
+     */
+    targetOrigin?: string;
+    /** Shown while the page does its work. Replace it to match your product. */
+    message?: string;
+    /** Fallback when a redirect return has no stored address. Defaults to `/`. */
+    fallbackReturnTo?: string;
+}
+declare function renderConnectCallbackPage(options?: ConnectCallbackPageOptions): string;
+/**
+ * A `Response` carrying the page, for any runtime with the Fetch API.
+ *
+ * ```ts
+ * // Next.js — app/oauth/callback/route.ts
+ * export const GET = () => connectCallbackResponse()
+ * ```
+ *
+ * `no-store` matters: this page is only ever loaded with a single-use code in
+ * the query string, and a cached copy is a stale code waiting to confuse
+ * someone.
+ */
+declare function connectCallbackResponse(options?: ConnectCallbackPageOptions): Response;
+
+export { type ConnectCallbackPageOptions, connectCallbackResponse, renderConnectCallbackPage };

package/dist/callback-page.js

@@ -0,0 +1,84 @@
+// src/callback-page.ts
+var DEFAULT_MESSAGE = "Finishing up\u2026";
+function jsLiteral(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function renderConnectCallbackPage(options = {}) {
+  const targetOrigin = options.targetOrigin ? jsLiteral(options.targetOrigin) : "location.origin";
+  const fallback = jsLiteral(options.fallbackReturnTo ?? "/");
+  const message = (options.message ?? DEFAULT_MESSAGE).replace(
+    /[<>&]/g,
+    (c) => c === "<" ? "&lt;" : c === ">" ? "&gt;" : "&amp;"
+  );
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="robots" content="noindex">
+<title>Connecting\u2026</title>
+<style>
+  body {
+    margin: 0; min-height: 100vh;
+    display: flex; align-items: center; justify-content: center;
+    font: 15px/1.5 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+    color: #16201f; background: #fbfbfa;
+  }
+  @media (prefers-color-scheme: dark) { body { color: #e6ecea; background: #0e1413; } }
+  p { opacity: .7; }
+</style>
+</head>
+<body>
+<p>${message}</p>
+<script>
+(function () {
+  var params = new URLSearchParams(location.search);
+  var payload = {
+    type: 'frontera:oauth-callback',
+    code: params.get('code') || undefined,
+    state: params.get('state') || undefined,
+    error: params.get('error') || undefined
+  };
+
+  // Popup: hand the result to the window that opened us, then get out of the
+  // way. The origin is pinned \u2014 this message carries an authorization code.
+  if (window.opener) {
+    try { window.opener.postMessage(payload, ${targetOrigin}); } catch (e) {}
+    window.close();
+    return;
+  }
+
+  // Redirected tab \u2014 the normal path on mobile, where popups are blocked. The
+  // chat parked its return address before leaving, because the redirect URI is
+  // registered with the provider and cannot carry one.
+  var returnTo = ${fallback};
+  try {
+    var pending = JSON.parse(sessionStorage.getItem('frontera:connect-pending') || 'null');
+    if (pending && pending.returnTo) returnTo = pending.returnTo;
+  } catch (e) {}
+
+  var target = new URL(returnTo, location.origin);
+  if (payload.code) target.searchParams.set('frontera_code', payload.code);
+  if (payload.state) target.searchParams.set('frontera_state', payload.state);
+  if (payload.error) target.searchParams.set('frontera_error', payload.error);
+  location.replace(target.toString());
+})();
+<\/script>
+</body>
+</html>`;
+}
+function connectCallbackResponse(options = {}) {
+  return new Response(renderConnectCallbackPage(options), {
+    headers: {
+      "content-type": "text/html; charset=utf-8",
+      "cache-control": "no-store",
+      // The page is not meant to be embedded, and framing it would put an
+      // authorization code inside someone else's document.
+      "x-frame-options": "DENY"
+    }
+  });
+}
+
+export { connectCallbackResponse, renderConnectCallbackPage };
+//# sourceMappingURL=callback-page.js.map
+//# sourceMappingURL=callback-page.js.map

package/dist/chat-client.d.ts

@@ -0,0 +1,221 @@
+import { FronteraClient } from '@frontera-sdk/core/client';
+import { ChatStreamOptions } from './stream.js';
+import { ChatClientOptions, StartChatRequest, StartChatResult, PendingApproval, ApprovalDecision, StartAppConnectionRequest, StartAppConnectionResult, CompleteAppConnectionRequest, CompleteAppConnectionResult, ResumeToolCallResult, ChatAgent, UploadedFile, Paginated, ChatArtifact, ArtifactVersionMeta, ListSessionsQuery, Session, CreateSessionRequest, SessionMessage, UpdateSessionRequest } from './types.js';
+
+/**
+ * Domain client for the chat surface, in the mould of `BlueprintClient`: one
+ * thin method per endpoint over a `FronteraClient`.
+ *
+ * `authorizeConversation` exists because under API-key auth the SERVER SKIPS
+ * conversation ownership checks — any conversation id under the key's agent is
+ * accepted. A backend serving several of its own users must therefore gate
+ * conversation access itself; wiring that gate in here means every access path
+ * goes through it. Methods throw `FronteraError` code `FORBIDDEN_LOCAL` when
+ * the callback denies. Under an end-user `cht_` token the server enforces
+ * isolation and the callback is unnecessary.
+ */
+declare class ChatClient {
+    private readonly client;
+    private readonly options;
+    constructor(client: FronteraClient, options?: ChatClientOptions);
+    private authorize;
+    /** Start (or continue) a run. See `stream.ts` for stream semantics. */
+    startChat(request: StartChatRequest, options?: ChatStreamOptions): Promise<StartChatResult>;
+    /**
+     * Re-attach to a run's stream. Run ids are capabilities: they only leave the
+     * server through a response the caller was already authorized to receive, so
+     * there is no conversation gate here — treat them accordingly.
+     */
+    resumeStream(runId: string, options?: {
+        startIndex?: number;
+    } & ChatStreamOptions): Promise<Response>;
+    cancelRun(runId: string): Promise<{
+        success: true;
+    }>;
+    steerRun(runId: string, message: string): Promise<{
+        success: true;
+    }>;
+    /**
+     * The tool calls this conversation has parked, waiting on a person.
+     *
+     * Poll or call this on mount: a run blocked on an approval stays blocked
+     * across a page reload, and the `tool-approval-request` chunk that announced
+     * it is not replayed by a fresh `useChat`. Without reading them back, the
+     * conversation looks like an agent that stopped for no reason.
+     *
+     * End-user (`cht_`) tokens only — see `respondToApproval`.
+     */
+    listPendingApprovals(conversationId: string): Promise<PendingApproval[]>;
+    /**
+     * Approve or deny a parked tool call, releasing (or refusing) the run.
+     *
+     * Requires an end-user `cht_` token: the decision is recorded against the
+     * person who made it, and an `sak_` key is one credential shared by every
+     * user of your product — there is nobody it could be deciding as, so the
+     * server answers 403 (`FORBIDDEN`). An integration that wants its agent to
+     * act unattended sets the agent's approval mode to `auto` instead.
+     *
+     * Deciding twice is not an error: the first decision wins and this reports
+     * the settled status. A lapsed request answers `expired`.
+     */
+    respondToApproval(approvalId: string, decision: ApprovalDecision): Promise<{
+        id: string;
+        status: string;
+    }>;
+    /**
+     * Begin connecting the end user's own account for a parked `needs_connect`
+     * call, and get the URL to send them to.
+     *
+     * Three things must line up before this answers, and all three are one-time
+     * setup rather than per-user work:
+     *   1. the workspace has ITS OWN OAuth client for the provider (the
+     *      deployment-managed one cannot serve this — your users are authorising
+     *      your application, and only its owner can register your callback);
+     *   2. `redirectUri` is registered with that client AND on the workspace's
+     *      embed allowlist;
+     *   3. the install allows external users, and this user's token carries the
+     *      `plugin-connect` capability you granted when you minted it.
+     *
+     * Open the returned `authUrl` in a popup. Your callback receives `code` and
+     * `state` — hand them to `completeAppConnection`, then `resumeToolCall`.
+     */
+    startAppConnection(request: StartAppConnectionRequest): Promise<StartAppConnectionResult>;
+    /**
+     * Finish a connect from the code your own callback received.
+     *
+     * `state` is signed by us and names the install, the user and the redirect
+     * URI, so none of the three can be swapped between the authorize request and
+     * this call. Pass it back exactly as it arrived.
+     */
+    completeAppConnection(request: CompleteAppConnectionRequest): Promise<CompleteAppConnectionResult>;
+    /**
+     * Re-run the tool call that was waiting on the connection.
+     *
+     * Not optional: the agent is blocked on a tool RESULT, not on an account, so
+     * a connect without this leaves the conversation exactly as stuck as before.
+     */
+    resumeToolCall(pendingToolCallId: string): Promise<ResumeToolCallResult>;
+    /**
+     * The agents this credential may talk to — what an agent picker renders.
+     *
+     * Scoped to the credential, so a token bound to one agent lists exactly that
+     * agent while a workspace-wide token lists them all. The Console listing is
+     * session-only and returns configuration an end user has no business seeing,
+     * which is why this exists separately.
+     */
+    listAgents(): Promise<ChatAgent[]>;
+    /**
+     * Upload a file for this user, then reference the result in
+     * `startChat({ fileAttachments: [uploaded] })`.
+     *
+     * A chat-scoped route, not the platform's `/v1/upload`: that one authorises
+     * through workspace membership, which an end user of a customer's product
+     * does not have and should not need.
+     */
+    upload(file: File | Blob, filename?: string): Promise<UploadedFile>;
+    /**
+     * A live URL for a stored upload.
+     *
+     * The URL saved on a message is presigned and expires about an hour after
+     * upload, so anything rendered later re-signs from the stored path — without
+     * this, attachments in yesterday's messages become broken images.
+     */
+    signUpload(storagePath: string): Promise<string>;
+    /** The artifacts this user owns — documents, decks and images the agent made. */
+    listArtifacts(query?: {
+        search?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<Paginated<ChatArtifact>>;
+    getArtifact(id: string): Promise<ChatArtifact>;
+    /**
+     * The artifact's contents as TEXT.
+     *
+     * Only for artifacts that are text — markdown, csv, code. Reading a PNG or a
+     * spreadsheet through here destroys it: `.text()` decodes the bytes as UTF-8,
+     * and every byte that is not valid UTF-8 becomes a replacement character on
+     * the way. Use `getArtifactFile` for anything binary.
+     */
+    getArtifactContent(id: string): Promise<string>;
+    /**
+     * The artifact's raw bytes, with the server's own content type.
+     *
+     * The Blob carries the type the route reported rather than one guessed from
+     * the format, so an <img> or a PDF reader gets what it needs without the
+     * caller restating it — and a wrong guess here is an image that silently
+     * will not display.
+     */
+    getArtifactFile(id: string): Promise<Blob>;
+    /**
+     * A PDF rendering of an artifact a browser cannot open itself.
+     *
+     * `.docx` and `.pptx` are bytes with no source to fall back on, so the
+     * service renders a PDF beside them and this returns it — displaying one
+     * without shipping an OOXML reader.
+     *
+     * Only artifacts with `previewKey` set have one; anything else answers 404
+     * as `NOT_FOUND`. Check the field before asking, or catch it.
+     */
+    /**
+     * Save an edit made in the viewer — a sheet cell, a document's text.
+     *
+     * Produces a new REVISION rather than overwriting: the service re-renders to
+     * a versioned storage key and bumps the version, so the artifact keeps the
+     * history an edit implies.
+     */
+    updateArtifact(id: string, patch: {
+        content: string;
+        title?: string;
+    }): Promise<ChatArtifact>;
+    /** One revision's content — what the inline "viewing v1" panel shows. */
+    getArtifactVersion(id: string, version: number): Promise<ChatArtifact>;
+    /**
+     * Roll back to a revision.
+     *
+     * Writes a new revision holding the old content — nothing is deleted, so a
+     * restore made in error is itself undoable.
+     */
+    restoreArtifactVersion(id: string, version: number): Promise<ChatArtifact>;
+    /** Revisions of one artifact, newest first. Metadata only. */
+    listArtifactVersions(id: string): Promise<ArtifactVersionMeta[]>;
+    /**
+     * The rendition of a PAST version, for the viewer's version picker.
+     *
+     * Separate from `getArtifactPreview` rather than an optional argument: the
+     * current preview lives at a different path, and a version of `0` or `NaN`
+     * silently falling back to "current" is how a reader ends up looking at
+     * today's document under yesterday's heading.
+     */
+    getArtifactVersionPreview(id: string, version: number): Promise<Blob>;
+    getArtifactPreview(id: string): Promise<Blob>;
+    listSessions(query?: ListSessionsQuery): Promise<Paginated<Session>>;
+    createSession(request?: CreateSessionRequest): Promise<Session>;
+    getSession(id: string): Promise<Session>;
+    getMessages(id: string, options?: {
+        limit?: number;
+    }): Promise<SessionMessage[]>;
+    /**
+     * Rename, pin, or restatus a conversation.
+     *
+     * Answers `{ success: true }` rather than the updated row — the service
+     * confirms the write and nothing more. Typed as what actually arrives: a
+     * `Session` here would be a promise the server never made, and the first
+     * caller to read `.title` off it would get `undefined` with no explanation.
+     * Re-read with `getSession` when you need the new state.
+     */
+    updateSession(id: string, patch: UpdateSessionRequest): Promise<{
+        success: boolean;
+    }>;
+    deleteSession(id: string): Promise<void>;
+    forkSession(id: string, messageId: string): Promise<Session>;
+    /** Returns the export as a raw string — this route has no JSON envelope. */
+    exportSession(id: string, format: string): Promise<string>;
+    getFollowUps(conversationId: string, messageId: string): Promise<{
+        suggestions: unknown[];
+    }>;
+    getMessageMetadata(conversationId: string, messageId: string): Promise<{
+        metadata: unknown;
+    }>;
+}
+
+export { ChatClient };

package/dist/chat-client.js

@@ -0,0 +1,5 @@
+export { ChatClient } from './chunk-RLHHRJWS.js';
+import './chunk-VWUR3ECR.js';
+import './chunk-KZEGEV3P.js';
+//# sourceMappingURL=chat-client.js.map
+//# sourceMappingURL=chat-client.js.map

package/dist/chat-errors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The error codes a chat integration meets, and what each means for the
+ * person chatting (Forge improvement plan L4: the codes were found by reading
+ * the package source). Every SDK call throws `FronteraError`; branch on its
+ * `code`. The service can add codes, so treat one not listed here as
+ * `INTERNAL_ERROR`.
+ */
+declare const CHAT_ERROR_CODES: {
+    readonly 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.";
+    readonly FORBIDDEN: "The credential may not do this: the page is not on the key’s allowed websites, or a visitor asked for something a public chat cannot do.";
+    readonly NOT_FOUND: "The conversation or run is not this credential’s, or no longer exists.";
+    readonly VALIDATION_ERROR: "The request was malformed, for example an empty message or more than five messages.";
+    readonly RATE_LIMITED: "Too many messages or new chats in a short time. Wait the number of seconds the message names, then try again.";
+    readonly QUOTA_EXCEEDED: "The organization’s usage limit is reached. An administrator raises it.";
+    readonly SERVICE_UNAVAILABLE: "The platform can’t take the request right now. Try again shortly.";
+    readonly INTERNAL_ERROR: "Something failed on the platform. Try again; if it keeps failing, the message names what to report.";
+    readonly PROTOCOL_ERROR: "The response wasn’t a chat stream: the API origin is likely wrong, or a proxy changed the response.";
+    readonly FORBIDDEN_LOCAL: "Your own `authorizeConversation` callback denied access to the conversation.";
+    readonly CONFIG_MISSING: "The client has no API origin or credential.";
+};
+type ChatErrorCode = keyof typeof CHAT_ERROR_CODES;
+/** The code of any thrown value, `INTERNAL_ERROR` for one that isn't a `FronteraError` (a network failure included). */
+declare function chatErrorCode(err: unknown): ChatErrorCode;
+/**
+ * What to show a website visitor for an error: the platform's own message for
+ * a limit (it names the wait), plain words otherwise. Never the raw response.
+ */
+declare function visitorErrorWords(err: unknown): string;
+
+export { CHAT_ERROR_CODES, type ChatErrorCode, chatErrorCode, visitorErrorWords };

package/dist/chat-errors.js

@@ -0,0 +1,3 @@
+export { CHAT_ERROR_CODES, chatErrorCode, visitorErrorWords } from './chunk-YKQ5Z5EK.js';
+//# sourceMappingURL=chat-errors.js.map
+//# sourceMappingURL=chat-errors.js.map

package/dist/chunk-CMMWTCYS.js

@@ -0,0 +1,116 @@
+import { createContext, useContext } from 'react';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+
+// src/hooks.ts
+var chatKeys = {
+  all: ["chat"],
+  sessions: (query) => ["chat", "sessions", JSON.stringify(query ?? {})],
+  session: (id) => ["chat", "session", id],
+  messages: (id) => ["chat", "messages", id],
+  followUps: (conversationId, messageId) => ["chat", "follow-ups", conversationId, messageId],
+  approvals: (conversationId) => ["chat", "approvals", conversationId]
+};
+var FronteraChatContext = createContext(null);
+function useChatClient() {
+  const client = useContext(FronteraChatContext);
+  if (!client) {
+    throw new Error(
+      "No ChatClient in context. Wrap the tree in FronteraChatContext.Provider \u2014 in a Frontera app, add chatProvider to createFronteraApp providers."
+    );
+  }
+  return client;
+}
+function useSessions(query, options = {}) {
+  const client = useChatClient();
+  return useQuery({
+    queryKey: chatKeys.sessions(query),
+    queryFn: () => client.listSessions(query),
+    ...options
+  });
+}
+function useSession(id, options = {}) {
+  const client = useChatClient();
+  return useQuery({
+    queryKey: chatKeys.session(id),
+    queryFn: () => client.getSession(id),
+    ...options
+  });
+}
+function useSessionMessages(id, options = {}) {
+  const client = useChatClient();
+  return useQuery({
+    queryKey: chatKeys.messages(id),
+    queryFn: () => client.getMessages(id),
+    ...options
+  });
+}
+function useFollowUps(conversationId, messageId, options = {}) {
+  const client = useChatClient();
+  return useQuery({
+    queryKey: chatKeys.followUps(conversationId, messageId),
+    queryFn: () => client.getFollowUps(conversationId, messageId),
+    ...options
+  });
+}
+function useCreateSession(options = {}) {
+  const client = useChatClient();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (request) => client.createSession(request),
+    ...options,
+    onSuccess: (data, variables, context, mutation) => {
+      void queryClient.invalidateQueries({ queryKey: chatKeys.all });
+      return options.onSuccess?.(data, variables, context, mutation);
+    }
+  });
+}
+function useUpdateSession(options = {}) {
+  const client = useChatClient();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, patch }) => client.updateSession(id, patch),
+    ...options,
+    onSuccess: (data, variables, context, mutation) => {
+      void queryClient.invalidateQueries({ queryKey: chatKeys.session(variables.id) });
+      void queryClient.invalidateQueries({ queryKey: chatKeys.all });
+      return options.onSuccess?.(data, variables, context, mutation);
+    }
+  });
+}
+function usePendingApprovals(conversationId, options = {}) {
+  const client = useChatClient();
+  return useQuery({
+    queryKey: chatKeys.approvals(conversationId),
+    queryFn: () => client.listPendingApprovals(conversationId),
+    enabled: Boolean(conversationId),
+    refetchInterval: 5e3,
+    ...options
+  });
+}
+function useRespondToApproval(conversationId, options = {}) {
+  const client = useChatClient();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ approvalId, decision }) => client.respondToApproval(approvalId, decision),
+    ...options,
+    onSuccess: (data, variables, context, mutation) => {
+      void queryClient.invalidateQueries({ queryKey: chatKeys.approvals(conversationId) });
+      return options.onSuccess?.(data, variables, context, mutation);
+    }
+  });
+}
+function useCancelRun(options = {}) {
+  const client = useChatClient();
+  return useMutation({ mutationFn: (runId) => client.cancelRun(runId), ...options });
+}
+function useSteerRun(options = {}) {
+  const client = useChatClient();
+  return useMutation({
+    mutationFn: ({ runId, message }) => client.steerRun(runId, message),
+    ...options
+  });
+}
+
+export { FronteraChatContext, chatKeys, useCancelRun, useChatClient, useCreateSession, useFollowUps, usePendingApprovals, useRespondToApproval, useSession, useSessionMessages, useSessions, useSteerRun, useUpdateSession };
+//# sourceMappingURL=chunk-CMMWTCYS.js.map
+//# sourceMappingURL=chunk-CMMWTCYS.js.map

package/dist/chunk-KZEGEV3P.js

@@ -0,0 +1,35 @@
+import { FronteraError } from '@frontera-sdk/core/errors';
+
+// src/stream.ts
+async function startChat(client, request, options = {}) {
+  const response = await client.requestRaw("/v1/chat", {
+    method: "POST",
+    body: request,
+    signal: options.signal
+  });
+  const conversationId = response.headers.get("x-conversation-id");
+  const runId = response.headers.get("x-workflow-run-id");
+  if (!conversationId || !runId) {
+    throw new FronteraError("chat response is missing run identification headers", {
+      code: "PROTOCOL_ERROR",
+      status: response.status
+    });
+  }
+  return {
+    conversationId,
+    runId,
+    runtime: response.headers.get("x-agent-runtime") ?? "pi",
+    quotaWarning: response.headers.get("x-quota-warning") ?? void 0,
+    response
+  };
+}
+async function resumeStream(client, runId, options = {}) {
+  return client.requestRaw(`/v1/chat/${encodeURIComponent(runId)}/stream`, {
+    query: { startIndex: options.startIndex },
+    signal: options.signal
+  });
+}
+
+export { resumeStream, startChat };
+//# sourceMappingURL=chunk-KZEGEV3P.js.map
+//# sourceMappingURL=chunk-KZEGEV3P.js.map