@tanstack/ai-client 0.18.5 → 0.18.6

package/dist/esm/chat-client.js

@@ -0,0 +1,1097 @@
+import { StreamProcessor, normalizeToUIMessage, generateMessageId, convertSchemaToJsonSchema, isStandardSchema, parseWithStandardSchema } from "@tanstack/ai/client";
+import { createNoOpChatDevtoolsBridge } from "./devtools-noop.js";
+import { normalizeConnectionAdapter, getChunkRunId, fetcherToConnectionAdapter } from "./connection-adapters.js";
+import { ChatPersistor } from "./client-persistor.js";
+function resolveTransport(transport) {
+  const { connection, fetcher } = transport;
+  if (connection && fetcher) {
+    throw new Error(
+      "ChatClient: pass either `connection` or `fetcher`, not both."
+    );
+  }
+  if (connection) return connection;
+  if (fetcher) return fetcherToConnectionAdapter(fetcher);
+  throw new Error("ChatClient: either `connection` or `fetcher` is required.");
+}
+class ChatClient {
+  processor;
+  connection;
+  uniqueId;
+  threadId;
+  // All persistence concerns (hydrate / save / clear, plus suppression of late
+  // chunks after a mid-stream clear) live in ChatPersistor so this class stays
+  // focused on streaming. Undefined when no `persistence` adapter is configured.
+  persistor;
+  currentRunId = null;
+  // Track the legacy `body` option and the canonical `forwardedProps`
+  // option as separate slots so that `updateOptions({ forwardedProps })`
+  // doesn't wipe a previously-set `body` (and vice versa). They are
+  // merged on every send, with `forwardedProps` winning on key collision.
+  bodyOption = {};
+  forwardedPropsOption = {};
+  context = void 0;
+  pendingMessageBody = void 0;
+  isLoading = false;
+  isSubscribed = false;
+  error = void 0;
+  status = "ready";
+  connectionStatus = "disconnected";
+  abortController = null;
+  clientToolsRef;
+  devtoolsBridge;
+  /**
+   * Alias for `this.events`. The bridge installs an
+   * emitter that auto-attaches run/thread context and auto-emits a
+   * snapshot after every event, so chat-client only ever calls
+   * `this.events.X(...)` exactly like it did before devtools landed.
+   */
+  events;
+  currentStreamId = null;
+  currentMessageId = null;
+  postStreamActions = [];
+  // Track pending client tool executions to await them before stream finalization
+  pendingToolExecutions = /* @__PURE__ */ new Map();
+  activeClientTools = null;
+  activeContext = void 0;
+  // Flag to deduplicate continuation checks during action draining
+  continuationPending = false;
+  subscriptionAbortController = null;
+  processingResolve = null;
+  errorReportedGeneration = null;
+  streamGeneration = 0;
+  // Tracks whether a queued checkForContinuation was skipped because
+  // continuationPending was true (chained approval scenario)
+  continuationSkipped = false;
+  draining = false;
+  sessionGenerating = false;
+  activeRunIds = /* @__PURE__ */ new Set();
+  devtoolsMounted = false;
+  callbacksRef;
+  constructor(options) {
+    this.uniqueId = options.id || this.generateUniqueId("chat");
+    this.threadId = options.threadId || this.generateUniqueId("thread");
+    if (options.persistence) {
+      this.persistor = new ChatPersistor(
+        options.persistence,
+        this.uniqueId,
+        (messages) => this.processor.setMessages(messages)
+      );
+    }
+    this.bodyOption = options.body || {};
+    this.forwardedPropsOption = options.forwardedProps || {};
+    this.context = options.context;
+    this.connection = normalizeConnectionAdapter(resolveTransport(options));
+    this.clientToolsRef = { current: /* @__PURE__ */ new Map() };
+    if (options.tools) {
+      for (const tool of options.tools) {
+        this.clientToolsRef.current.set(tool.name, tool);
+      }
+    }
+    this.devtoolsBridge = (options.devtoolsBridgeFactory ?? createNoOpChatDevtoolsBridge)(this.buildDevtoolsBridgeOptions(options.devtools));
+    this.events = this.devtoolsBridge.events;
+    this.callbacksRef = {
+      current: {
+        onResponse: options.onResponse || (() => {
+        }),
+        onChunk: options.onChunk || (() => {
+        }),
+        onFinish: options.onFinish || (() => {
+        }),
+        onError: options.onError || (() => {
+        }),
+        onMessagesChange: options.onMessagesChange || (() => {
+        }),
+        onLoadingChange: options.onLoadingChange || (() => {
+        }),
+        onErrorChange: options.onErrorChange || (() => {
+        }),
+        onStatusChange: options.onStatusChange || (() => {
+        }),
+        onSubscriptionChange: options.onSubscriptionChange || (() => {
+        }),
+        onConnectionStatusChange: options.onConnectionStatusChange || (() => {
+        }),
+        onSessionGeneratingChange: options.onSessionGeneratingChange || (() => {
+        }),
+        onCustomEvent: options.onCustomEvent || (() => {
+        })
+      }
+    };
+    const persistedMessages = this.persistor?.readInitial();
+    const initialMessages = Array.isArray(persistedMessages) ? persistedMessages : options.initialMessages;
+    this.processor = new StreamProcessor({
+      ...options.streamProcessor?.chunkStrategy ? { chunkStrategy: options.streamProcessor.chunkStrategy } : {},
+      ...initialMessages ? { initialMessages } : {},
+      events: {
+        onMessagesChange: (messages) => {
+          this.persistor?.notifyMessagesChanged(messages);
+          this.callbacksRef.current.onMessagesChange(messages);
+        },
+        onStreamStart: () => {
+          this.setStatus("streaming");
+          const assistantMessageId = this.processor.getCurrentAssistantMessageId();
+          if (!assistantMessageId) {
+            return;
+          }
+          const messages = this.processor.getMessages();
+          const assistantMessage = messages.find(
+            (m) => m.id === assistantMessageId
+          );
+          if (assistantMessage) {
+            this.currentMessageId = assistantMessage.id;
+            this.events.messageAppended(
+              assistantMessage,
+              this.currentStreamId || void 0
+            );
+          }
+        },
+        onStreamEnd: (message) => {
+          this.callbacksRef.current.onFinish(message);
+          this.setStatus("ready");
+          this.resolveProcessing();
+        },
+        onError: (error) => {
+          this.reportStreamError(error);
+        },
+        onTextUpdate: (messageId, content) => {
+          if (this.currentStreamId) {
+            this.events.textUpdated(this.currentStreamId, messageId, content);
+          }
+        },
+        onThinkingUpdate: (messageId, content) => {
+          if (this.currentStreamId) {
+            this.events.thinkingUpdated(
+              this.currentStreamId,
+              messageId,
+              content,
+              void 0
+            );
+          }
+        },
+        onStructuredOutputChange: (args) => {
+          const streamId = this.devtoolsBridge.resolveStreamId();
+          const eventName = args.phase === "start" ? "structured-output:started" : args.phase === "complete" ? "structured-output:completed" : args.phase === "error" ? "structured-output:errored" : "structured-output:updated";
+          this.currentMessageId = args.messageId;
+          this.events.structuredOutputChanged(
+            eventName,
+            streamId,
+            args.messageId,
+            {
+              status: args.status,
+              raw: args.raw,
+              ...args.partial !== void 0 ? { partial: args.partial } : {},
+              ...args.data !== void 0 ? { data: args.data } : {},
+              ...args.reasoning !== void 0 ? { reasoning: args.reasoning } : {},
+              ...args.errorMessage !== void 0 ? { errorMessage: args.errorMessage } : {},
+              ...args.delta !== void 0 ? { delta: args.delta } : {}
+            }
+          );
+        },
+        onToolCallStateChange: (messageId, toolCallId, state, args) => {
+          const messages = this.processor.getMessages();
+          const message = messages.find((m) => m.id === messageId);
+          const toolCallPart = message?.parts.find(
+            (p) => p.type === "tool-call" && p.id === toolCallId
+          );
+          const toolName = toolCallPart?.name || "unknown";
+          if (this.currentStreamId) {
+            this.events.toolCallStateChanged(
+              this.currentStreamId,
+              messageId,
+              toolCallId,
+              toolName,
+              state,
+              args
+            );
+          }
+        },
+        onToolCall: (args) => {
+          const clientTools = this.activeClientTools ?? this.clientToolsRef.current;
+          const clientTool = clientTools.get(args.toolName);
+          const executeFunc = clientTool?.execute;
+          if (executeFunc) {
+            const runEventContext = this.devtoolsBridge.getCurrentRunEventContext();
+            const executionPromise = (async () => {
+              try {
+                const context = this.activeClientTools === null ? this.context : this.activeContext;
+                const output = await executeFunc(args.input, {
+                  toolCallId: args.toolCallId,
+                  context,
+                  emitCustomEvent: () => {
+                  }
+                });
+                await this.addToolResultForClientTool(
+                  {
+                    toolCallId: args.toolCallId,
+                    tool: args.toolName,
+                    output,
+                    state: "output-available"
+                  },
+                  clientTool,
+                  runEventContext
+                );
+              } catch (error) {
+                await this.addToolResultForClientTool(
+                  {
+                    toolCallId: args.toolCallId,
+                    tool: args.toolName,
+                    output: null,
+                    state: "output-error",
+                    errorText: error.message
+                  },
+                  clientTool,
+                  runEventContext
+                );
+              } finally {
+                this.pendingToolExecutions.delete(args.toolCallId);
+              }
+            })();
+            this.pendingToolExecutions.set(args.toolCallId, executionPromise);
+          }
+        },
+        onApprovalRequest: (args) => {
+          const streamId = this.devtoolsBridge.resolveStreamId();
+          const messageIdForApproval = this.findMessageIdForToolCall(args.toolCallId) ?? this.currentMessageId ?? "";
+          this.events.approvalRequested(
+            streamId,
+            messageIdForApproval,
+            args.toolCallId,
+            args.toolName,
+            args.input,
+            args.approvalId
+          );
+        },
+        onCustomEvent: (eventType, data, context) => {
+          this.callbacksRef.current.onCustomEvent(eventType, data, context);
+        }
+      }
+    });
+    this.persistor?.hydrateAsync(persistedMessages);
+  }
+  mountDevtools() {
+    if (this.devtoolsMounted) {
+      return;
+    }
+    this.devtoolsMounted = true;
+    this.devtoolsBridge.mountWithTools(this.processor.getMessages().length);
+  }
+  /**
+   * Drain a runId-less RUN_ERROR that belongs to a cleared run the client is
+   * still tracking. The persistor owns the cleared-run bookkeeping; the client
+   * owns the active-run / session / processing state.
+   */
+  drainIgnoredRunlessChunk(chunk) {
+    if (chunk.type !== "RUN_ERROR") return;
+    const runId = this.persistor?.takeRunlessRunId();
+    if (!runId) return;
+    this.activeRunIds.delete(runId);
+    this.setSessionGenerating(this.activeRunIds.size > 0);
+    this.resolveProcessing();
+  }
+  updateRunLifecycle(chunk, options) {
+    if (chunk.type === "RUN_STARTED") {
+      const chunkRunId = getChunkRunId(chunk) ?? chunk.runId;
+      this.activeRunIds.add(chunkRunId);
+      this.persistor?.onRunStarted(chunkRunId);
+      this.setSessionGenerating(true);
+      return;
+    }
+    if (chunk.type !== "RUN_FINISHED" && chunk.type !== "RUN_ERROR") {
+      return;
+    }
+    const runId = getChunkRunId(chunk);
+    if (runId) {
+      this.activeRunIds.delete(runId);
+      this.persistor?.onRunSettled(runId);
+    } else if (chunk.type === "RUN_ERROR") {
+      this.activeRunIds.clear();
+      this.persistor?.onSessionRunError();
+    }
+    this.setSessionGenerating(this.activeRunIds.size > 0);
+    if (options?.resolveProcessing !== false) {
+      this.resolveProcessing();
+    }
+  }
+  generateUniqueId(prefix) {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+  }
+  setIsLoading(isLoading) {
+    this.isLoading = isLoading;
+    this.callbacksRef.current.onLoadingChange(isLoading);
+    this.events.loadingChanged(isLoading);
+  }
+  setStatus(status) {
+    this.status = status;
+    this.callbacksRef.current.onStatusChange(status);
+    this.devtoolsBridge.emitSnapshot();
+  }
+  setIsSubscribed(isSubscribed) {
+    this.isSubscribed = isSubscribed;
+    this.callbacksRef.current.onSubscriptionChange(isSubscribed);
+    this.devtoolsBridge.emitSnapshot();
+  }
+  setConnectionStatus(status) {
+    this.connectionStatus = status;
+    this.callbacksRef.current.onConnectionStatusChange(status);
+    this.devtoolsBridge.emitSnapshot();
+  }
+  setSessionGenerating(isGenerating) {
+    if (this.sessionGenerating === isGenerating) return;
+    this.sessionGenerating = isGenerating;
+    this.callbacksRef.current.onSessionGeneratingChange(isGenerating);
+    this.devtoolsBridge.emitSnapshot();
+  }
+  resetSessionGenerating() {
+    this.activeRunIds.clear();
+    this.persistor?.resetIgnored();
+    this.setSessionGenerating(false);
+  }
+  setError(error) {
+    this.error = error;
+    this.callbacksRef.current.onErrorChange(error);
+    this.events.errorChanged(error?.message || null);
+  }
+  buildDevtoolsBridgeOptions(devtools) {
+    return {
+      hookId: this.uniqueId,
+      clientId: this.uniqueId,
+      threadId: this.threadId,
+      metadata: {
+        hookName: devtools?.hookName ?? "useChat",
+        outputKind: devtools?.outputKind ?? "chat",
+        ...devtools?.framework ? { framework: devtools.framework } : {},
+        ...devtools?.name ? { name: devtools.name } : {}
+      },
+      getSnapshot: () => this.getDevtoolsSnapshot(),
+      getTools: () => this.clientToolsRef.current.values(),
+      getMessages: () => this.processor.getMessages(),
+      setMessages: (messages) => {
+        this.processor.setMessages(messages);
+      },
+      addToolResult: (toolCallId, output, errorText) => {
+        this.processor.addToolResult(toolCallId, output, errorText);
+      },
+      generateId: (prefix) => this.generateUniqueId(prefix)
+    };
+  }
+  getDevtoolsSnapshot() {
+    return {
+      messages: this.processor.getMessages(),
+      status: this.status,
+      isLoading: this.isLoading,
+      isSubscribed: this.isSubscribed,
+      connectionStatus: this.connectionStatus,
+      sessionGenerating: this.sessionGenerating,
+      activeRunIds: Array.from(this.activeRunIds),
+      ...this.error ? { error: this.error.message } : {}
+    };
+  }
+  findMessageIdForToolCall(toolCallId) {
+    const messages = this.processor.getMessages();
+    for (const message of messages) {
+      const match = message.parts.find(
+        (part) => part.type === "tool-call" && part.id === toolCallId
+      );
+      if (match) return message.id;
+    }
+    return void 0;
+  }
+  abortSubscriptionLoop() {
+    this.subscriptionAbortController?.abort();
+    this.subscriptionAbortController = null;
+  }
+  resolveProcessing() {
+    this.processingResolve?.();
+    this.processingResolve = null;
+  }
+  cancelInFlightStream(options) {
+    this.abortController?.abort();
+    this.abortController = null;
+    if (options?.abortSubscription) {
+      this.abortSubscriptionLoop();
+    }
+    this.resolveProcessing();
+    this.setIsLoading(false);
+    if (options?.setReadyStatus) {
+      this.setStatus("ready");
+    }
+  }
+  reportStreamError(error) {
+    const alreadyReported = this.errorReportedGeneration === this.streamGeneration;
+    this.setError(error);
+    if (this.isLoading || this.status === "submitted" || this.status === "streaming") {
+      this.setStatus("error");
+    }
+    if (!alreadyReported) {
+      this.errorReportedGeneration = this.streamGeneration;
+      this.callbacksRef.current.onError(error);
+    }
+  }
+  /**
+   * Start the background subscription loop.
+   */
+  startSubscription() {
+    this.subscriptionAbortController = new AbortController();
+    const signal = this.subscriptionAbortController.signal;
+    this.consumeSubscription(signal).catch((err) => {
+      if (err instanceof Error && err.name !== "AbortError") {
+        this.setConnectionStatus("error");
+        this.resetSessionGenerating();
+        this.setIsSubscribed(false);
+        this.reportStreamError(err);
+      }
+      this.resolveProcessing();
+    }).finally(() => {
+      if (this.subscriptionAbortController?.signal !== signal) {
+        return;
+      }
+      this.subscriptionAbortController = null;
+      if (!signal.aborted && this.isSubscribed) {
+        this.setIsSubscribed(false);
+        if (this.connectionStatus !== "error") {
+          this.setConnectionStatus("disconnected");
+        }
+      }
+    });
+  }
+  /**
+   * Consume chunks from the connection subscription.
+   */
+  async consumeSubscription(signal) {
+    const stream = this.connection.subscribe(signal);
+    for await (const chunk of stream) {
+      if (signal.aborted) break;
+      if (this.connectionStatus === "connecting") {
+        this.setConnectionStatus("connected");
+      }
+      const shouldIgnore = this.persistor?.shouldIgnoreChunk(chunk) ?? false;
+      if (shouldIgnore) {
+        if (chunk.type === "RUN_FINISHED" || chunk.type === "RUN_ERROR") {
+          if (getChunkRunId(chunk)) {
+            this.updateRunLifecycle(chunk, { resolveProcessing: false });
+          } else {
+            this.drainIgnoredRunlessChunk(chunk);
+          }
+        }
+        continue;
+      }
+      this.callbacksRef.current.onChunk(chunk);
+      this.devtoolsBridge.observeChunk(chunk);
+      this.processor.processChunk(chunk);
+      this.updateRunLifecycle(chunk);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+  /**
+   * Ensure subscription loop is running, starting it if needed.
+   */
+  ensureSubscription() {
+    if (!this.isSubscribed) {
+      this.subscribe();
+      return;
+    }
+    if (!this.subscriptionAbortController || this.subscriptionAbortController.signal.aborted) {
+      this.subscribe({ restart: true });
+    }
+  }
+  /**
+   * Create a promise that resolves when onStreamEnd fires.
+   * Used by streamResponse to await processing completion.
+   */
+  waitForProcessing() {
+    this.resolveProcessing();
+    return new Promise((resolve) => {
+      this.processingResolve = resolve;
+    });
+  }
+  /**
+   * Send a message and stream the response.
+   * Supports both simple string content and multimodal content (images, audio, video, documents).
+   *
+   * @param content - The message content. Can be:
+   *   - A simple string for text-only messages
+   *   - A MultimodalContent object with content array and optional custom ID
+   * @param body - Optional body parameters to merge with the client's base body for this request.
+   *               Uses shallow merge with per-message body taking priority.
+   *
+   * @example
+   * ```ts
+   * // Simple text message
+   * await client.sendMessage('Hello!')
+   *
+   * // Text message with custom body params
+   * await client.sendMessage('Hello!', { temperature: 0.7 })
+   *
+   * // Multimodal message with image
+   * await client.sendMessage({
+   *   content: [
+   *     { type: 'text', content: 'What is in this image?' },
+   *     { type: 'image', source: { type: 'url', value: 'https://example.com/photo.jpg' } }
+   *   ]
+   * })
+   *
+   * // Multimodal message with custom ID and body params
+   * await client.sendMessage(
+   *   {
+   *     content: [
+   *       { type: 'text', content: 'Describe this audio' },
+   *       { type: 'audio', source: { type: 'data', value: 'base64...' } }
+   *     ],
+   *     id: 'custom-message-id'
+   *   },
+   *   { model: 'gpt-4-audio' }
+   * )
+   * ```
+   */
+  async sendMessage(content, body) {
+    this.mountDevtools();
+    const emptyMessage = typeof content === "string" && !content.trim();
+    if (emptyMessage || this.isLoading) {
+      return;
+    }
+    const normalizedContent = this.normalizeMessageInput(content);
+    this.pendingMessageBody = body;
+    const userMessage = this.processor.addUserMessage(
+      normalizedContent.content,
+      normalizedContent.id
+    );
+    this.events.messageSent(userMessage.id, normalizedContent.content);
+    await this.streamResponse();
+  }
+  /**
+   * Normalize the message input to extract content and optional id.
+   * Trims string content automatically.
+   */
+  normalizeMessageInput(input) {
+    if (typeof input === "string") {
+      return { content: input.trim() };
+    }
+    return { content: input.content, id: input.id };
+  }
+  /**
+   * Append a message and stream the response
+   */
+  async append(message) {
+    this.mountDevtools();
+    const normalizedMessage = normalizeToUIMessage(message, generateMessageId);
+    if (normalizedMessage.role === "system") {
+      return;
+    }
+    const uiMessage = normalizedMessage;
+    this.events.messageAppended(uiMessage);
+    const messages = this.processor.getMessages();
+    this.processor.setMessages([...messages, uiMessage]);
+    this.devtoolsBridge.emitSnapshot();
+    if (this.isLoading) {
+      this.queuePostStreamAction(async () => {
+        await this.streamResponse();
+      });
+      return;
+    }
+    await this.streamResponse();
+  }
+  /**
+   * Stream a response from the LLM.
+   * Returns true if the stream completed successfully, false on abort or error.
+   */
+  async streamResponse() {
+    if (this.isLoading) {
+      return false;
+    }
+    const generation = ++this.streamGeneration;
+    const runId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    this.currentRunId = runId;
+    this.setIsLoading(true);
+    this.setStatus("submitted");
+    this.setError(void 0);
+    this.errorReportedGeneration = null;
+    this.abortController = new AbortController();
+    const signal = this.abortController.signal;
+    this.pendingToolExecutions.clear();
+    let streamCompletedSuccessfully = false;
+    let activeDevtoolsRunId = null;
+    let runTerminalEventEmitted = false;
+    try {
+      const messages = this.processor.getMessages();
+      const clientTools = new Map(this.clientToolsRef.current);
+      const runtimeContext = this.context;
+      await this.callbacksRef.current.onResponse();
+      if (signal.aborted) {
+        return false;
+      }
+      const mergedBody = {
+        ...this.bodyOption,
+        ...this.forwardedPropsOption,
+        ...this.pendingMessageBody
+      };
+      this.pendingMessageBody = void 0;
+      this.currentStreamId = this.generateUniqueId("stream");
+      this.devtoolsBridge.setCurrentStreamId(this.currentStreamId);
+      this.currentMessageId = null;
+      this.activeClientTools = clientTools;
+      this.activeContext = runtimeContext;
+      this.processor.prepareAssistantMessage();
+      this.ensureSubscription();
+      const processingComplete = this.waitForProcessing();
+      const runContext = {
+        threadId: this.threadId,
+        runId,
+        clientTools: Array.from(clientTools.values()).map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema ? convertSchemaToJsonSchema(t.inputSchema) : { type: "object" }
+        })),
+        forwardedProps: { ...mergedBody }
+      };
+      this.devtoolsBridge.beginRun(runContext.runId, this.threadId);
+      activeDevtoolsRunId = runContext.runId;
+      this.devtoolsBridge.emitRunLifecycle(
+        "run:created",
+        runContext.runId,
+        "created"
+      );
+      this.devtoolsBridge.emitRunLifecycle(
+        "run:started",
+        runContext.runId,
+        "started"
+      );
+      this.devtoolsBridge.emitSnapshot();
+      await this.connection.send(messages, mergedBody, signal, runContext);
+      await processingComplete;
+      if (generation !== this.streamGeneration) {
+        return false;
+      }
+      if (this.status === "error") {
+        if (activeDevtoolsRunId) {
+          this.devtoolsBridge.emitRunLifecycle(
+            "run:errored",
+            activeDevtoolsRunId,
+            "errored",
+            this.error ? { error: this.error.message } : {}
+          );
+          runTerminalEventEmitted = true;
+        }
+        return false;
+      }
+      if (this.pendingToolExecutions.size > 0) {
+        await Promise.all(this.pendingToolExecutions.values());
+      }
+      this.processor.finalizeStream();
+      streamCompletedSuccessfully = true;
+    } catch (err) {
+      if (err instanceof Error) {
+        if (err.name === "AbortError") {
+          if (activeDevtoolsRunId) {
+            this.devtoolsBridge.emitRunLifecycle(
+              "run:cancelled",
+              activeDevtoolsRunId,
+              "cancelled"
+            );
+            runTerminalEventEmitted = true;
+          }
+          return false;
+        }
+        if (generation === this.streamGeneration) {
+          this.reportStreamError(err);
+          if (activeDevtoolsRunId) {
+            this.devtoolsBridge.emitRunLifecycle(
+              "run:errored",
+              activeDevtoolsRunId,
+              "errored",
+              { error: err.message }
+            );
+            runTerminalEventEmitted = true;
+          }
+        }
+      }
+    } finally {
+      if (generation === this.streamGeneration) {
+        this.currentStreamId = null;
+        this.devtoolsBridge.setCurrentStreamId(null);
+        this.currentMessageId = null;
+        this.currentRunId = null;
+        this.activeClientTools = null;
+        this.activeContext = void 0;
+        this.abortController = null;
+        this.setIsLoading(false);
+        this.pendingMessageBody = void 0;
+        if (activeDevtoolsRunId && !runTerminalEventEmitted) {
+          if (streamCompletedSuccessfully) {
+            this.devtoolsBridge.emitRunLifecycle(
+              "run:completed",
+              activeDevtoolsRunId,
+              "completed"
+            );
+          } else if (signal.aborted) {
+            this.devtoolsBridge.emitRunLifecycle(
+              "run:cancelled",
+              activeDevtoolsRunId,
+              "cancelled"
+            );
+          }
+        }
+        await this.drainPostStreamActions();
+        if (streamCompletedSuccessfully) {
+          const messages = this.processor.getMessages();
+          const lastPart = messages.at(-1)?.parts.at(-1);
+          const { finishReason } = this.processor.getState();
+          if (lastPart?.type === "tool-result" && finishReason !== "stop" && this.shouldAutoSend()) {
+            try {
+              await this.checkForContinuation();
+            } catch (error) {
+              console.error("Failed to continue flow after tool result:", error);
+            }
+          } else if (this.status !== "ready") {
+            this.setStatus("ready");
+          }
+        }
+      }
+    }
+    return streamCompletedSuccessfully;
+  }
+  /**
+   * Start the client subscription loop.
+   * This controls the connection lifecycle independently from request lifecycle.
+   */
+  subscribe(options) {
+    const restart = options?.restart === true;
+    if (this.isSubscribed && !restart) {
+      return;
+    }
+    if (this.isSubscribed && restart) {
+      this.abortSubscriptionLoop();
+    }
+    this.setIsSubscribed(true);
+    this.setConnectionStatus("connecting");
+    this.startSubscription();
+  }
+  /**
+   * Unsubscribe and fully tear down live behavior.
+   * This aborts an in-flight request and the subscription loop.
+   */
+  unsubscribe() {
+    this.cancelInFlightStream({
+      setReadyStatus: true,
+      abortSubscription: true
+    });
+    this.resetSessionGenerating();
+    this.setIsSubscribed(false);
+    this.setConnectionStatus("disconnected");
+  }
+  /**
+   * Reload the last assistant message
+   */
+  async reload() {
+    const messages = this.processor.getMessages();
+    if (messages.length === 0) return;
+    const lastUserMessageIndex = messages.findLastIndex(
+      (m) => m.role === "user"
+    );
+    if (lastUserMessageIndex === -1) return;
+    if (this.isLoading) {
+      this.cancelInFlightStream();
+    }
+    this.events.reloaded(lastUserMessageIndex);
+    this.processor.removeMessagesAfter(lastUserMessageIndex);
+    this.devtoolsBridge.emitSnapshot();
+    await this.streamResponse();
+  }
+  /**
+   * Stop the current stream
+   */
+  stop() {
+    const hadLocalStream = this.abortController !== null;
+    this.cancelInFlightStream({ setReadyStatus: true });
+    if (hadLocalStream) {
+      this.resetSessionGenerating();
+    }
+    this.events.stopped();
+  }
+  /**
+   * Clear all messages
+   */
+  clear() {
+    if (this.persistor) {
+      this.persistor.snapshotClear({
+        messages: this.processor.getMessages(),
+        activeRunIds: this.activeRunIds,
+        currentRunId: this.currentRunId
+      });
+      if (this.isLoading) {
+        this.cancelInFlightStream({ setReadyStatus: true });
+        this.resetSessionGenerating();
+      } else if (this.activeRunIds.size > 0) {
+        this.resetSessionGenerating();
+      }
+      this.persistor.beginClear();
+    }
+    this.processor.clearMessages();
+    this.persistor?.remove();
+    this.setError(void 0);
+    this.events.messagesCleared();
+  }
+  /**
+   * Add the result of a client-side tool execution
+   */
+  async addToolResult(result) {
+    const clientTool = this.clientToolsRef.current.get(result.tool);
+    await this.addToolResultForClientTool(result, clientTool);
+  }
+  async addToolResultForClientTool(result, clientTool, context) {
+    if (clientTool && result.state !== "output-error") {
+      try {
+        result = {
+          ...result,
+          output: this.validateClientToolOutput(clientTool, result.output)
+        };
+      } catch (error) {
+        result = {
+          ...result,
+          output: null,
+          state: "output-error",
+          errorText: error.message
+        };
+      }
+    }
+    this.events.toolResultAdded(
+      result.toolCallId,
+      result.tool,
+      result.output,
+      result.state || "output-available",
+      context
+    );
+    this.processor.addToolResult(
+      result.toolCallId,
+      result.output,
+      result.state === "output-error" ? result.errorText || "Tool execution failed" : void 0
+    );
+    if (this.isLoading) {
+      this.queuePostStreamAction(() => this.checkForContinuation());
+      return;
+    }
+    await this.checkForContinuation();
+  }
+  validateClientToolOutput(clientTool, output) {
+    if (clientTool.outputSchema && isStandardSchema(clientTool.outputSchema)) {
+      return parseWithStandardSchema(clientTool.outputSchema, output);
+    }
+    return output;
+  }
+  /**
+   * Respond to a tool approval request
+   */
+  async addToolApprovalResponse(response) {
+    const messages = this.processor.getMessages();
+    let foundToolCallId;
+    for (const msg of messages) {
+      const toolCallPart = msg.parts.find(
+        (p) => p.type === "tool-call" && p.approval?.id === response.id
+      );
+      if (toolCallPart) {
+        foundToolCallId = toolCallPart.id;
+        break;
+      }
+    }
+    if (foundToolCallId) {
+      this.events.toolApprovalResponded(
+        response.id,
+        foundToolCallId,
+        response.approved
+      );
+    }
+    this.processor.addToolApprovalResponse(response.id, response.approved);
+    this.devtoolsBridge.emitSnapshot();
+    if (this.isLoading) {
+      this.queuePostStreamAction(() => this.checkForContinuation());
+      return;
+    }
+    await this.checkForContinuation();
+  }
+  /**
+   * Queue an action to be executed after the current stream ends
+   */
+  queuePostStreamAction(action) {
+    this.postStreamActions.push(action);
+  }
+  /**
+   * Drain and execute all queued post-stream actions
+   */
+  async drainPostStreamActions() {
+    if (this.draining) return;
+    this.draining = true;
+    try {
+      let action;
+      while ((action = this.postStreamActions.shift()) !== void 0) {
+        await action();
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+  /**
+   * Check if we should continue the flow and do so if needed
+   */
+  async checkForContinuation() {
+    if (this.continuationPending || this.isLoading) {
+      this.continuationSkipped = true;
+      return;
+    }
+    if (this.shouldAutoSend()) {
+      this.continuationPending = true;
+      this.continuationSkipped = false;
+      let succeeded = false;
+      try {
+        succeeded = await this.streamResponse();
+      } finally {
+        this.continuationPending = false;
+      }
+      if (this.continuationSkipped && succeeded) {
+        this.continuationSkipped = false;
+        await this.checkForContinuation();
+      }
+    }
+  }
+  /**
+   * Check if all tool calls are complete and we should auto-send.
+   * Requires that there is at least one tool call in the last assistant message;
+   * a text-only response has nothing to auto-send.
+   */
+  shouldAutoSend() {
+    const messages = this.processor.getMessages();
+    const lastAssistant = messages.findLast(
+      (m) => m.role === "assistant"
+    );
+    if (!lastAssistant) return false;
+    const hasToolCalls = lastAssistant.parts.some(
+      (p) => p.type === "tool-call"
+    );
+    if (!hasToolCalls) return false;
+    return this.processor.areAllToolsComplete();
+  }
+  /**
+   * Get current messages
+   */
+  getMessages() {
+    return this.processor.getMessages();
+  }
+  /**
+   * Get loading state
+   */
+  getIsLoading() {
+    return this.isLoading;
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Get whether the subscription loop is active
+   */
+  getIsSubscribed() {
+    return this.isSubscribed;
+  }
+  /**
+   * Get current connection lifecycle status
+   */
+  getConnectionStatus() {
+    return this.connectionStatus;
+  }
+  /**
+   * Whether the shared session is actively generating.
+   * Derived from stream run events (RUN_STARTED / RUN_FINISHED / RUN_ERROR).
+   * Unlike `isLoading` (request-local), this reflects shared generation
+   * activity visible to all subscribers (e.g. across tabs/devices).
+   */
+  getSessionGenerating() {
+    return this.sessionGenerating;
+  }
+  /**
+   * Get current error
+   */
+  getError() {
+    return this.error;
+  }
+  /**
+   * Manually set messages
+   */
+  setMessagesManually(messages) {
+    this.processor.setMessages(messages);
+    this.devtoolsBridge.emitSnapshot();
+  }
+  updateOptions(options) {
+    if (options.connection !== void 0 || options.fetcher !== void 0) {
+      const wasSubscribed = this.isSubscribed;
+      if (this.isLoading) {
+        this.cancelInFlightStream({
+          setReadyStatus: true,
+          abortSubscription: true
+        });
+      } else if (wasSubscribed) {
+        this.abortSubscriptionLoop();
+      }
+      this.resetSessionGenerating();
+      this.setIsSubscribed(false);
+      this.setConnectionStatus("disconnected");
+      this.connection = normalizeConnectionAdapter(
+        resolveTransport({
+          connection: options.connection,
+          fetcher: options.fetcher
+        })
+      );
+      if (wasSubscribed) {
+        this.subscribe();
+      }
+    }
+    if (options.body !== void 0) {
+      this.bodyOption = options.body;
+    }
+    if (options.forwardedProps !== void 0) {
+      this.forwardedPropsOption = options.forwardedProps;
+    }
+    if ("context" in options) {
+      this.context = options.context;
+    }
+    if (options.tools !== void 0) {
+      this.clientToolsRef.current = /* @__PURE__ */ new Map();
+      for (const tool of options.tools) {
+        this.clientToolsRef.current.set(tool.name, tool);
+      }
+      this.devtoolsBridge.notifyToolsChanged();
+    }
+    if (options.onResponse !== void 0) {
+      this.callbacksRef.current.onResponse = options.onResponse;
+    }
+    if (options.onChunk !== void 0) {
+      this.callbacksRef.current.onChunk = options.onChunk;
+    }
+    if (options.onFinish !== void 0) {
+      this.callbacksRef.current.onFinish = options.onFinish;
+    }
+    if (options.onError !== void 0) {
+      this.callbacksRef.current.onError = options.onError;
+    }
+    if (options.onSubscriptionChange !== void 0) {
+      this.callbacksRef.current.onSubscriptionChange = options.onSubscriptionChange;
+    }
+    if (options.onConnectionStatusChange !== void 0) {
+      this.callbacksRef.current.onConnectionStatusChange = options.onConnectionStatusChange;
+    }
+    if (options.onSessionGeneratingChange !== void 0) {
+      this.callbacksRef.current.onSessionGeneratingChange = options.onSessionGeneratingChange;
+    }
+    if (options.onCustomEvent !== void 0) {
+      this.callbacksRef.current.onCustomEvent = options.onCustomEvent;
+    }
+  }
+  dispose() {
+    this.unsubscribe();
+    this.devtoolsBridge.dispose();
+    this.devtoolsMounted = false;
+  }
+}
+export {
+  ChatClient
+};
+//# sourceMappingURL=chat-client.js.map