@waniwani/sdk 0.21.4 → 0.22.0-beta.0

package/dist/chat/index.d.ts

@@ -590,6 +590,11 @@ interface ChatBaseProps {
     apiKey?: string;
     /** Chat API endpoint URL. Defaults to Waniwani hosted endpoint */
     api?: string;
+    /**
+     * Builds the transport turns are sent through. Defaults to the chat's own
+     * HTTP transport to `api`, which it also hands the factory as `fallback`.
+     */
+    transport?: ChatTransportFactory;
     /** Pre-loaded messages to display when the chat mounts. */
     initialMessages?: ai.UIMessage[];
     /** Initial greeting shown before user types */
@@ -869,6 +874,23 @@ interface ChatHandle {
         eventId: string;
     }>;
 }
+/** What the chat hands a transport factory. */
+interface ChatTransportContext {
+    /** The chat's HTTP transport to `api`. */
+    fallback: ai.ChatTransport<ai.UIMessage>;
+    headers: () => Record<string, string> | undefined;
+    /** The channel and visitor a turn is attributed to. */
+    body: () => Record<string, unknown>;
+    /** True while the thread needs what only `fallback` carries: attachments, model context, saved history. */
+    needsFallback: () => boolean;
+    onSession: (sessionId: string) => void;
+}
+/** Optional hooks the chat calls on a transport: ahead of the first message, and on unmount. */
+interface ChatTransportLifecycle {
+    prepare?(): void;
+    dispose?(): void;
+}
+type ChatTransportFactory = (context: ChatTransportContext) => ai.ChatTransport<ai.UIMessage> & ChatTransportLifecycle;
 
 type ModelContextContentBlock = ContentBlock;
 type ModelContextUpdate = {
@@ -959,6 +981,14 @@ type WebMcpContentBlock = {
     text?: string;
     [key: string]: unknown;
 };
+/** A tool as `tools/list` describes it. */
+type WebMcpTool = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    annotations?: Record<string, unknown>;
+    _meta?: Record<string, unknown>;
+};
 /**
  * Everything the page needs to mount a widget itself.
  *
@@ -997,6 +1027,46 @@ type WebMcpWidgetPayload = {
      */
     preview?: boolean;
 };
+type WebMcpCallResponse = {
+    content: WebMcpContentBlock[];
+    structuredContent?: Record<string, unknown>;
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+    /** Present and non-null only when the call produced a resolvable widget step. */
+    widget: WebMcpWidgetPayload | null;
+};
+
+/**
+ * The WebMCP bridge.
+ *
+ * A browsing agent standing on a page never speaks to the MCP server. It speaks
+ * to the page, through `document.modelContext`, and this is what puts the
+ * server's tools there. Every `execute()` the agent calls lands on the endpoint
+ * below, which stamps attribution server-side and answers.
+ *
+ * Nothing here discovers its own configuration. The endpoint, both ids, and the
+ * widget callback are arguments, because there are two callers with two
+ * different ways of knowing them: the chat embed reads them from its remote
+ * config, and the standalone loader derives them from its own script tag.
+ * Sniffing `document.currentScript` inside a bundle that may be loaded twenty
+ * modules deep finds the wrong script or none.
+ */
+
+/** Live for as long as the bridge is registered. */
+type WebMcpBridge = {
+    /** Tools successfully registered with the browser. */
+    readonly tools: WebMcpTool[];
+    /**
+     * Call a tool with the bridge's auth and identity, for a mounted view's own
+     * `tools/call`. Resolves to the raw response; widgets are not re-dispatched.
+     */
+    callTool: (params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }) => Promise<WebMcpCallResponse>;
+    /** Unregister everything. Idempotent. */
+    dispose: () => void;
+};
 
 /**
  * `McpAppFrame` is used exactly as the chat uses it, with no new props.
@@ -1019,9 +1089,14 @@ type WebMcpWidgetPayload = {
 type WebMcpOverlayProps = {
     /** The step to show, or `null` for nothing. */
     widget: WebMcpWidgetPayload | null;
-    /** The tools endpoint, so a view's own `tools/call` can be proxied. */
-    toolsEndpoint: string;
-    /** Auth for that endpoint, matching what the bridge sends. */
+    /**
+     * Proxies a view's own `tools/call`. Pass the bridge's `callTool` so the
+     * request carries the same auth and session identity as the agent's calls.
+     */
+    onCallTool?: WebMcpBridge["callTool"];
+    /** @deprecated Pass `onCallTool`. Removed in 0.23.0. */
+    toolsEndpoint?: string;
+    /** @deprecated Pass `onCallTool`. Removed in 0.23.0. */
     headers?: Record<string, string>;
     /**
      * Where view HTML is fetched from, resolved from the token the same way the
@@ -1032,7 +1107,7 @@ type WebMcpOverlayProps = {
     onClose: () => void;
     isDark?: boolean;
 };
-declare function WebMcpOverlay({ widget, toolsEndpoint, resourceEndpoint, headers, onClose, isDark, }: WebMcpOverlayProps): react_jsx_runtime.JSX.Element | null;
+declare function WebMcpOverlay({ widget, onCallTool, toolsEndpoint, headers, resourceEndpoint, onClose, isDark, }: WebMcpOverlayProps): react_jsx_runtime.JSX.Element | null;
 
 /**
  * **Bare-bones, bring-your-own-backend chat primitive.** Most apps want
@@ -1100,6 +1175,12 @@ interface WaniwaniChatOverrides {
     api?: string;
     /** Override the MCP server URL (rarely needed). */
     mcpServerUrl?: string;
+    /**
+     * The app's agent-runtime session route (`/api/mcp/agent/session`). Set,
+     * turns go straight to the agent runtime for a chat the route admits, and
+     * through `api` for one it does not.
+     */
+    sessionApi?: string;
     /**
      * AI transparency notice rendered under the input (EU AI Act compliance).
      * String overrides the default wording; `false` hides it.