@lumerahq/ui 0.7.7 → 0.8.0-dev.1

package/dist/{api-DXN1wKkz.js → api-Da1IIWDG.js}

@@ -1,4 +1,4 @@
-import { p as parentApiRequest, B as BridgeError } from "./automations-OzVpAuzv.js";
+import { p as parentApiRequest, B as BridgeError } from "./automations-BEBG7FqJ.js";
 const API_PREFIX = "/api";
 const buildUrl = (path) => {
   const normalized = path.startsWith("/") ? path : `/${path}`;

package/dist/{automations-OzVpAuzv.js → automations-BEBG7FqJ.js}

@@ -65,6 +65,7 @@ class BridgeError extends Error {
   }
 }
 const pendingRequests = /* @__PURE__ */ new Map();
+const pendingStreams = /* @__PURE__ */ new Map();
 const initListeners = /* @__PURE__ */ new Set();
 let listenerAttached = false;
 let routeSyncAttached = false;
@@ -216,6 +217,14 @@ const playgroundApiRequest = async (request2) => {
     };
   }
 };
+const playgroundApiStream = (handlers) => {
+  const id = "playground-stream";
+  setTimeout(() => {
+    handlers.onError?.(new BridgeError("Streaming is not available in playground mode", 501));
+    handlers.onClose?.();
+  }, 0);
+  return { id, close: () => void 0 };
+};
 const isStandaloneDevMode = () => false;
 const getCurrentRouteSnapshot = () => ({
   pathname: window.location.pathname,
@@ -302,6 +311,40 @@ const ensureRouteSync = () => {
     postRouteChange("replace");
   });
 };
+const clearPendingStream = (id) => {
+  const stream = pendingStreams.get(id);
+  if (!stream) return void 0;
+  pendingStreams.delete(id);
+  if (stream.timeoutId) clearTimeout(stream.timeoutId);
+  return stream;
+};
+const handleStreamResponse = (payload) => {
+  if (!payload?.id) return;
+  const stream = pendingStreams.get(payload.id);
+  if (!stream) {
+    log("No pending stream found for response id", payload.id);
+    return;
+  }
+  switch (payload.type) {
+    case "open":
+      stream.handlers.onOpen?.(payload);
+      return;
+    case "chunk":
+      stream.handlers.onChunk(payload.chunk);
+      return;
+    case "error": {
+      clearPendingStream(payload.id);
+      stream.handlers.onError?.(new BridgeError(payload.error, payload.status));
+      stream.handlers.onClose?.();
+      return;
+    }
+    case "close": {
+      clearPendingStream(payload.id);
+      stream.handlers.onClose?.();
+      return;
+    }
+  }
+};
 const handleMessage = (event) => {
   const allowedOrigins = trustedParentOrigins();
   if (!isAllowedParentOrigin(event.origin, window.location.origin)) {
@@ -331,6 +374,10 @@ const handleMessage = (event) => {
     }
     return;
   }
+  if (type === "stream-response") {
+    handleStreamResponse(payload);
+    return;
+  }
   if (type === "route-sync") {
     applyRouteSyncFromParent(payload);
   }
@@ -435,13 +482,59 @@ const parentApiRequest = async (request2) => {
             ...request2.headers
           },
           body: request2.body,
-          isBase64: request2.isBase64
+          isBase64: request2.isBase64,
+          fileName: request2.fileName,
+          formFieldName: request2.formFieldName
         }
       },
       "*"
     );
   });
 };
