@tanstack/ai-client 0.0.1

package/dist/esm/connection-adapters.d.ts

@@ -0,0 +1,124 @@
+import { ModelMessage, StreamChunk, UIMessage } from '@tanstack/ai';
+/**
+ * Connection adapter interface - converts a connection into a stream of chunks
+ */
+export interface ConnectionAdapter {
+    /**
+     * Connect and return an async iterable of StreamChunks
+     * @param messages - The messages to send (UIMessages or ModelMessages)
+     * @param data - Additional data to send
+     * @param abortSignal - Optional abort signal for request cancellation
+     */
+    connect: (messages: Array<UIMessage> | Array<ModelMessage>, data?: Record<string, any>, abortSignal?: AbortSignal) => AsyncIterable<StreamChunk>;
+}
+/**
+ * Options for fetch-based connection adapters
+ */
+export interface FetchConnectionOptions {
+    headers?: Record<string, string> | Headers;
+    credentials?: RequestCredentials;
+    signal?: AbortSignal;
+    body?: Record<string, any>;
+}
+/**
+ * Create a Server-Sent Events connection adapter
+ *
+ * @param url - The API endpoint URL (or a function that returns the URL)
+ * @param options - Fetch options (headers, credentials, body, etc.) or a function that returns options (can be async)
+ * @returns A connection adapter for SSE streams
+ *
+ * @example
+ * ```typescript
+ * // Static URL
+ * const connection = fetchServerSentEvents('/api/chat');
+ *
+ * // Dynamic URL
+ * const connection = fetchServerSentEvents(() => `/api/chat?user=${userId}`);
+ *
+ * // With options
+ * const connection = fetchServerSentEvents('/api/chat', {
+ *   headers: { 'Authorization': 'Bearer token' }
+ * });
+ *
+ * // With dynamic options
+ * const connection = fetchServerSentEvents('/api/chat', () => ({
+ *   headers: { 'Authorization': `Bearer ${getToken()}` }
+ * }));
+ *
+ * // With additional body data
+ * const connection = fetchServerSentEvents('/api/chat', async () => ({
+ *   body: {
+ *     provider: 'openai',
+ *     model: 'gpt-4o',
+ *   }
+ * }));
+ * ```
+ */
+export declare function fetchServerSentEvents(url: string | (() => string), options?: FetchConnectionOptions | (() => FetchConnectionOptions | Promise<FetchConnectionOptions>)): ConnectionAdapter;
+/**
+ * Create an HTTP streaming connection adapter (for raw streaming without SSE format)
+ *
+ * @param url - The API endpoint URL (or a function that returns the URL)
+ * @param options - Fetch options (headers, credentials, body, etc.) or a function that returns options (can be async)
+ * @returns A connection adapter for HTTP streams
+ *
+ * @example
+ * ```typescript
+ * // Static URL
+ * const connection = fetchHttpStream('/api/chat');
+ *
+ * // Dynamic URL
+ * const connection = fetchHttpStream(() => `/api/chat?user=${userId}`);
+ *
+ * // With options
+ * const connection = fetchHttpStream('/api/chat', {
+ *   headers: { 'Authorization': 'Bearer token' }
+ * });
+ *
+ * // With dynamic options
+ * const connection = fetchHttpStream('/api/chat', () => ({
+ *   headers: { 'Authorization': `Bearer ${getToken()}` }
+ * }));
+ *
+ * // With additional body data
+ * const connection = fetchHttpStream('/api/chat', async () => ({
+ *   body: {
+ *     provider: 'openai',
+ *     model: 'gpt-4o',
+ *   }
+ * }));
+ * ```
+ */
+export declare function fetchHttpStream(url: string | (() => string), options?: FetchConnectionOptions | (() => FetchConnectionOptions | Promise<FetchConnectionOptions>)): ConnectionAdapter;
+/**
+ * Create a direct stream connection adapter (for server functions or direct streams)
+ *
+ * @param streamFactory - A function that returns an async iterable of StreamChunks
+ * @returns A connection adapter for direct streams
+ *
+ * @example
+ * ```typescript
+ * // With TanStack Start server function
+ * const connection = stream(() => serverFunction({ messages }));
+ *
+ * const client = new ChatClient({ connection });
+ * ```
+ */
+export declare function stream(streamFactory: (messages: Array<ModelMessage>, data?: Record<string, any>) => AsyncIterable<StreamChunk>): ConnectionAdapter;
+/**
+ * Create an RPC stream connection adapter (for RPC-based streaming like Cap'n Web RPC)
+ *
+ * @param rpcCall - A function that accepts messages and returns an async iterable of StreamChunks
+ * @returns A connection adapter for RPC streams
+ *
+ * @example
+ * ```typescript
+ * // With Cap'n Web RPC
+ * const connection = rpcStream((messages, data) =>
+ *   api.streamMurfResponse(messages, data)
+ * );
+ *
+ * const client = new ChatClient({ connection });
+ * ```
+ */
+export declare function rpcStream(rpcCall: (messages: Array<ModelMessage>, data?: Record<string, any>) => AsyncIterable<StreamChunk>): ConnectionAdapter;

