@frontera-sdk/chat 1.52.44 → 1.52.46

package/dist/transport.js

@@ -0,0 +1,103 @@
+import { chatDoctor } from './chunk-VWUR3ECR.js';
+import { DefaultChatTransport } from 'ai';
+import { authHeaders } from '@frontera-sdk/core/transport';
+import { errorFromResponse } from '@frontera-sdk/core/errors';
+
+var OPENING_MESSAGE_ID = "frontera-opening";
+async function readErrorBody(response) {
+  try {
+    const text = await response.text();
+    if (!text) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function createChatTransport(client, options = {}) {
+  const current = typeof client === "function" ? client : () => client;
+  let conversationId = options.conversationId;
+  let runId;
+  const wrappedFetch = (async (input, init) => {
+    const send = async () => {
+      const merged = {};
+      new Headers(init?.headers).forEach((value, name) => {
+        merged[name] = value;
+      });
+      Object.assign(merged, authHeaders(current().config));
+      return fetch(input, { ...init, headers: merged });
+    };
+    let response = await send();
+    if (response.status === 401) {
+      if (options.onUnauthorized) {
+        await options.onUnauthorized();
+        response = await send();
+      } else {
+        chatDoctor.noticed("unauthorized");
+      }
+    }
+    if (!response.ok) {
+      throw errorFromResponse(response.status, await readErrorBody(response));
+    }
+    const headerConversationId = response.headers.get("x-conversation-id");
+    const headerRunId = response.headers.get("x-workflow-run-id");
+    if (headerConversationId && headerRunId) {
+      conversationId = headerConversationId;
+      runId = headerRunId;
+      options.onStart?.({
+        conversationId: headerConversationId,
+        runId: headerRunId,
+        runtime: response.headers.get("x-agent-runtime") ?? "pi",
+        quotaWarning: response.headers.get("x-quota-warning") ?? void 0
+      });
+    }
+    return chatDoctor.observe(response);
+  });
+  return new DefaultChatTransport({
+    // Resolved per request, not here. The client may not exist yet: a caller
+    // that fetches its token asynchronously has nothing to give until the
+    // first exchange returns, and reading `.config` at construction would
+    // throw before anything could render.
+    api: "",
+    fetch: wrappedFetch,
+    /*
+          `body` here is the PER-CALL one — `sendMessage(message, { body })`.
+    
+          It was dropped, and the loss was silent: attachments upload fine, the
+          composer shows them, the send succeeds, and the agent simply never
+          receives the file. Anything a caller attaches to one message travels this
+          way, so the same omission also swallowed per-send `modelMode` and any
+          custom field a host passes for a single turn.
+    
+          Merged AFTER the transport-level `options.body` on purpose: that one is
+          the standing configuration for every send, and a value supplied for one
+          message is the more specific statement.
+        */
+    prepareSendMessagesRequest: ({ messages, body }) => {
+      const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
+      const before = lastUserMessage ? messages[messages.indexOf(lastUserMessage) - 1] : void 0;
+      const opening = !conversationId && before?.role === "assistant" && before.id === OPENING_MESSAGE_ID ? [before] : [];
+      const trimmed = options.lastMessageOnly === false ? messages : lastUserMessage ? [...opening, lastUserMessage] : messages.slice(-1);
+      return {
+        api: `${current().config.apiBaseUrl}/v1/chat`,
+        body: {
+          messages: trimmed,
+          ...conversationId ? { conversationId } : {},
+          ...typeof options.body === "function" ? options.body() : options.body,
+          ...body
+        }
+      };
+    },
+    prepareReconnectToStreamRequest: () => {
+      if (!runId) throw new Error("no run to reconnect to \u2014 no send has completed yet");
+      return { api: `${current().config.apiBaseUrl}/v1/chat/${encodeURIComponent(runId)}/stream` };
+    }
+  });
+}
+
+export { OPENING_MESSAGE_ID, createChatTransport };
+//# sourceMappingURL=transport.js.map
+//# sourceMappingURL=transport.js.map

package/dist/types.d.ts

@@ -0,0 +1,361 @@
+/**
+ * Request/response shapes for the chat surface, mirrored from the service's
+ * TypeBox schemas (chat-router.ts, session-router.ts). Mirrored by hand rather
+ * than imported: the SDK publishes source and must not depend on the service
+ * package.
+ */
+type ChatRole = 'user' | 'assistant' | 'system';
+/**
+ * A message as `POST /v1/chat` accepts it. `parts` is deliberately untyped:
+ * the server persists parts opaquely (a narrow schema on the wire stripped
+ * part fields once — see the comment in chat-router.ts), and the SDK follows.
+ */
+interface ChatInputMessage {
+    id: string;
+    role: ChatRole;
+    content?: string;
+    parts: unknown[];
+}
+interface ContextAttachment {
+    type: string;
+    id: string;
+    name?: string;
+    meta?: Record<string, unknown>;
+}
+interface FileAttachment {
+    /** Publicly reachable URL — under API-key auth there is no upload endpoint. */
+    url: string;
+    storagePath?: string;
+    filename: string;
+    mediaType: string;
+    size: number;
+    pageCount?: number;
+    isScanned?: boolean;
+}
+type ReasoningEffort = 'max' | 'xhigh' | 'high' | 'medium' | 'low' | 'minimal' | 'none';
+interface StartChatRequest {
+    /** 1–5 messages; the server rehydrates earlier history from the conversation. */
+    messages: ChatInputMessage[];
+    conversationId?: string;
+    editMessageId?: string;
+    contextAttachments?: ContextAttachment[];
+    fileAttachments?: FileAttachment[];
+    analysisMode?: string;
+    webSearchAugment?: boolean;
+    modelMode?: string | null;
+    thinkingEnabled?: boolean;
+    reasoningEffort?: ReasoningEffort;
+    /** Ignored under sak_/cht_ auth — the credential's agent always wins. */
+    agentName?: string;
+    surface?: 'web' | 'mobile' | 'console';
+}
+/** What `startChat` extracts from the response before handing over the stream. */
+interface StartChatResult {
+    conversationId: string;
+    runId: string;
+    runtime: string;
+    quotaWarning?: string;
+    /** The raw response; `response.body` is the AI SDK v6 UI-message SSE stream. */
+    response: Response;
+}
+interface ExchangeTokenRequest {
+    externalUserId: string;
+    name?: string;
+    metadata?: Record<string, unknown>;
+    ttlSeconds?: number;
+    /**
+     * Which agent the token reaches. Accepted when minting with a workspace key
+     * scoped for chat; an agent key is fixed to its own agent and refuses a
+     * different one. Omit with a workspace key for a token that reaches every
+     * agent, the way a platform user does.
+     */
+    agentId?: string;
+    agentName?: string;
+    /**
+     * Limit this token to a SUBSET of the workspace's agents — ids or slugs.
+     *
+     * Omit and it reaches every agent the minting credential can (an agent key
+     * always fixes exactly one). Naming a subset is how a product that exposes
+     * two of five agents stops the other three from being reachable by a guessed
+     * id, not merely hidden from the picker.
+     */
+    agentIds?: string[];
+    /**
+     * What YOUR product authorises this person to do beyond chatting. Everything
+     * here is DENIED unless asked for:
+     *
+     * - `plugin-connect` — connect their own account (Gmail, Drive, …) for a plugin
+     *   that needs one. All-or-nothing across the plugins the workspace has
+     *   opened to external users; a per-plugin scope is planned (see the TODO in
+     *   the service's `chat-token.ts`).
+     * - `schedule` — read and manage the agent's scheduled tasks.
+     * - `agent-mode` — agent work items, exchanges, handoffs, agent conversations.
+     *
+     * The base token chats and nothing more: it sends, reads its own history and
+     * answers what the agent parks. Decide the rest against your own roles — we
+     * never model them. The decision rides on the token and expires with it, so
+     * withdrawing it on your side takes effect with nothing to synchronise.
+     */
+    capabilities?: string[];
+}
+interface ChatToken {
+    token: string;
+    expiresAt: string;
+}
+/** What an upload returns — the shape `fileAttachments` expects. */
+interface UploadedFile {
+    url: string;
+    storagePath?: string;
+    filename: string;
+    mediaType: string;
+    size: number;
+    pageCount?: number;
+    isScanned?: boolean;
+}
+/**
+ * A document, image or deck the agent produced.
+ *
+ * The named fields are the ones a viewer reads; the index signature carries
+ * whatever else the deployment returns. Naming them matters — under an index
+ * signature alone every read is `unknown`, and a renderer cannot tell a title
+ * from a MIME type.
+ */
+/**
+ * One revision of an artifact, as the version picker needs it.
+ *
+ * Metadata only — no `content`, no `storageKey`. Drawing a menu does not
+ * require every revision's bytes, and the preview route serves them when a
+ * revision is actually opened.
+ */
+interface ArtifactVersionMeta {
+    version: number;
+    createdAt?: string;
+    title?: string | null;
+    /** Who saved it — an agent turn, or the person editing in the viewer. */
+    createdBy?: string | null;
+    sizeBytes?: number | null;
+}
+interface ChatArtifact {
+    id: string;
+    title?: string | null;
+    kind?: string | null;
+    /** Rendered format: markdown, csv, sheet, pdf, image, htmldeck, canvas. */
+    format?: string | null;
+    mimeType?: string | null;
+    /** The artifact's text, when it has one. */
+    content?: string | null;
+    /** Source language for a code artifact, used to pick a subtitle and lexer. */
+    language?: string | null;
+    conversationId?: string | null;
+    /** Where the bytes live, for artifacts stored as files rather than text. */
+    storageKey?: string | null;
+    /**
+     * A rendered PDF of this artifact, when the format needs one to be shown.
+     *
+     * Set for `.docx`/`.pptx` and anything else a browser cannot open. Present
+     * means `getArtifactPreview(id)` will answer; absent means it will not.
+     */
+    previewKey?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+/** An agent the current credential may talk to — enough to draw a picker. */
+/**
+ * One model choice an agent offers.
+ *
+ * `/v1/chat-agents` omits `modelId`, `model` and `provider` on purpose: those
+ * are the exact checkpoint the deployment runs, and nothing a chat needs to
+ * draw a picker. `name` is a LABEL, not that identifier — the operator's own
+ * wording when they set one, and the catalog's when they did not, which does
+ * name a vendor ("Claude Sonnet 5") and is what a vendor glyph is chosen from.
+ * Nothing here can be sent back to pin a request to a model.
+ *
+ * `reasoning` is what decides whether an effort control appears beside the
+ * model: a mode without it offers a model and nothing else.
+ */
+interface ChatAgentMode {
+    key: string;
+    name: string;
+    description?: string;
+    style?: string;
+    reasoning?: {
+        style?: string;
+        supportedEfforts?: string[];
+        defaultEffort?: string;
+        [key: string]: unknown;
+    };
+}
+interface ChatAgent {
+    id: string;
+    agentId: string;
+    name: string;
+    description?: string | null;
+    avatarConfig?: unknown;
+    /** The agent's own model choices. Empty or single → nothing to pick between. */
+    modes?: ChatAgentMode[];
+    /** The mode the agent starts in, as configured on the deployment. */
+    defaultMode?: string | null;
+}
+/**
+ * A tool call the agent has parked, waiting for a person to decide.
+ *
+ * The run is BLOCKED while this exists: an agent whose approval mode is `ask`
+ * (or whose tool the safety reviewer would not clear on its own) streams a
+ * `tool-approval-request` chunk carrying `approvalId` and then stops until
+ * `respondToApproval` settles it or `expiresAt` passes. An integration that
+ * never answers looks like an agent that silently stopped mid-sentence.
+ *
+ * Named fields are what a card needs to render; the index signature carries
+ * whatever else the deployment reports.
+ */
+interface PendingApproval {
+    id: string;
+    /** `pending` while it waits; then `approved`, `denied` or `expired`. */
+    status: string;
+    /** `needs_approval` for a human gate; `needs_connect` for a missing account. */
+    pauseReason: string;
+    /** Which app the agent was reaching for — pass it to `startAppConnection`. */
+    installId?: string | null;
+    toolCallId?: string | null;
+    toolName?: string | null;
+    /** Where the tool came from: an app, an MCP server, the platform. */
+    toolSource?: string | null;
+    risk?: string | null;
+    /** A short, secret-safe description of what the tool is about to do. */
+    actionSummary?: unknown;
+    /** Why the policy asked rather than allowing. */
+    policyReason?: string | null;
+    expiresAt?: string;
+    [key: string]: unknown;
+}
+type ApprovalDecision = 'approve' | 'deny';
+/**
+ * Starting a connect for a tool that needs the END USER's own account.
+ *
+ * `redirectUri` is a callback on YOUR domain, registered both with your OAuth
+ * client and on the workspace's embed allowlist. It has to be yours: a
+ * provider only authorises redirect URIs under a domain the OAuth project's
+ * owner has verified, and you cannot verify ours.
+ */
+interface StartAppConnectionRequest {
+    /** From the parked call's `installId`; or name the app with `catalogKind`. */
+    installId?: string;
+    catalogKind?: string;
+    redirectUri: string;
+    /** Where your page sends the user afterwards — origin must be allowlisted. */
+    returnTo?: string;
+}
+interface StartAppConnectionResult {
+    /** Open this in a popup or a full-page redirect. */
+    authUrl: string;
+    installId: string;
+}
+/** What your callback forwards to us: the provider's `code` and our `state`. */
+interface CompleteAppConnectionRequest {
+    code: string;
+    state: string;
+}
+interface CompleteAppConnectionResult {
+    installId: string;
+    /** The account's email, when the provider reports one. */
+    email: string | null;
+}
+/**
+ * The re-run of a parked call. `ok: false` with `reason: 'no_account'` means
+ * the connection still is not usable — the row stays parked, so the same card
+ * can retry.
+ */
+type ResumeToolCallResult = {
+    ok: true;
+    [key: string]: unknown;
+} | {
+    ok: false;
+    reason: string;
+    error?: string;
+};
+/**
+ * The chunk that announces a parked tool call, as it arrives on the stream.
+ *
+ * Not exported by the AI SDK's own chunk union, so it is declared here for
+ * consumers switching on chunk types from `chatChunkStream`.
+ */
+interface ToolApprovalRequestChunk {
+    type: 'tool-approval-request';
+    approvalId: string;
+    toolCallId: string;
+}
+interface CreateSessionRequest {
+    agentName?: string;
+    modelMode?: string | null;
+    approvalMode?: 'ask' | 'auto' | 'full';
+    workspaceId?: string;
+}
+interface UpdateSessionRequest {
+    title?: string;
+    status?: string;
+    pinned?: boolean;
+    group?: string | null;
+    modelMode?: string | null;
+    approvalMode?: 'ask' | 'auto' | 'full';
+}
+interface ListSessionsQuery {
+    cursor?: string;
+    limit?: number;
+    status?: string;
+    label?: string;
+    group?: string;
+    search?: string;
+    pinned?: boolean;
+    source?: 'chat' | 'automation' | 'all';
+    agentName?: string;
+    agentId?: string;
+    updatedAfter?: string;
+    updatedBefore?: string;
+    surface?: string;
+}
+interface Paginated<T> {
+    data: T[];
+    nextCursor?: string;
+}
+/**
+ * Loose by design: these are the fields the server guarantees today; anything
+ * else rides in the index signature until the service exposes a shared
+ * contract.
+ */
+interface Session {
+    id: string;
+    title?: string | null;
+    status?: string;
+    agentName?: string | null;
+    pinned?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+/** UIMessage-shaped: feed straight into `useChat({ messages })`. */
+interface SessionMessage {
+    id: string;
+    role: ChatRole;
+    parts: unknown[];
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+}
+/**
+ * Custom data parts the server streams alongside text. Payloads are `unknown`
+ * in v1; the names are stable and safe to switch on in `onData`.
+ */
+type ChatDataPartName = 'data-context' | 'data-context-estimate' | 'data-context-observed' | 'data-context-maintenance' | 'data-compaction' | 'data-work-queued' | 'data-desktop';
+/**
+ * Called before any method that touches an existing conversation. Under
+ * API-key auth the server skips conversation ownership checks entirely, so a
+ * consumer serving multiple end-users MUST decide here whether the current
+ * user may touch `conversationId` — typically a lookup in their own
+ * user↔conversation store.
+ */
+type AuthorizeConversation = (conversationId: string) => boolean | Promise<boolean>;
+interface ChatClientOptions {
+    authorizeConversation?: AuthorizeConversation;
+}
+
+export type { ApprovalDecision, ArtifactVersionMeta, AuthorizeConversation, ChatAgent, ChatAgentMode, ChatArtifact, ChatClientOptions, ChatDataPartName, ChatInputMessage, ChatRole, ChatToken, CompleteAppConnectionRequest, CompleteAppConnectionResult, ContextAttachment, CreateSessionRequest, ExchangeTokenRequest, FileAttachment, ListSessionsQuery, Paginated, PendingApproval, ReasoningEffort, ResumeToolCallResult, Session, SessionMessage, StartAppConnectionRequest, StartAppConnectionResult, StartChatRequest, StartChatResult, ToolApprovalRequestChunk, UpdateSessionRequest, UploadedFile };

package/dist/types.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/ui-stream.d.ts

@@ -0,0 +1,25 @@
+import { UIMessageChunk, UIMessage } from 'ai';
+
+/**
+ * Decode a chat SSE `Response` into the AI SDK's typed chunk stream.
+ *
+ * `readUIMessageStream` consumes chunks, not responses, so this is the bridge
+ * for server-side consumers holding the raw `Response` from `startChat`/
+ * `resumeStream`. The SSE layer (including the server's `: ping` keepalive
+ * comments and the `[DONE]` terminator) is handled by the AI SDK's own parser
+ * — the SDK never hand-parses SSE.
+ */
+declare function chatChunkStream(response: Response): ReadableStream<UIMessageChunk>;
+/**
+ * Iterate assembled `UIMessage` snapshots from a chat response:
+ *
+ * ```ts
+ * const run = await chat.startChat({ messages: [...] })
+ * for await (const message of readChatStream(run.response)) {
+ *   // message.parts grows as the agent streams
+ * }
+ * ```
+ */
+declare function readChatStream(response: Response): AsyncIterable<UIMessage>;
+
+export { chatChunkStream, readChatStream };

package/dist/ui-stream.js

@@ -0,0 +1,26 @@
+import { parseJsonEventStream, readUIMessageStream } from 'ai';
+
+// src/ui-stream.ts
+function chatChunkStream(response) {
+  if (!response.body) {
+    throw new Error("chat response has no body to stream");
+  }
+  return parseJsonEventStream({
+    stream: response.body,
+    schema: void 0
+  }).pipeThrough(
+    new TransformStream({
+      transform(result, controller) {
+        if (!result.success) throw result.error;
+        controller.enqueue(result.value);
+      }
+    })
+  );
+}
+function readChatStream(response) {
+  return readUIMessageStream({ stream: chatChunkStream(response) });
+}
+
+export { chatChunkStream, readChatStream };
+//# sourceMappingURL=ui-stream.js.map
+//# sourceMappingURL=ui-stream.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontera-sdk/chat",
-  "version": "1.52.44",
+  "version": "1.52.46",
   "description": "Typed client and React hooks for chatting with a Frontera agent from your own application.",
   "keywords": [
     "frontera",
@@ -12,6 +12,8 @@
   "license": "Apache-2.0",
   "type": "module",
   "files": [
+    "dist",
+    "!dist/**/*.map",
     "src",
     "!src/__tests__",
     "!src/**/*.test.ts",
@@ -23,65 +25,101 @@
   },
   "exports": {
     "./types": {
-      "types": "./src/types.ts",
-      "import": "./src/types.ts"
+      "types": "./dist/types.d.ts",
+      "bun": "./src/types.ts",
+      "import": "./dist/types.js"
     },
     "./chat-client": {
-      "types": "./src/chat-client.ts",
-      "import": "./src/chat-client.ts"
+      "types": "./dist/chat-client.d.ts",
+      "bun": "./src/chat-client.ts",
+      "import": "./dist/chat-client.js"
     },
     "./auth": {
-      "types": "./src/auth.ts",
-      "import": "./src/auth.ts"
+      "types": "./dist/auth.d.ts",
+      "bun": "./src/auth.ts",
+      "import": "./dist/auth.js"
     },
     "./stream": {
-      "types": "./src/stream.ts",
-      "import": "./src/stream.ts"
+      "types": "./dist/stream.d.ts",
+      "bun": "./src/stream.ts",
+      "import": "./dist/stream.js"
     },
     "./ui-stream": {
-      "types": "./src/ui-stream.ts",
-      "import": "./src/ui-stream.ts"
+      "types": "./dist/ui-stream.d.ts",
+      "bun": "./src/ui-stream.ts",
+      "import": "./dist/ui-stream.js"
     },
     "./doctor": {
-      "types": "./src/doctor.ts",
-      "import": "./src/doctor.ts"
+      "types": "./dist/doctor.d.ts",
+      "bun": "./src/doctor.ts",
+      "import": "./dist/doctor.js"
     },
     "./token-session": {
-      "types": "./src/token-session.ts",
-      "import": "./src/token-session.ts"
+      "types": "./dist/token-session.d.ts",
+      "bun": "./src/token-session.ts",
+      "import": "./dist/token-session.js"
     },
     "./public-token": {
-      "types": "./src/public-token.ts",
-      "import": "./src/public-token.ts"
+      "types": "./dist/public-token.d.ts",
+      "bun": "./src/public-token.ts",
+      "import": "./dist/public-token.js"
     },
     "./callback-page": {
-      "types": "./src/callback-page.ts",
-      "import": "./src/callback-page.ts"
+      "types": "./dist/callback-page.d.ts",
+      "bun": "./src/callback-page.ts",
+      "import": "./dist/callback-page.js"
     },
     "./connect-popup": {
-      "types": "./src/connect-popup.ts",
-      "import": "./src/connect-popup.ts"
+      "types": "./dist/connect-popup.d.ts",
+      "bun": "./src/connect-popup.ts",
+      "import": "./dist/connect-popup.js"
     },
     "./transport": {
-      "types": "./src/transport.ts",
-      "import": "./src/transport.ts"
+      "types": "./dist/transport.d.ts",
+      "bun": "./src/transport.ts",
+      "import": "./dist/transport.js"
     },
     "./hooks": {
-      "types": "./src/hooks.ts",
-      "import": "./src/hooks.ts"
+      "types": "./dist/hooks.d.ts",
+      "bun": "./src/hooks.ts",
+      "import": "./dist/hooks.js"
     },
     "./provider": {
-      "types": "./src/provider.tsx",
-      "import": "./src/provider.tsx"
-    }
+      "types": "./dist/provider.d.ts",
+      "bun": "./src/provider.tsx",
+      "import": "./dist/provider.js"
+    },
+    "./chat-errors": {
+      "types": "./dist/chat-errors.d.ts",
+      "bun": "./src/chat-errors.ts",
+      "import": "./dist/chat-errors.js"
+    },
+    "./public-chat": {
+      "types": "./dist/public-chat.d.ts",
+      "bun": "./src/public-chat.ts",
+      "import": "./dist/public-chat.js"
+    },
+    "./reply-text": {
+      "types": "./dist/reply-text.d.ts",
+      "bun": "./src/reply-text.ts",
+      "import": "./dist/reply-text.js"
+    },
+    "./element": {
+      "types": "./dist/element.d.ts",
+      "bun": "./src/element.ts",
+      "import": "./dist/element.js"
+    },
+    "./frontera-chat.iife.js": "./dist/frontera-chat.iife.js"
   },
   "scripts": {
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit",
-    "smoke": "bun run scripts/smoke.ts"
+    "smoke": "bun run scripts/smoke.ts",
+    "build": "bunx tsup",
+    "prepack": "bun run build"
   },
   "dependencies": {
-    "@frontera-sdk/core": "1.52.44"
+    "@frontera-sdk/core": "1.52.46"
   },
   "peerDependencies": {
     "@ai-sdk/react": "^3.0.0",
@@ -104,11 +142,13 @@
     }
   },
   "devDependencies": {
+    "@happy-dom/global-registrator": "^20.11.1",
     "@tanstack/react-query": "^5.90.21",
     "@types/bun": "^1.3.14",
     "@types/react": "^19",
     "ai": "^6.0.116",
     "react": "19.2.5",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }
 }