+const parentApiStream = (request2, handlers) => {
+  if (isPlaygroundMode()) {
+    return playgroundApiStream(handlers);
+  }
+  if (typeof window === "undefined" || !isEmbedded()) {
+    throw new BridgeError("App must be embedded in the Lumera host to stream API responses");
+  }
+  ensureListener();
+  const id = generateId();
+  const timeout = request2.timeout;
+  const timeoutId = timeout ? setTimeout(() => {
+    clearPendingStream(id);
+    window.parent.postMessage({ type: "stream-cancel", payload: { id } }, "*");
+    handlers.onError?.(new BridgeError(`Stream timed out after ${timeout}ms`, 408));
+    handlers.onClose?.();
+  }, timeout) : void 0;
+  pendingStreams.set(id, { handlers, timeoutId });
+  window.parent.postMessage(
+    {
+      type: "stream-request",
+      payload: {
+        id,
+        method: request2.method,
+        url: request2.url,
+        headers: {
+          Accept: "text/event-stream",
+          "X-Lumera-Client": "lumera-custom-app",
+          ...request2.headers
+        },
+        body: request2.body,
+        isBase64: request2.isBase64
+      }
+    },
+    "*"
+  );
+  return {
+    id,
+    close: () => {
+      const stream = clearPendingStream(id);
+      if (!stream) return;
+      window.parent.postMessage({ type: "stream-cancel", payload: { id } }, "*");
+    }
+  };
+};
 const API_PREFIX = "/api";
 const TERMINAL_STATUSES = ["succeeded", "failed", "cancelled"];
 const ACTIVE_STATUSES = ["preparing", "queued", "running", "cancelling"];
@@ -671,36 +764,37 @@ async function listRunsByExternalId(params) {
   });
 }
 export {
-  listRunsByAgent as A,
+  listRuns as A,
   BridgeError as B,
-  listRunsByExternalId as C,
-  pollAutomationRun as D,
+  listRunsByAgent as C,
+  listRunsByExternalId as D,
   EXPECTED_PARENT_ORIGIN as E,
-  pollRun as F,
+  pollAutomationRun as F,
+  pollRun as G,
   getShareableAppUrl as a,
-  postReadyMessage as b,
+  parentApiStream as b,
   configureBridge as c,
-  automationStatuses as d,
-  cancelAutomationRun as e,
-  cancelRun as f,
+  postReadyMessage as d,
+  automationStatuses as e,
+  cancelAutomationRun as f,
   getAppProjectExternalId as g,
-  clearAutomationCache as h,
+  cancelRun as h,
   isEmbedded as i,
-  createAutomationRun as j,
-  createRun as k,
-  ensureAutomationRun as l,
-  ensureRun as m,
-  getAutomationByExternalId as n,
+  clearAutomationCache as j,
+  createAutomationRun as k,
+  createRun as l,
+  ensureAutomationRun as m,
+  ensureRun as n,
   onInitMessage as o,
   parentApiRequest as p,
-  getAutomationRun as q,
-  getAutomationRunFileDownloadUrl as r,
+  getAutomationByExternalId as q,
+  getAutomationRun as r,
   serializeBridgeRuntimeConfig as s,
-  getRun as t,
-  getRunFiles as u,
-  getRunFileUrl as v,
-  isActiveStatus as w,
-  isTerminalStatus as x,
-  listAutomationRunFiles as y,
-  listRuns as z
+  getAutomationRunFileDownloadUrl as t,
+  getRun as u,
+  getRunFiles as v,
+  getRunFileUrl as w,
+  isActiveStatus as x,
+  isTerminalStatus as y,
+  listAutomationRunFiles as z
 };

package/dist/components/agent-chat/AgentChat.d.ts

@@ -0,0 +1,3 @@
+import { AgentChatMetadata, AgentChatProps } from './types';
+export declare function AgentChat<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown>({ agentId, sessionId, agent, name, description, transport, initialMessages, initialPage, historyLimit, maxBufferedMessages, maxQueuedMessages, disabled, className, labels: labelOverrides, features, renderers, onMessagesChange, onTurnComplete, onError, children, }: AgentChatProps<TMeta, TToolInput, TActionData>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AgentChat.d.ts.map

package/dist/components/agent-chat/AgentChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentChat.d.ts","sourceRoot":"","sources":["../../../src/components/agent-chat/AgentChat.tsx"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAMV,iBAAiB,EAEjB,cAAc,EAIf,MAAM,SAAS,CAAC;AAajB,wBAAgB,SAAS,CACvB,KAAK,SAAS,iBAAiB,GAAG,iBAAiB,EACnD,UAAU,GAAG,OAAO,EACpB,WAAW,GAAG,OAAO,EACrB,EACA,OAAO,EACP,SAAS,EACT,KAAK,EACL,IAAI,EACJ,WAAW,EACX,SAAS,EACT,eAAe,EACf,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,QAAQ,EACR,SAAS,EACT,MAAM,EAAE,cAAc,EACtB,QAAQ,EACR,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,OAAO,EACP,QAAQ,GACT,EAAE,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,WAAW,CAAC,2CAyNhD"}