package/dist/esm/connection-adapters.js

@@ -0,0 +1,149 @@
+import { convertMessagesToModelMessages } from "@tanstack/ai";
+function mergeHeaders(customHeaders) {
+  if (!customHeaders) {
+    return {};
+  }
+  if (customHeaders instanceof Headers) {
+    const result = {};
+    customHeaders.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  return customHeaders;
+}
+async function* readStreamLines(reader, abortSignal) {
+  try {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      if (abortSignal?.aborted) {
+        break;
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.trim()) {
+          yield line;
+        }
+      }
+    }
+    if (buffer.trim()) {
+      yield buffer;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function fetchServerSentEvents(url, options = {}) {
+  return {
+    async *connect(messages, data, abortSignal) {
+      const resolvedUrl = typeof url === "function" ? url() : url;
+      const resolvedOptions = typeof options === "function" ? await options() : options;
+      const modelMessages = convertMessagesToModelMessages(messages);
+      const requestHeaders = {
+        "Content-Type": "application/json",
+        ...mergeHeaders(resolvedOptions.headers)
+      };
+      const requestBody = {
+        messages: modelMessages,
+        data,
+        ...resolvedOptions.body
+      };
+      const response = await fetch(resolvedUrl, {
+        method: "POST",
+        headers: requestHeaders,
+        body: JSON.stringify(requestBody),
+        credentials: resolvedOptions.credentials || "same-origin",
+        signal: abortSignal || resolvedOptions.signal
+      });
+      if (!response.ok) {
+        throw new Error(
+          `HTTP error! status: ${response.status} ${response.statusText}`
+        );
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      for await (const line of readStreamLines(reader, abortSignal)) {
+        const data2 = line.startsWith("data: ") ? line.slice(6) : line;
+        if (data2 === "[DONE]") continue;
+        try {
+          const parsed = JSON.parse(data2);
+          yield parsed;
+        } catch (parseError) {
+          console.warn("Failed to parse SSE chunk:", data2);
+        }
+      }
+    }
+  };
+}
+function fetchHttpStream(url, options = {}) {
+  return {
+    async *connect(messages, data, abortSignal) {
+      const resolvedUrl = typeof url === "function" ? url() : url;
+      const resolvedOptions = typeof options === "function" ? await options() : options;
+      const modelMessages = convertMessagesToModelMessages(messages);
+      const requestHeaders = {
+        "Content-Type": "application/json",
+        ...mergeHeaders(resolvedOptions.headers)
+      };
+      const requestBody = {
+        messages: modelMessages,
+        data,
+        ...resolvedOptions.body
+      };
+      const response = await fetch(resolvedUrl, {
+        method: "POST",
+        headers: requestHeaders,
+        body: JSON.stringify(requestBody),
+        credentials: resolvedOptions.credentials || "same-origin",
+        signal: abortSignal || resolvedOptions.signal
+      });
+      if (!response.ok) {
+        throw new Error(
+          `HTTP error! status: ${response.status} ${response.statusText}`
+        );
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      for await (const line of readStreamLines(reader, abortSignal)) {
+        try {
+          const parsed = JSON.parse(line);
+          yield parsed;
+        } catch (parseError) {
+          console.warn("Failed to parse HTTP stream chunk:", line);
+        }
+      }
+    }
+  };
+}
+function stream(streamFactory) {
+  return {
+    async *connect(messages, data) {
+      const modelMessages = convertMessagesToModelMessages(messages);
+      yield* streamFactory(modelMessages, data);
+    }
+  };
+}
+function rpcStream(rpcCall) {
+  return {
+    async *connect(messages, data) {
+      const modelMessages = convertMessagesToModelMessages(messages);
+      yield* rpcCall(modelMessages, data);
+    }
+  };
+}
+export {
+  fetchHttpStream,
+  fetchServerSentEvents,
+  rpcStream,
+  stream
+};
+//# sourceMappingURL=connection-adapters.js.map

package/dist/esm/connection-adapters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-adapters.js","sources":["../../src/connection-adapters.ts"],"sourcesContent":["import { convertMessagesToModelMessages } from '@tanstack/ai'\nimport type { ModelMessage, StreamChunk, UIMessage } from '@tanstack/ai'\n\n/**\n * Merge custom headers into request headers\n */\nfunction mergeHeaders(\n  customHeaders?: Record<string, string> | Headers,\n): Record<string, string> {\n  if (!customHeaders) {\n    return {}\n  }\n  if (customHeaders instanceof Headers) {\n    const result: Record<string, string> = {}\n    customHeaders.forEach((value, key) => {\n      result[key] = value\n    })\n    return result\n  }\n  return customHeaders\n}\n\n/**\n * Read lines from a stream (newline-delimited)\n */\nasync function* readStreamLines(\n  reader: ReadableStreamDefaultReader<Uint8Array>,\n  abortSignal?: AbortSignal,\n): AsyncGenerator<string> {\n  try {\n    const decoder = new TextDecoder()\n    let buffer = ''\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    while (true) {\n      // Check if aborted before reading\n      if (abortSignal?.aborted) {\n        break\n      }\n\n      const { done, value } = await reader.read()\n      if (done) break\n\n      buffer += decoder.decode(value, { stream: true })\n      const lines = buffer.split('\\n')\n\n      // Keep the last incomplete line in the buffer\n      buffer = lines.pop() || ''\n\n      for (const line of lines) {\n        if (line.trim()) {\n          yield line\n        }\n      }\n    }\n\n    // Process any remaining data in the buffer\n    if (buffer.trim()) {\n      yield buffer\n    }\n  } finally {\n    reader.releaseLock()\n  }\n}\n\n/**\n * Connection adapter interface - converts a connection into a stream of chunks\n */\nexport interface ConnectionAdapter {\n  /**\n   * Connect and return an async iterable of StreamChunks\n   * @param messages - The messages to send (UIMessages or ModelMessages)\n   * @param data - Additional data to send\n   * @param abortSignal - Optional abort signal for request cancellation\n   */\n  connect: (\n    messages: Array<UIMessage> | Array<ModelMessage>,\n    data?: Record<string, any>,\n    abortSignal?: AbortSignal,\n  ) => AsyncIterable<StreamChunk>\n}\n\n/**\n * Options for fetch-based connection adapters\n */\nexport interface FetchConnectionOptions {\n  headers?: Record<string, string> | Headers\n  credentials?: RequestCredentials\n  signal?: AbortSignal\n  body?: Record<string, any>\n}\n\n/**\n * Create a Server-Sent Events connection adapter\n *\n * @param url - The API endpoint URL (or a function that returns the URL)\n * @param options - Fetch options (headers, credentials, body, etc.) or a function that returns options (can be async)\n * @returns A connection adapter for SSE streams\n *\n * @example\n * ```typescript\n * // Static URL\n * const connection = fetchServerSentEvents('/api/chat');\n *\n * // Dynamic URL\n * const connection = fetchServerSentEvents(() => `/api/chat?user=${userId}`);\n *\n * // With options\n * const connection = fetchServerSentEvents('/api/chat', {\n *   headers: { 'Authorization': 'Bearer token' }\n * });\n *\n * // With dynamic options\n * const connection = fetchServerSentEvents('/api/chat', () => ({\n *   headers: { 'Authorization': `Bearer ${getToken()}` }\n * }));\n *\n * // With additional body data\n * const connection = fetchServerSentEvents('/api/chat', async () => ({\n *   body: {\n *     provider: 'openai',\n *     model: 'gpt-4o',\n *   }\n * }));\n * ```\n */\nexport function fetchServerSentEvents(\n  url: string | (() => string),\n  options:\n    | FetchConnectionOptions\n    | (() => FetchConnectionOptions | Promise<FetchConnectionOptions>) = {},\n): ConnectionAdapter {\n  return {\n    async *connect(messages, data, abortSignal) {\n      // Resolve URL and options if they are functions\n      const resolvedUrl = typeof url === 'function' ? url() : url\n      const resolvedOptions =\n        typeof options === 'function' ? await options() : options\n\n      const modelMessages = convertMessagesToModelMessages(messages)\n\n      const requestHeaders: Record<string, string> = {\n        'Content-Type': 'application/json',\n        ...mergeHeaders(resolvedOptions.headers),\n      }\n\n      // Merge body from options with messages and data\n      const requestBody = {\n        messages: modelMessages,\n        data,\n        ...resolvedOptions.body,\n      }\n\n      const response = await fetch(resolvedUrl, {\n        method: 'POST',\n        headers: requestHeaders,\n        body: JSON.stringify(requestBody),\n        credentials: resolvedOptions.credentials || 'same-origin',\n        signal: abortSignal || resolvedOptions.signal,\n      })\n\n      if (!response.ok) {\n        throw new Error(\n          `HTTP error! status: ${response.status} ${response.statusText}`,\n        )\n      }\n\n      // Parse Server-Sent Events format\n      const reader = response.body?.getReader()\n      if (!reader) {\n        throw new Error('Response body is not readable')\n      }\n\n      for await (const line of readStreamLines(reader, abortSignal)) {\n        // Handle Server-Sent Events format\n        const data = line.startsWith('data: ') ? line.slice(6) : line\n\n        if (data === '[DONE]') continue\n\n        try {\n          const parsed: StreamChunk = JSON.parse(data)\n          yield parsed\n        } catch (parseError) {\n          // Skip non-JSON lines or malformed chunks\n          console.warn('Failed to parse SSE chunk:', data)\n        }\n      }\n    },\n  }\n}\n\n/**\n * Create an HTTP streaming connection adapter (for raw streaming without SSE format)\n *\n * @param url - The API endpoint URL (or a function that returns the URL)\n * @param options - Fetch options (headers, credentials, body, etc.) or a function that returns options (can be async)\n * @returns A connection adapter for HTTP streams\n *\n * @example\n * ```typescript\n * // Static URL\n * const connection = fetchHttpStream('/api/chat');\n *\n * // Dynamic URL\n * const connection = fetchHttpStream(() => `/api/chat?user=${userId}`);\n *\n * // With options\n * const connection = fetchHttpStream('/api/chat', {\n *   headers: { 'Authorization': 'Bearer token' }\n * });\n *\n * // With dynamic options\n * const connection = fetchHttpStream('/api/chat', () => ({\n *   headers: { 'Authorization': `Bearer ${getToken()}` }\n * }));\n *\n * // With additional body data\n * const connection = fetchHttpStream('/api/chat', async () => ({\n *   body: {\n *     provider: 'openai',\n *     model: 'gpt-4o',\n *   }\n * }));\n * ```\n */\nexport function fetchHttpStream(\n  url: string | (() => string),\n  options:\n    | FetchConnectionOptions\n    | (() => FetchConnectionOptions | Promise<FetchConnectionOptions>) = {},\n): ConnectionAdapter {\n  return {\n    async *connect(messages, data, abortSignal) {\n      // Resolve URL and options if they are functions\n      const resolvedUrl = typeof url === 'function' ? url() : url\n      const resolvedOptions =\n        typeof options === 'function' ? await options() : options\n\n      // Convert UIMessages to ModelMessages if needed\n      const modelMessages = convertMessagesToModelMessages(messages)\n\n      const requestHeaders: Record<string, string> = {\n        'Content-Type': 'application/json',\n        ...mergeHeaders(resolvedOptions.headers),\n      }\n\n      // Merge body from options with messages and data\n      const requestBody = {\n        messages: modelMessages,\n        data,\n        ...resolvedOptions.body,\n      }\n\n      const response = await fetch(resolvedUrl, {\n        method: 'POST',\n        headers: requestHeaders,\n        body: JSON.stringify(requestBody),\n        credentials: resolvedOptions.credentials || 'same-origin',\n        signal: abortSignal || resolvedOptions.signal,\n      })\n\n      if (!response.ok) {\n        throw new Error(\n          `HTTP error! status: ${response.status} ${response.statusText}`,\n        )\n      }\n\n      // Parse raw HTTP stream (newline-delimited JSON)\n      const reader = response.body?.getReader()\n      if (!reader) {\n        throw new Error('Response body is not readable')\n      }\n\n      for await (const line of readStreamLines(reader, abortSignal)) {\n        try {\n          const parsed: StreamChunk = JSON.parse(line)\n          yield parsed\n        } catch (parseError) {\n          console.warn('Failed to parse HTTP stream chunk:', line)\n        }\n      }\n    },\n  }\n}\n\n/**\n * Create a direct stream connection adapter (for server functions or direct streams)\n *\n * @param streamFactory - A function that returns an async iterable of StreamChunks\n * @returns A connection adapter for direct streams\n *\n * @example\n * ```typescript\n * // With TanStack Start server function\n * const connection = stream(() => serverFunction({ messages }));\n *\n * const client = new ChatClient({ connection });\n * ```\n */\nexport function stream(\n  streamFactory: (\n    messages: Array<ModelMessage>,\n    data?: Record<string, any>,\n  ) => AsyncIterable<StreamChunk>,\n): ConnectionAdapter {\n  return {\n    async *connect(messages, data) {\n      const modelMessages = convertMessagesToModelMessages(messages)\n      yield* streamFactory(modelMessages, data)\n    },\n  }\n}\n\n/**\n * Create an RPC stream connection adapter (for RPC-based streaming like Cap'n Web RPC)\n *\n * @param rpcCall - A function that accepts messages and returns an async iterable of StreamChunks\n * @returns A connection adapter for RPC streams\n *\n * @example\n * ```typescript\n * // With Cap'n Web RPC\n * const connection = rpcStream((messages, data) =>\n *   api.streamMurfResponse(messages, data)\n * );\n *\n * const client = new ChatClient({ connection });\n * ```\n */\nexport function rpcStream(\n  rpcCall: (\n    messages: Array<ModelMessage>,\n    data?: Record<string, any>,\n  ) => AsyncIterable<StreamChunk>,\n): ConnectionAdapter {\n  return {\n    async *connect(messages, data) {\n      const modelMessages = convertMessagesToModelMessages(messages)\n      // Simply yield from the RPC call\n      // The RPC layer handles WebSocket transport\n      yield* rpcCall(modelMessages, data)\n    },\n  }\n}\n"],"names":["data"],"mappings":"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"}

package/dist/esm/events.d.ts

@@ -0,0 +1,82 @@
+import { UIMessage } from './types.js';
+/**
+ * Abstract base class for ChatClient event emission
+ */
+export declare abstract class ChatClientEventEmitter {
+    protected clientId: string;
+    constructor(clientId: string);
+    /**
+     * Protected abstract method for emitting events
+     * Implementations should handle adding clientId and timestamp
+     */
+    protected abstract emitEvent(eventName: string, data?: Record<string, any>): void;
+    /**
+     * Emit client created event
+     */
+    clientCreated(initialMessageCount: number): void;
+    /**
+     * Emit loading state changed event
+     */
+    loadingChanged(isLoading: boolean): void;
+    /**
+     * Emit error state changed event
+     */
+    errorChanged(error: string | null): void;
+    /**
+     * Emit text update events (combines processor and client events)
+     */
+    textUpdated(streamId: string, messageId: string, content: string): void;
+    /**
+     * Emit tool call state change events (combines processor and client events)
+     */
+    toolCallStateChanged(streamId: string, messageId: string, toolCallId: string, toolName: string, state: string, args: string): void;
+    /**
+     * Emit tool result state change event
+     */
+    toolResultStateChanged(streamId: string, toolCallId: string, content: string, state: string, error?: string): void;
+    /**
+     * Emit thinking update event
+     */
+    thinkingUpdated(streamId: string, messageId: string, content: string, delta?: string): void;
+    /**
+     * Emit approval requested event
+     */
+    approvalRequested(messageId: string, toolCallId: string, toolName: string, input: any, approvalId: string): void;
+    /**
+     * Emit message appended event
+     */
+    messageAppended(uiMessage: UIMessage): void;
+    /**
+     * Emit message sent event
+     */
+    messageSent(messageId: string, content: string): void;
+    /**
+     * Emit reloaded event
+     */
+    reloaded(fromMessageIndex: number): void;
+    /**
+     * Emit stopped event
+     */
+    stopped(): void;
+    /**
+     * Emit messages cleared event
+     */
+    messagesCleared(): void;
+    /**
+     * Emit tool result added event
+     */
+    toolResultAdded(toolCallId: string, toolName: string, output: any, state: string): void;
+    /**
+     * Emit tool approval responded event
+     */
+    toolApprovalResponded(approvalId: string, toolCallId: string, approved: boolean): void;
+}
+/**
+ * Default implementation of ChatClientEventEmitter
+ */
+export declare class DefaultChatClientEventEmitter extends ChatClientEventEmitter {
+    /**
+     * Emit an event with automatic clientId and timestamp for client/tool events
+     */
+    protected emitEvent(eventName: string, data?: Record<string, any>): void;
+}

package/dist/esm/events.js

@@ -0,0 +1,180 @@
+import { aiEventClient } from "@tanstack/ai/event-client";
+class ChatClientEventEmitter {
+  constructor(clientId) {
+    this.clientId = clientId;
+  }
+  /**
+   * Emit client created event
+   */
+  clientCreated(initialMessageCount) {
+    this.emitEvent("client:created", {
+      initialMessageCount
+    });
+  }
+  /**
+   * Emit loading state changed event
+   */
+  loadingChanged(isLoading) {
+    this.emitEvent("client:loading-changed", { isLoading });
+  }
+  /**
+   * Emit error state changed event
+   */
+  errorChanged(error) {
+    this.emitEvent("client:error-changed", {
+      error
+    });
+  }
+  /**
+   * Emit text update events (combines processor and client events)
+   */
+  textUpdated(streamId, messageId, content) {
+    this.emitEvent("processor:text-updated", {
+      streamId,
+      content
+    });
+    this.emitEvent("client:assistant-message-updated", {
+      messageId,
+      content
+    });
+  }
+  /**
+   * Emit tool call state change events (combines processor and client events)
+   */
+  toolCallStateChanged(streamId, messageId, toolCallId, toolName, state, args) {
+    this.emitEvent("processor:tool-call-state-changed", {
+      streamId,
+      toolCallId,
+      toolName,
+      state,
+      arguments: args
+    });
+    this.emitEvent("client:tool-call-updated", {
+      messageId,
+      toolCallId,
+      toolName,
+      state,
+      arguments: args
+    });
+  }
+  /**
+   * Emit tool result state change event
+   */
+  toolResultStateChanged(streamId, toolCallId, content, state, error) {
+    this.emitEvent("processor:tool-result-state-changed", {
+      streamId,
+      toolCallId,
+      content,
+      state,
+      error
+    });
+  }
+  /**
+   * Emit thinking update event
+   */
+  thinkingUpdated(streamId, messageId, content, delta) {
+    this.emitEvent("stream:chunk:thinking", {
+      streamId,
+      messageId,
+      content,
+      delta
+    });
+  }
+  /**
+   * Emit approval requested event
+   */
+  approvalRequested(messageId, toolCallId, toolName, input, approvalId) {
+    this.emitEvent("client:approval-requested", {
+      messageId,
+      toolCallId,
+      toolName,
+      input,
+      approvalId
+    });
+  }
+  /**
+   * Emit message appended event
+   */
+  messageAppended(uiMessage) {
+    const contentPreview = uiMessage.parts.filter((p) => p.type === "text").map((p) => p.content).join(" ").substring(0, 100);
+    this.emitEvent("client:message-appended", {
+      messageId: uiMessage.id,
+      role: uiMessage.role,
+      contentPreview
+    });
+  }
+  /**
+   * Emit message sent event
+   */
+  messageSent(messageId, content) {
+    this.emitEvent("client:message-sent", {
+      messageId,
+      content
+    });
+  }
+  /**
+   * Emit reloaded event
+   */
+  reloaded(fromMessageIndex) {
+    this.emitEvent("client:reloaded", {
+      fromMessageIndex
+    });
+  }
+  /**
+   * Emit stopped event
+   */
+  stopped() {
+    this.emitEvent("client:stopped");
+  }
+  /**
+   * Emit messages cleared event
+   */
+  messagesCleared() {
+    this.emitEvent("client:messages-cleared");
+  }
+  /**
+   * Emit tool result added event
+   */
+  toolResultAdded(toolCallId, toolName, output, state) {
+    this.emitEvent("tool:result-added", {
+      toolCallId,
+      toolName,
+      output,
+      state
+    });
+  }
+  /**
+   * Emit tool approval responded event
+   */
+  toolApprovalResponded(approvalId, toolCallId, approved) {
+    this.emitEvent("tool:approval-responded", {
+      approvalId,
+      toolCallId,
+      approved
+    });
+  }
+}
+class DefaultChatClientEventEmitter extends ChatClientEventEmitter {
+  /**
+   * Emit an event with automatic clientId and timestamp for client/tool events
+   */
+  emitEvent(eventName, data) {
+    if (eventName.startsWith("client:") || eventName.startsWith("tool:")) {
+      aiEventClient.emit(eventName, {
+        ...data,
+        clientId: this.clientId,
+        timestamp: Date.now()
+      });
+    } else {
+      aiEventClient.emit(eventName, {
+        ...data,
+        timestamp: Date.now()
+      });
+    }
+  }
+}
+export {
+  ChatClientEventEmitter,
+  DefaultChatClientEventEmitter
+};
+//# sourceMappingURL=events.js.map

package/dist/esm/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sources":["../../src/events.ts"],"sourcesContent":["import { aiEventClient } from '@tanstack/ai/event-client'\nimport type { UIMessage } from './types'\n\n/**\n * Abstract base class for ChatClient event emission\n */\nexport abstract class ChatClientEventEmitter {\n  protected clientId: string\n\n  constructor(clientId: string) {\n    this.clientId = clientId\n  }\n\n  /**\n   * Protected abstract method for emitting events\n   * Implementations should handle adding clientId and timestamp\n   */\n  protected abstract emitEvent(\n    eventName: string,\n    data?: Record<string, any>,\n  ): void\n\n  /**\n   * Emit client created event\n   */\n  clientCreated(initialMessageCount: number): void {\n    this.emitEvent('client:created', {\n      initialMessageCount,\n    })\n  }\n\n  /**\n   * Emit loading state changed event\n   */\n  loadingChanged(isLoading: boolean): void {\n    this.emitEvent('client:loading-changed', { isLoading })\n  }\n\n  /**\n   * Emit error state changed event\n   */\n  errorChanged(error: string | null): void {\n    this.emitEvent('client:error-changed', {\n      error,\n    })\n  }\n\n  /**\n   * Emit text update events (combines processor and client events)\n   */\n  textUpdated(streamId: string, messageId: string, content: string): void {\n    this.emitEvent('processor:text-updated', {\n      streamId,\n      content,\n    })\n\n    this.emitEvent('client:assistant-message-updated', {\n      messageId,\n      content,\n    })\n  }\n\n  /**\n   * Emit tool call state change events (combines processor and client events)\n   */\n  toolCallStateChanged(\n    streamId: string,\n    messageId: string,\n    toolCallId: string,\n    toolName: string,\n    state: string,\n    args: string,\n  ): void {\n    this.emitEvent('processor:tool-call-state-changed', {\n      streamId,\n      toolCallId,\n      toolName,\n      state,\n      arguments: args,\n    })\n\n    this.emitEvent('client:tool-call-updated', {\n      messageId,\n      toolCallId,\n      toolName,\n      state,\n      arguments: args,\n    })\n  }\n\n  /**\n   * Emit tool result state change event\n   */\n  toolResultStateChanged(\n    streamId: string,\n    toolCallId: string,\n    content: string,\n    state: string,\n    error?: string,\n  ): void {\n    this.emitEvent('processor:tool-result-state-changed', {\n      streamId,\n      toolCallId,\n      content,\n      state,\n      error,\n    })\n  }\n\n  /**\n   * Emit thinking update event\n   */\n  thinkingUpdated(\n    streamId: string,\n    messageId: string,\n    content: string,\n    delta?: string,\n  ): void {\n    this.emitEvent('stream:chunk:thinking', {\n      streamId,\n      messageId,\n      content,\n      delta,\n    })\n  }\n\n  /**\n   * Emit approval requested event\n   */\n  approvalRequested(\n    messageId: string,\n    toolCallId: string,\n    toolName: string,\n    input: any,\n    approvalId: string,\n  ): void {\n    this.emitEvent('client:approval-requested', {\n      messageId,\n      toolCallId,\n      toolName,\n      input,\n      approvalId,\n    })\n  }\n\n  /**\n   * Emit message appended event\n   */\n  messageAppended(uiMessage: UIMessage): void {\n    const contentPreview = uiMessage.parts\n      .filter((p) => p.type === 'text')\n      .map((p) => (p as any).content)\n      .join(' ')\n      .substring(0, 100)\n\n    this.emitEvent('client:message-appended', {\n      messageId: uiMessage.id,\n      role: uiMessage.role,\n      contentPreview,\n    })\n  }\n\n  /**\n   * Emit message sent event\n   */\n  messageSent(messageId: string, content: string): void {\n    this.emitEvent('client:message-sent', {\n      messageId,\n      content,\n    })\n  }\n\n  /**\n   * Emit reloaded event\n   */\n  reloaded(fromMessageIndex: number): void {\n    this.emitEvent('client:reloaded', {\n      fromMessageIndex,\n    })\n  }\n\n  /**\n   * Emit stopped event\n   */\n  stopped(): void {\n    this.emitEvent('client:stopped')\n  }\n\n  /**\n   * Emit messages cleared event\n   */\n  messagesCleared(): void {\n    this.emitEvent('client:messages-cleared')\n  }\n\n  /**\n   * Emit tool result added event\n   */\n  toolResultAdded(\n    toolCallId: string,\n    toolName: string,\n    output: any,\n    state: string,\n  ): void {\n    this.emitEvent('tool:result-added', {\n      toolCallId,\n      toolName,\n      output,\n      state,\n    })\n  }\n\n  /**\n   * Emit tool approval responded event\n   */\n  toolApprovalResponded(\n    approvalId: string,\n    toolCallId: string,\n    approved: boolean,\n  ): void {\n    this.emitEvent('tool:approval-responded', {\n      approvalId,\n      toolCallId,\n      approved,\n    })\n  }\n}\n\n/**\n * Default implementation of ChatClientEventEmitter\n */\nexport class DefaultChatClientEventEmitter extends ChatClientEventEmitter {\n  /**\n   * Emit an event with automatic clientId and timestamp for client/tool events\n   */\n  protected emitEvent(eventName: string, data?: Record<string, any>): void {\n    // For client:* and tool:* events, automatically add clientId and timestamp\n    if (eventName.startsWith('client:') || eventName.startsWith('tool:')) {\n      aiEventClient.emit(eventName as any, {\n        ...data,\n        clientId: this.clientId,\n        timestamp: Date.now(),\n      })\n    } else {\n      // For other events (e.g., processor:*), just add timestamp\n      aiEventClient.emit(eventName as any, {\n        ...data,\n        timestamp: Date.now(),\n      })\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+export { ChatClient } from './chat-client.js';
+export type { UIMessage, MessagePart, TextPart, ToolCallPart, ToolResultPart, ThinkingPart, ChatClientOptions, ChatRequestBody, InferChatMessages, } from './types.js';
+export { clientTools, createChatClientOptions } from './types.js';
+export type { ExtractToolNames, ExtractToolInput, ExtractToolOutput, } from './tool-types.js';
+export type { AnyClientTool } from '@tanstack/ai';
+export { fetchServerSentEvents, fetchHttpStream, stream, rpcStream, type ConnectionAdapter, type FetchConnectionOptions, } from './connection-adapters.js';
+export { uiMessageToModelMessages, modelMessageToUIMessage, modelMessagesToUIMessages, convertMessagesToModelMessages, normalizeToUIMessage, generateMessageId, } from '@tanstack/ai';
+export { StreamProcessor, ImmediateStrategy, PunctuationStrategy, BatchStrategy, WordBoundaryStrategy, CompositeStrategy, parsePartialJSON, PartialJSONParser, defaultJSONParser, type ChunkStrategy, type StreamProcessorOptions, type StreamProcessorHandlers, type StreamProcessorEvents, type InternalToolCallState, type ToolCallState, type ToolResultState, type JSONParser, type ChunkRecording, type ProcessorResult, type ProcessorState, } from '@tanstack/ai';

package/dist/esm/index.js

@@ -0,0 +1,29 @@
+import { ChatClient } from "./chat-client.js";
+import { clientTools, createChatClientOptions } from "./types.js";
+import { fetchHttpStream, fetchServerSentEvents, rpcStream, stream } from "./connection-adapters.js";
+import { BatchStrategy, CompositeStrategy, ImmediateStrategy, PartialJSONParser, PunctuationStrategy, StreamProcessor, WordBoundaryStrategy, convertMessagesToModelMessages, defaultJSONParser, generateMessageId, modelMessageToUIMessage, modelMessagesToUIMessages, normalizeToUIMessage, parsePartialJSON, uiMessageToModelMessages } from "@tanstack/ai";
+export {
+  BatchStrategy,
+  ChatClient,
+  CompositeStrategy,
+  ImmediateStrategy,
+  PartialJSONParser,
+  PunctuationStrategy,
+  StreamProcessor,
+  WordBoundaryStrategy,
+  clientTools,
+  convertMessagesToModelMessages,
+  createChatClientOptions,
+  defaultJSONParser,
+  fetchHttpStream,
+  fetchServerSentEvents,
+  generateMessageId,
+  modelMessageToUIMessage,
+  modelMessagesToUIMessages,
+  normalizeToUIMessage,
+  parsePartialJSON,
+  rpcStream,
+  stream,
+  uiMessageToModelMessages
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/esm/tool-types.d.ts

@@ -0,0 +1,20 @@
+import { AnyClientTool, InferToolInput, InferToolOutput } from '@tanstack/ai';
+/**
+ * Extract all tool names from a tools array as a union type
+ */
+export type ExtractToolNames<TTools extends ReadonlyArray<AnyClientTool>> = TTools[number]['name'];
+/**
+ * Find a tool by name in the tools array
+ */
+type FindTool<TTools extends ReadonlyArray<AnyClientTool>, TName extends string> = Extract<TTools[number], {
+    name: TName;
+}>;
+/**
+ * Extract the input type for a specific tool by name
+ */
+export type ExtractToolInput<TTools extends ReadonlyArray<AnyClientTool>, TName extends string> = TName extends ExtractToolNames<TTools> ? InferToolInput<FindTool<TTools, TName>> : any;
+/**
+ * Extract the output type for a specific tool by name
+ */
+export type ExtractToolOutput<TTools extends ReadonlyArray<AnyClientTool>, TName extends string> = TName extends ExtractToolNames<TTools> ? InferToolOutput<FindTool<TTools, TName>> : any;
+export {};