🤖 Fix web server error handling to preserve structured errors (#369)

Author: kylecarbs

src/browser/api.ts

@@ -10,7 +10,7 @@ const WS_BASE = API_BASE.replace("http://", "ws://").replace("https://", "wss://
 interface InvokeResponse<T> {
   success: boolean;
   data?: T;
-  error?: string;
+  error?: unknown; // Can be string or structured error object
 }
 
 // Helper function to invoke IPC handlers via HTTP
@@ -30,9 +30,16 @@ async function invokeIPC<T>(channel: string, ...args: unknown[]): Promise<T> {
   const result = (await response.json()) as InvokeResponse<T>;
 
   if (!result.success) {
-    throw new Error(result.error ?? "Unknown error");
+    // Failed response - check if it's a structured error or simple string
+    if (typeof result.error === "object" && result.error !== null) {
+      // Structured error (e.g., SendMessageError) - return as Result<T, E> for caller to handle
+      return result as T;
+    }
+    // Simple string error - throw it
+    throw new Error(typeof result.error === "string" ? result.error : "Unknown error");
   }
 
+  // Success - unwrap and return the data
   return result.data as T;
 }
 

src/components/ChatInputToasts.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "@jest/globals";
+import { createErrorToast } from "./ChatInputToasts";
+import type { SendMessageError } from "@/types/errors";
+
+describe("ChatInputToasts", () => {
+  describe("createErrorToast", () => {
+    test("should create toast for api_key_not_found error", () => {
+      const error: SendMessageError = {
+        type: "api_key_not_found",
+        provider: "openai",
+      };
+
+      const toast = createErrorToast(error);
+
+      expect(toast.type).toBe("error");
+      expect(toast.title).toBe("API Key Not Found");
+      expect(toast.message).toContain("openai");
+      expect(toast.message).toContain("API key");
+    });
+
+    test("should create toast for provider_not_supported error", () => {
+      const error: SendMessageError = {
+        type: "provider_not_supported",
+        provider: "custom-provider",
+      };
+
+      const toast = createErrorToast(error);
+
+      expect(toast.type).toBe("error");
+      expect(toast.title).toBe("Provider Not Supported");
+      expect(toast.message).toContain("custom-provider");
+    });
+
+    test("should create toast for invalid_model_string error", () => {
+      const error: SendMessageError = {
+        type: "invalid_model_string",
+        message: "Invalid format: expected provider:model",
+      };
+
+      const toast = createErrorToast(error);
+
+      expect(toast.type).toBe("error");
+      expect(toast.title).toBe("Invalid Model Format");
+      expect(toast.message).toBe("Invalid format: expected provider:model");
+    });
+
+    test("should create toast for unknown error with message", () => {
+      const error: SendMessageError = {
+        type: "unknown",
+        raw: "Network connection failed",
+      };
+
+      const toast = createErrorToast(error);
+
+      expect(toast.type).toBe("error");
+      expect(toast.title).toBe("Message Send Failed");
+      expect(toast.message).toBe("Network connection failed");
+    });
+
+    test("should create toast for unknown error without message", () => {
+      const error: SendMessageError = {
+        type: "unknown",
+        raw: "",
+      };
+
+      const toast = createErrorToast(error);
+
+      expect(toast.type).toBe("error");
+      expect(toast.title).toBe("Message Send Failed");
+      expect(toast.message).toContain("unexpected error");
+    });
+  });
+});

src/main-server.ts

@@ -30,21 +30,22 @@ class HttpIpcMainAdapter {
         const args: unknown[] = body.args ?? [];
         const result = await handler(null, ...args);
 
-        // If handler returns an error result object, unwrap it and send as error response
-        // This ensures webApi.ts will throw with the proper error message
+        // If handler returns a failed Result type, pass through the error
+        // This preserves structured error types like SendMessageError
         if (
           result &&
           typeof result === "object" &&
           "success" in result &&
-          result.success === false
+          result.success === false &&
+          "error" in result
         ) {
-          const errorMessage =
-            "error" in result && typeof result.error === "string" ? result.error : "Unknown error";
-          // Return 200 with error structure so webApi can throw with the detailed message
-          res.json({ success: false, error: errorMessage });
+          // Pass through failed Result to preserve error structure
+          res.json(result);
           return;
         }
 
+        // For all other return values (including successful Results), wrap in success response
+        // The browser API will unwrap the data field
         res.json({ success: true, data: result });
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);