🤖 fix: surface sendMessage errors to chat UI during workspace creation

When workspace creation background operations fail (e.g., API key not
configured), errors were silently logged to console with no user feedback.
The user would just see their message with no response.

Changes:
- Add formatSendMessageError helper to convert SendMessageError to
  user-friendly messages with appropriate StreamErrorType
- Handle sendMessage result in completeWorkspaceCreation and emit
  stream-error events on failure
- Add unit tests for the new helper

This ensures users see error messages in the chat UI instead of silence.

_Generated with mux_

Author: ibetitsmike

src/node/services/utils/sendMessageError.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "bun:test";
+import { formatSendMessageError, createUnknownSendMessageError } from "./sendMessageError";
+
+describe("formatSendMessageError", () => {
+  test("formats api_key_not_found with authentication errorType", () => {
+    const result = formatSendMessageError({
+      type: "api_key_not_found",
+      provider: "anthropic",
+    });
+
+    expect(result.errorType).toBe("authentication");
+    expect(result.message).toContain("anthropic");
+    expect(result.message).toContain("API key");
+  });
+
+  test("formats provider_not_supported", () => {
+    const result = formatSendMessageError({
+      type: "provider_not_supported",
+      provider: "unsupported-provider",
+    });
+
+    expect(result.errorType).toBe("unknown");
+    expect(result.message).toContain("unsupported-provider");
+    expect(result.message).toContain("not supported");
+  });
+
+  test("formats invalid_model_string with model_not_found errorType", () => {
+    const result = formatSendMessageError({
+      type: "invalid_model_string",
+      message: "Invalid model format: foo",
+    });
+
+    expect(result.errorType).toBe("model_not_found");
+    expect(result.message).toBe("Invalid model format: foo");
+  });
+
+  test("formats incompatible_workspace", () => {
+    const result = formatSendMessageError({
+      type: "incompatible_workspace",
+      message: "Workspace is incompatible",
+    });
+
+    expect(result.errorType).toBe("unknown");
+    expect(result.message).toBe("Workspace is incompatible");
+  });
+
+  test("formats unknown errors", () => {
+    const result = formatSendMessageError({
+      type: "unknown",
+      raw: "Something went wrong",
+    });
+
+    expect(result.errorType).toBe("unknown");
+    expect(result.message).toBe("Something went wrong");
+  });
+});
+
+describe("createUnknownSendMessageError", () => {
+  test("creates unknown error with trimmed message", () => {
+    const result = createUnknownSendMessageError("  test error  ");
+
+    expect(result.type).toBe("unknown");
+    expect(result.raw).toBe("test error");
+  });
+
+  test("throws on empty message", () => {
+    expect(() => createUnknownSendMessageError("")).toThrow();
+    expect(() => createUnknownSendMessageError("   ")).toThrow();
+  });
+});

src/node/services/utils/sendMessageError.ts

@@ -1,5 +1,5 @@
 import assert from "@/common/utils/assert";
-import type { SendMessageError } from "@/common/types/errors";
+import type { SendMessageError, StreamErrorType } from "@/common/types/errors";
 
 /**
  * Helper to wrap arbitrary errors into SendMessageError structures.
@@ -15,3 +15,39 @@ export const createUnknownSendMessageError = (raw: string): SendMessageError =>
     raw: trimmed,
   };
 };
+
+/**
+ * Formats a SendMessageError into a user-visible message and StreamErrorType
+ * for display in the chat UI as a stream-error event.
+ */
+export const formatSendMessageError = (
+  error: SendMessageError
+): { message: string; errorType: StreamErrorType } => {
+  switch (error.type) {
+    case "api_key_not_found":
+      return {
+        message: `API key not configured for ${error.provider}. Please add your API key in settings.`,
+        errorType: "authentication",
+      };
+    case "provider_not_supported":
+      return {
+        message: `Provider "${error.provider}" is not supported.`,
+        errorType: "unknown",
+      };
+    case "invalid_model_string":
+      return {
+        message: error.message,
+        errorType: "model_not_found",
+      };
+    case "incompatible_workspace":
+      return {
+        message: error.message,
+        errorType: "unknown",
+      };
+    case "unknown":
+      return {
+        message: error.raw,
+        errorType: "unknown",
+      };
+  }
+};

src/node/services/workspaceService.ts

@@ -16,12 +16,14 @@ import { listLocalBranches, detectDefaultTrunkBranch } from "@/node/git";
 import { createRuntime, IncompatibleRuntimeError } from "@/node/runtime/runtimeFactory";
 import { generateWorkspaceName, generatePlaceholderName } from "./workspaceTitleGenerator";
 import { validateWorkspaceName } from "@/common/utils/validation/workspaceValidation";
+import { formatSendMessageError } from "@/node/services/utils/sendMessageError";
 
 import type {
   SendMessageOptions,
   DeleteMessage,
   ImagePart,
   WorkspaceChatMessage,
+  StreamErrorMessage,
 } from "@/common/orpc/types";
 import type { SendMessageError } from "@/common/types/errors";
 import type {
@@ -605,8 +607,19 @@ export class WorkspaceService extends EventEmitter {
           initLogger.logComplete(-1);
         });
 
-      // Send the first message
-      void session.sendMessage(message, options);
+      // Send the first message, surfacing errors to the chat UI
+      void session.sendMessage(message, options).then((result) => {
+        if (!result.success) {
+          const { message: errorMessage, errorType } = formatSendMessageError(result.error);
+          const streamError: StreamErrorMessage = {
+            type: "stream-error",
+            messageId: `error-${Date.now()}`,
+            error: errorMessage,
+            errorType,
+          };
+          session.emitChatEvent(streamError);
+        }
+      });
 
       // Generate AI name asynchronously and rename if successful
       void this.generateAndApplyAIName(workspaceId, message, finalBranchName, options.model);