🤖 fix: emit stream-error for pre-stream API failures

When sendMessage failed before the stream started (e.g., invalid model,
API key missing), the error was only shown as a toast which could be
easily missed. The user would see their message in the chat but no
response, with no indication of what went wrong.

Now, when streamWithHistory fails, we emit a stream-error chat event
so the error is visible directly in the conversation. This provides
clear feedback when:
- Model validation fails (invalid format, non-existent model)
- API key is not configured
- Provider is not supported
- Any other pre-stream error

The toast is still shown for immediate feedback, but the stream-error
ensures the error is also visible in the chat history.

_Generated with mux_

Author: ibetitsmike

src/node/services/agentSession.ts

@@ -18,7 +18,10 @@ import type {
   ImagePart,
 } from "@/common/orpc/types";
 import type { SendMessageError } from "@/common/types/errors";
-import { createUnknownSendMessageError } from "@/node/services/utils/sendMessageError";
+import {
+  createUnknownSendMessageError,
+  formatSendMessageError,
+} from "@/node/services/utils/sendMessageError";
 import type { Result } from "@/common/types/result";
 import { Ok, Err } from "@/common/types/result";
 import { enforceThinkingPolicy } from "@/browser/utils/thinking/policy";
@@ -427,9 +430,11 @@ export class AgentSession {
     }
 
     if (!options?.model || options.model.trim().length === 0) {
-      return Err(
-        createUnknownSendMessageError("No model specified. Please select a model using /model.")
+      const error = createUnknownSendMessageError(
+        "No model specified. Please select a model using /model."
       );
+      this.emitStreamError(error);
+      return Err(error);
     }
 
     return this.streamWithHistory(options.model, options);
@@ -483,12 +488,16 @@ export class AgentSession {
   ): Promise<Result<void, SendMessageError>> {
     const commitResult = await this.partialService.commitToHistory(this.workspaceId);
     if (!commitResult.success) {
-      return Err(createUnknownSendMessageError(commitResult.error));
+      const error = createUnknownSendMessageError(commitResult.error);
+      this.emitStreamError(error);
+      return Err(error);
     }
 
     const historyResult = await this.historyService.getHistory(this.workspaceId);
     if (!historyResult.success) {
-      return Err(createUnknownSendMessageError(historyResult.error));
+      const error = createUnknownSendMessageError(historyResult.error);
+      this.emitStreamError(error);
+      return Err(error);
     }
 
     // Enforce thinking policy for the specified model (single source of truth)
@@ -497,7 +506,7 @@ export class AgentSession {
       ? enforceThinkingPolicy(modelString, options.thinkingLevel)
       : undefined;
 
-    return this.aiService.streamMessage(
+    const result = await this.aiService.streamMessage(
       historyResult.data,
       this.workspaceId,
       modelString,
@@ -509,6 +518,32 @@ export class AgentSession {
       options?.providerOptions,
       options?.mode
     );
+
+    // If stream failed to start, emit a stream-error so the user sees the error in the chat UI
+    // (not just a toast which might be missed). The error is already displayed in the chat via
+    // stream-error handling, which shows up as an error message in the conversation.
+    if (!result.success) {
+      this.emitStreamError(result.error);
+    }
+
+    return result;
+  }
+
+  /**
+   * Emit a stream-error chat event for pre-stream failures.
+   * This ensures errors that occur before stream-start are visible in the chat UI,
+   * not just as a toast that might be dismissed or missed.
+   */
+  private emitStreamError(error: SendMessageError): void {
+    const { message, errorType } = formatSendMessageError(error);
+    const streamError: StreamErrorMessage = {
+      type: "stream-error",
+      // Use a synthetic messageId since no assistant message was created
+      messageId: `error-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+      error: message,
+      errorType,
+    };
+    this.emitChatEvent(streamError);
   }
 
   private attachAiListeners(): void {

tests/ipc/sendMessage.errors.test.ts

@@ -96,6 +96,30 @@ describeIntegration("sendMessage error handling tests", () => {
       15000
     );
 
+    test.concurrent(
+      "should emit stream-error when model validation fails early",
+      async () => {
+        await withSharedWorkspace("openai", async ({ env, workspaceId, collector }) => {
+          // Send a message with an invalid model format (causes early validation failure)
+          const result = await sendMessage(env, workspaceId, "Hello", {
+            model: "invalid-model-without-provider",
+          });
+
+          // IPC call fails immediately (pre-stream validation error)
+          expect(result.success).toBe(false);
+
+          // Should still emit stream-error so it shows in the chat UI
+          // This is important because the user message is displayed before stream starts
+          const errorEvent = await collector.waitForEvent("stream-error", 3000);
+          expect(errorEvent).toBeDefined();
+          if (errorEvent?.type === "stream-error") {
+            expect(errorEvent.error).toBeDefined();
+          }
+        });
+      },
+      15000
+    );
+
     test.concurrent(
       "should fail with non-existent model",
       async () => {