package/dist/components/agent-chat/index.d.ts

@@ -0,0 +1,5 @@
+export { AgentChat } from './AgentChat';
+export type { LumeraAgentChatTransportOptions } from './lumera-agent-transport';
+export { createLumeraAgentChatTransport } from './lumera-agent-transport';
+export type { AgentChatAbortRequest, AgentChatAction, AgentChatActionBlock, AgentChatActiveStatus, AgentChatAgentProfile, AgentChatAgentRequest, AgentChatBlockRendererProps, AgentChatComposerActions, AgentChatComposerRendererProps, AgentChatComposerState, AgentChatContentBlock, AgentChatCustomBlock, AgentChatFeatureFlags, AgentChatFile, AgentChatFileBlock, AgentChatHistoryPage, AgentChatHistoryRequest, AgentChatHistoryResult, AgentChatID, AgentChatInfoBlock, AgentChatLabels, AgentChatLoadEarlierRequest, AgentChatMessage, AgentChatMessageRendererProps, AgentChatMessageRole, AgentChatMetadata, AgentChatOperationStatus, AgentChatPendingFile, AgentChatPhase, AgentChatProps, AgentChatRenameSessionRequest, AgentChatRenderers, AgentChatResizableWidthOptions, AgentChatSession, AgentChatSessionListRequest, AgentChatSessionListResult, AgentChatStreamEvent, AgentChatStreamHandlers, AgentChatSubmitInput, AgentChatSubmitResult, AgentChatSubscription, AgentChatTerminalStatus, AgentChatTextBlock, AgentChatThinkingBlock, AgentChatTokenUsage, AgentChatToolCall, AgentChatToolCallBlock, AgentChatTransport, AgentChatTurn, AgentChatTurnStatus, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/agent-chat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/agent-chat/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,+BAA+B,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAE1E,YAAY,EACV,qBAAqB,EACrB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,2BAA2B,EAC3B,wBAAwB,EACxB,8BAA8B,EAC9B,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,aAAa,EACb,kBAAkB,EAClB,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACtB,WAAW,EACX,kBAAkB,EAClB,eAAe,EACf,2BAA2B,EAC3B,gBAAgB,EAChB,6BAA6B,EAC7B,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,EACxB,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,6BAA6B,EAC7B,kBAAkB,EAClB,8BAA8B,EAC9B,gBAAgB,EAChB,2BAA2B,EAC3B,0BAA0B,EAC1B,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,kBAAkB,EAClB,aAAa,EACb,mBAAmB,GACpB,MAAM,SAAS,CAAC"}

package/dist/components/agent-chat/lumera-agent-transport.d.ts

@@ -0,0 +1,20 @@
+import { BridgeRequest, BridgeResponse, BridgeStream, parentApiStream } from '../../lib/bridge';
+import { AgentChatMetadata, AgentChatSubmitInput, AgentChatTransport } from './types';
+export interface LumeraAgentChatTransportOptions {
+    agentId: string;
+    sessionId?: string;
+    historyLimit?: number;
+    streamWaitMs?: number;
+    reconnectDelayMs?: number;
+    maxReconnects?: number;
+    model?: string;
+    systemPrompt?: string;
+    webSearchEnabled?: boolean;
+    startBody?: (input: AgentChatSubmitInput, body: Record<string, unknown>) => Record<string, unknown>;
+    request?: (request: BridgeRequest) => Promise<BridgeResponse>;
+    stream?: (request: BridgeRequest, handlers: LumeraBridgeStreamHandlers) => BridgeStream;
+}
+type LumeraBridgeStreamHandlers = Parameters<typeof parentApiStream>[1];
+export declare function createLumeraAgentChatTransport(options: LumeraAgentChatTransportOptions): AgentChatTransport<AgentChatMetadata, unknown, unknown>;
+export {};
+//# sourceMappingURL=lumera-agent-transport.d.ts.map

package/dist/components/agent-chat/lumera-agent-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lumera-agent-transport.d.ts","sourceRoot":"","sources":["../../../src/components/agent-chat/lumera-agent-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAiC,eAAe,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAQV,iBAAiB,EAOjB,oBAAoB,EAIpB,kBAAkB,EAEnB,MAAM,SAAS,CAAC;AAQjB,MAAM,WAAW,+BAA+B;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,oBAAoB,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpG,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAC9D,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,0BAA0B,KAAK,YAAY,CAAC;CACzF;AAED,KAAK,0BAA0B,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAkGxE,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,+BAA+B,GACvC,kBAAkB,CAAC,iBAAiB,EAAE,OAAO,EAAE,OAAO,CAAC,CAkIzD"}

package/dist/components/agent-chat/types.d.ts

@@ -0,0 +1,400 @@
+import { ComponentType, ReactNode } from 'react';
+/** Stable string id used by Lumera chat transports. */
+export type AgentChatID = string;
+/** JSON-compatible metadata bag for app-specific extensions. */
+export type AgentChatMetadata = Record<string, unknown>;
+/** Chat roles understood by the base component. */
+export type AgentChatMessageRole = 'user' | 'assistant' | 'system';
+/** Live/queued statuses for a user request turn. */
+export type AgentChatActiveStatus = 'queued' | 'claimed' | 'preparing' | 'submitting' | 'running';
+/** Terminal statuses for a user request turn. */
+export type AgentChatTerminalStatus = 'completed' | 'failed' | 'interrupted' | 'aborted';
+/** Any request-turn status the component can render. */
+export type AgentChatTurnStatus = AgentChatActiveStatus | AgentChatTerminalStatus;
+/** Coarse UI phase for the chat surface. */
+export type AgentChatPhase = 'idle' | 'loading-history' | 'loading-earlier' | 'submitting' | 'streaming' | 'aborting' | 'error';
+export interface AgentChatAgentProfile<TMeta extends AgentChatMetadata = AgentChatMetadata> {
+    id?: AgentChatID;
+    name?: string;
+    description?: string;
+    avatarUrl?: string;
+    metadata?: TMeta;
+}
+export interface AgentChatAgentRequest {
+    agentId?: string;
+}
+/** Agent conversation metadata shown in a session picker. */
+export interface AgentChatSession<TMeta extends AgentChatMetadata = AgentChatMetadata> {
+    id: AgentChatID;
+    name?: string;
+    createdAt?: string;
+    lastUsedAt?: string;
+    metadata?: TMeta;
+}
+export interface AgentChatSessionListRequest {
+    agentId?: string;
+}
+export interface AgentChatSessionListResult<TMeta extends AgentChatMetadata = AgentChatMetadata> {
+    sessions: AgentChatSession<TMeta>[];
+    /** Backend-selected/default active session, usually the most recently used session. */
+    activeSessionId?: AgentChatID;
+    metadata?: TMeta;
+}
+export interface AgentChatRenameSessionRequest {
+    agentId?: string;
+    sessionId: AgentChatID;
+    name: string;
+}
+/** Token accounting reported by a transport or stream. */
+export interface AgentChatTokenUsage {
+    input: number;
+    output: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+    cost?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        total?: number;
+    };
+}
+/** File or artifact shown in the chat transcript. */
+export interface AgentChatFile {
+    id?: AgentChatID;
+    name: string;
+    url?: string;
+    mimeType?: string;
+    size?: number;
+    objectKey?: string;
+    metadata?: AgentChatMetadata;
+}
+/** File selected by the user before submit. */
+export interface AgentChatPendingFile {
+    id: AgentChatID;
+    file?: File;
+    name: string;
+    mimeType?: string;
+    size?: number;
+    previewUrl?: string;
+    upload?: AgentChatFile;
+    status?: 'pending' | 'uploading' | 'uploaded' | 'failed';
+    error?: string;
+    metadata?: AgentChatMetadata;
+}
+/** Lifecycle state for a tool/action block. */
+export type AgentChatOperationStatus = 'running' | 'completed' | 'error';
+/** Tool call emitted by an agent runtime. */
+export interface AgentChatToolCall<TInput = unknown, TMeta extends AgentChatMetadata = AgentChatMetadata> {
+    id: AgentChatID;
+    name: string;
+    input?: TInput;
+    output?: string;
+    status: AgentChatOperationStatus;
+    error?: string;
+    startedAt?: string;
+    completedAt?: string;
+    exploratory?: boolean;
+    metadata?: TMeta;
+}
+/** Human-readable semantic action, optionally linked to a raw tool call. */
+export interface AgentChatAction<TData = unknown, TMeta extends AgentChatMetadata = AgentChatMetadata> {
+    id: AgentChatID;
+    type: string;
+    label: string;
+    status: AgentChatOperationStatus;
+    icon?: string;
+    toolCallId?: AgentChatID;
+    data?: TData;
+    error?: string;
+    metadata?: TMeta;
+}
+export interface AgentChatTextBlock {
+    type: 'text';
+    content: string;
+}
+export interface AgentChatThinkingBlock {
+    type: 'thinking';
+    content: string;
+}
+export interface AgentChatToolCallBlock<TToolInput = unknown, TMeta extends AgentChatMetadata = AgentChatMetadata> {
+    type: 'tool_call';
+    toolCall: AgentChatToolCall<TToolInput, TMeta>;
+}
+export interface AgentChatActionBlock<TActionData = unknown, TMeta extends AgentChatMetadata = AgentChatMetadata> {
+    type: 'action';
+    action: AgentChatAction<TActionData, TMeta>;
+}
+export interface AgentChatFileBlock {
+    type: 'file';
+    file: AgentChatFile;
+}
+export interface AgentChatInfoBlock {
+    type: 'info';
+    content: string;
+    tone?: 'default' | 'success' | 'warning' | 'error';
+}
+export interface AgentChatCustomBlock<TPayload = unknown> {
+    type: 'custom';
+    kind: string;
+    payload: TPayload;
+}
+/** Chronological block content inside assistant/system messages. */
+export type AgentChatContentBlock<TToolInput = unknown, TActionData = unknown, TMeta extends AgentChatMetadata = AgentChatMetadata> = AgentChatTextBlock | AgentChatThinkingBlock | AgentChatToolCallBlock<TToolInput, TMeta> | AgentChatActionBlock<TActionData, TMeta> | AgentChatFileBlock | AgentChatInfoBlock | AgentChatCustomBlock;
+/** A message row in the chat transcript. */
+export interface AgentChatMessage<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    id: AgentChatID;
+    role: AgentChatMessageRole;
+    content: string;
+    /** ISO 8601 timestamp. */
+    timestamp?: string;
+    /** Lumera request/turn id. Unique for user prompts; grouping-only for assistant rows. */
+    requestId?: AgentChatID;
+    /** Backend-backed status for the request turn, usually present on user rows. */
+    status?: AgentChatTurnStatus;
+    error?: string;
+    errorCategory?: string;
+    blocks?: AgentChatContentBlock<TToolInput, TActionData, TMeta>[];
+    toolCalls?: AgentChatToolCall<TToolInput, TMeta>[];
+    files?: AgentChatFile[];
+    metadata?: TMeta;
+}
+/** Stable request/response render grouping derived from messages. */
+export interface AgentChatTurn<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    id: AgentChatID;
+    requestId?: AgentChatID;
+    user?: AgentChatMessage<TMeta, TToolInput, TActionData>;
+    assistants: AgentChatMessage<TMeta, TToolInput, TActionData>[];
+    systems?: AgentChatMessage<TMeta, TToolInput, TActionData>[];
+    status?: AgentChatTurnStatus;
+    metadata?: TMeta;
+}
+/** Pagination metadata returned by a history transport. */
+export interface AgentChatHistoryPage {
+    limit: number;
+    hasMoreBefore: boolean;
+    beforeCursor?: string;
+    source?: string;
+    contextBoundary?: 'start' | 'compaction' | 'tail_limit' | string;
+    truncated?: boolean;
+    windowBytes?: number;
+    totalBytes?: number;
+}
+/** History result consumed by the chat controller. */
+export interface AgentChatHistoryResult<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    messages: AgentChatMessage<TMeta, TToolInput, TActionData>[];
+    /** Live/pending rows that have not yet been fully represented in messages. */
+    pending?: AgentChatMessage<TMeta, TToolInput, TActionData>[];
+    page?: AgentChatHistoryPage;
+}
+export interface AgentChatHistoryRequest {
+    agentId?: string;
+    sessionId: string;
+    limit?: number;
+    beforeCursor?: string;
+}
+export interface AgentChatSubmitInput {
+    message: string;
+    requestId?: AgentChatID;
+    sessionId: string;
+    files?: AgentChatPendingFile[];
+    metadata?: AgentChatMetadata;
+}
+export interface AgentChatSubmitResult<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    accepted: boolean;
+    requestId?: AgentChatID;
+    sessionId?: string;
+    pending?: AgentChatMessage<TMeta, TToolInput, TActionData>;
+    error?: string;
+    metadata?: TMeta;
+}
+export interface AgentChatAbortRequest {
+    agentId?: string;
+    sessionId: string;
+    requestId?: AgentChatID;
+}
+export interface AgentChatLoadEarlierRequest {
+    agentId?: string;
+    sessionId: string;
+    beforeCursor: string;
+    limit?: number;
+}
+export type AgentChatStreamEvent<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> = {
+    type: 'text_delta' | 'thinking_delta';
+    requestId?: AgentChatID;
+    delta: string;
+    metadata?: TMeta;
+} | {
+    type: 'message';
+    message: AgentChatMessage<TMeta, TToolInput, TActionData>;
+    metadata?: TMeta;
+} | {
+    type: 'tool_start' | 'tool_update' | 'tool_end';
+    requestId?: AgentChatID;
+    toolCall: AgentChatToolCall<TToolInput, TMeta>;
+    metadata?: TMeta;
+} | {
+    type: 'action';
+    requestId?: AgentChatID;
+    action: AgentChatAction<TActionData, TMeta>;
+    metadata?: TMeta;
+} | {
+    type: 'file';
+    requestId?: AgentChatID;
+    file: AgentChatFile;
+    metadata?: TMeta;
+} | {
+    type: 'info';
+    requestId?: AgentChatID;
+    content: string;
+    tone?: 'default' | 'success' | 'warning' | 'error';
+    metadata?: TMeta;
+} | {
+    type: 'usage';
+    requestId?: AgentChatID;
+    usage: AgentChatTokenUsage;
+    metadata?: TMeta;
+} | {
+    type: 'terminal';
+    requestId?: AgentChatID;
+    status?: AgentChatTerminalStatus;
+    error?: string;
+    metadata?: TMeta;
+} | {
+    type: 'error';
+    requestId?: AgentChatID;
+    error: string;
+    metadata?: TMeta;
+} | {
+    type: 'custom';
+    kind: string;
+    payload: unknown;
+    requestId?: AgentChatID;
+    metadata?: TMeta;
+};
+export interface AgentChatStreamHandlers<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    onEvent: (event: AgentChatStreamEvent<TMeta, TToolInput, TActionData>) => void;
+    onError?: (error: unknown) => void;
+    onClose?: () => void;
+}
+export interface AgentChatSubscription {
+    close: () => void;
+}
+/** Transport boundary for app-specific agent backends. */
+export interface AgentChatTransport<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    loadAgent?: (request: AgentChatAgentRequest) => Promise<AgentChatAgentProfile<TMeta>>;
+    listSessions?: (request: AgentChatSessionListRequest) => Promise<AgentChatSessionListResult<TMeta>>;
+    renameSession?: (request: AgentChatRenameSessionRequest) => Promise<AgentChatSession<TMeta>>;
+    loadHistory: (request: AgentChatHistoryRequest) => Promise<AgentChatHistoryResult<TMeta, TToolInput, TActionData>>;
+    sendMessage: (input: AgentChatSubmitInput) => Promise<AgentChatSubmitResult<TMeta, TToolInput, TActionData>>;
+    loadEarlier?: (request: AgentChatLoadEarlierRequest) => Promise<AgentChatHistoryResult<TMeta, TToolInput, TActionData>>;
+    subscribe?: (request: {
+        agentId?: string;
+        sessionId: string;
+        requestId?: AgentChatID;
+    }, handlers: AgentChatStreamHandlers<TMeta, TToolInput, TActionData>) => AgentChatSubscription;
+    abort?: (request: AgentChatAbortRequest) => Promise<void>;
+    uploadFile?: (file: File) => Promise<AgentChatFile>;
+}
+export interface AgentChatComposerState {
+    value: string;
+    pendingFiles: AgentChatPendingFile[];
+    disabled: boolean;
+    phase: AgentChatPhase;
+    queueLength: number;
+    canSubmit: boolean;
+    canAbort: boolean;
+    placeholder: string;
+}
+export interface AgentChatComposerActions {
+    setValue: (value: string) => void;
+    submit: () => void | Promise<void>;
+    abort: () => void | Promise<void>;
+    attachFiles?: (files: File[]) => void | Promise<void>;
+    removePendingFile?: (id: AgentChatID) => void;
+}
+export interface AgentChatMessageRendererProps<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    message: AgentChatMessage<TMeta, TToolInput, TActionData>;
+    turn?: AgentChatTurn<TMeta, TToolInput, TActionData>;
+    isStreaming?: boolean;
+    isLast?: boolean;
+}
+export interface AgentChatBlockRendererProps<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    block: AgentChatContentBlock<TToolInput, TActionData, TMeta>;
+    message: AgentChatMessage<TMeta, TToolInput, TActionData>;
+    isStreaming?: boolean;
+}
+export interface AgentChatComposerRendererProps {
+    state: AgentChatComposerState;
+    actions: AgentChatComposerActions;
+}
+/** Render slots for applications that need deeper visual customization. */
+export interface AgentChatRenderers<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    UserMessage?: ComponentType<AgentChatMessageRendererProps<TMeta, TToolInput, TActionData>>;
+    AssistantMessage?: ComponentType<AgentChatMessageRendererProps<TMeta, TToolInput, TActionData>>;
+    SystemMessage?: ComponentType<AgentChatMessageRendererProps<TMeta, TToolInput, TActionData>>;
+    ContentBlock?: ComponentType<AgentChatBlockRendererProps<TMeta, TToolInput, TActionData>>;
+    Composer?: ComponentType<AgentChatComposerRendererProps>;
+    EmptyState?: ComponentType;
+    ErrorState?: ComponentType<{
+        error: unknown;
+        retry?: () => void;
+    }>;
+    LoadingState?: ComponentType;
+    LoadEarlierButton?: ComponentType<{
+        loading: boolean;
+        onClick: () => void;
+    }>;
+}
+export interface AgentChatLabels {
+    placeholder?: string;
+    send?: string;
+    stop?: string;
+    queue?: string;
+    retry?: string;
+    loadEarlier?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+}
+export interface AgentChatResizableWidthOptions {
+    enabled?: boolean;
+    defaultWidth?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    edge?: 'left' | 'right';
+    storageKey?: string;
+}
+export interface AgentChatFeatureFlags {
+    attachments?: boolean;
+    webSearch?: boolean;
+    tokenUsage?: boolean;
+    toolDetails?: boolean;
+    loadEarlier?: boolean;
+    queueWhileStreaming?: boolean;
+    resizableWidth?: boolean | AgentChatResizableWidthOptions;
+}
+/** Public props for the future AgentChat component. */
+export interface AgentChatProps<TMeta extends AgentChatMetadata = AgentChatMetadata, TToolInput = unknown, TActionData = unknown> {
+    agentId?: string;
+    sessionId?: string;
+    agent?: AgentChatAgentProfile<TMeta>;
+    name?: string;
+    description?: string;
+    transport: AgentChatTransport<TMeta, TToolInput, TActionData>;
+    initialMessages?: AgentChatMessage<TMeta, TToolInput, TActionData>[];
+    initialPage?: AgentChatHistoryPage;
+    historyLimit?: number;
+    maxBufferedMessages?: number;
+    maxQueuedMessages?: number;
+    disabled?: boolean;
+    className?: string;
+    labels?: AgentChatLabels;
+    features?: AgentChatFeatureFlags;
+    renderers?: AgentChatRenderers<TMeta, TToolInput, TActionData>;
+    onMessagesChange?: (messages: AgentChatMessage<TMeta, TToolInput, TActionData>[]) => void;
+    onTurnComplete?: (turn: AgentChatTurn<TMeta, TToolInput, TActionData>) => void;
+    onError?: (error: unknown) => void;
+    children?: ReactNode;
+}
+//# sourceMappingURL=types.d.ts.map