refactor: centralize error message formatting

Created src/utils/errors/formatSendError.ts as single source of truth
for SendMessageError formatting. Both RetryBarrier and ChatInputToasts
now use formatSendMessageError() helper, eliminating duplicate logic
for provider commands and error messages.

- formatSendMessageError() returns message + optional providerCommand
- RetryBarrier combines them: "message. Configure with command"
- ChatInputToasts uses providerCommand in solution section
- All provider-related strings now defined in one place

Author: ammar-agent

src/components/ChatInputToasts.tsx

@@ -3,6 +3,7 @@ import type { Toast } from "./ChatInputToast";
 import { SolutionLabel } from "./ChatInputToast";
 import type { ParsedCommand } from "@/utils/slashCommands/types";
 import type { SendMessageError as SendMessageErrorType } from "@/types/errors";
+import { formatSendMessageError } from "@/utils/errors/formatSendError";
 
 /**
  * Creates a toast message for command-related errors and help messages
@@ -146,55 +147,63 @@ export const createCommandToast = (parsed: ParsedCommand): Toast | null => {
  */
 export const createErrorToast = (error: SendMessageErrorType): Toast => {
   switch (error.type) {
-    case "api_key_not_found":
+    case "api_key_not_found": {
+      const formatted = formatSendMessageError(error);
       return {
         id: Date.now().toString(),
         type: "error",
         title: "API Key Not Found",
         message: `The ${error.provider} provider requires an API key to function.`,
-        solution: (
+        solution: formatted.providerCommand ? (
           <>
             <SolutionLabel>Quick Fix:</SolutionLabel>
-            /providers set {error.provider} apiKey YOUR_API_KEY
+            {formatted.providerCommand}
           </>
-        ),
+        ) : undefined,
       };
+    }
 
-    case "provider_not_supported":
+    case "provider_not_supported": {
+      const formatted = formatSendMessageError(error);
       return {
         id: Date.now().toString(),
         type: "error",
         title: "Provider Not Supported",
-        message: `The ${error.provider} provider is not supported yet.`,
+        message: formatted.message,
         solution: (
           <>
             <SolutionLabel>Try This:</SolutionLabel>
             Use an available provider from /providers list
           </>
         ),
       };
+    }
 
-    case "invalid_model_string":
+    case "invalid_model_string": {
+      const formatted = formatSendMessageError(error);
       return {
         id: Date.now().toString(),
         type: "error",
         title: "Invalid Model Format",
-        message: error.message,
+        message: formatted.message,
         solution: (
           <>
             <SolutionLabel>Expected Format:</SolutionLabel>
             provider:model-name (e.g., anthropic:claude-opus-4-1)
           </>
         ),
       };
+    }
 
     case "unknown":
-    default:
+    default: {
+      const formatted = formatSendMessageError(error);
       return {
         id: Date.now().toString(),
         type: "error",
         title: "Message Send Failed",
-        message: error.raw || "An unexpected error occurred while sending your message.",
+        message: formatted.message,
       };
+    }
   }
 };

src/components/Messages/ChatBarrier/RetryBarrier.tsx

@@ -3,10 +3,10 @@ import { usePersistedState, updatePersistedState } from "@/hooks/usePersistedSta
 import { getRetryStateKey, getAutoRetryKey } from "@/constants/storage";
 import { CUSTOM_EVENTS, createCustomEvent } from "@/constants/events";
 import { cn } from "@/lib/utils";
-import type { SendMessageError } from "@/types/errors";
 import type { RetryState } from "@/hooks/useResumeManager";
 import { useWorkspaceState } from "@/stores/WorkspaceStore";
 import { isEligibleForAutoRetry, isNonRetryableSendError } from "@/utils/messages/retryEligibility";
+import { formatSendMessageError } from "@/utils/errors/formatSendError";
 
 interface RetryBarrierProps {
   workspaceId: string;
@@ -112,19 +112,14 @@ export const RetryBarrier: React.FC<RetryBarrierProps> = ({ workspaceId, classNa
     setAutoRetry(false);
   };
 
-  // Format error message for display
-  const getErrorMessage = (error: SendMessageError): string => {
-    switch (error.type) {
-      case "api_key_not_found":
-        return `API key not found for ${error.provider}. Configure with /providers set ${error.provider} apiKey YOUR_KEY`;
-      case "provider_not_supported":
-        return `Provider ${error.provider} is not supported yet.`;
-      case "invalid_model_string":
-        return error.message;
-      case "unknown":
-      default:
-        return error.raw || "Unknown error occurred";
-    }
+  // Format error message for display (centralized logic)
+  const getErrorMessage = (error: typeof lastError): string => {
+    if (!error) return "";
+    const formatted = formatSendMessageError(error);
+    // Combine message with command if available
+    return formatted.providerCommand
+      ? `${formatted.message} Configure with ${formatted.providerCommand}`
+      : formatted.message;
   };
 
   if (effectiveAutoRetry) {

src/utils/errors/formatSendError.ts

@@ -0,0 +1,40 @@
+/**
+ * Centralized error message formatting for SendMessageError types
+ * Used by both RetryBarrier and ChatInputToasts
+ */
+
+import type { SendMessageError } from "@/types/errors";
+
+export interface FormattedError {
+  message: string;
+  providerCommand?: string; // e.g., "/providers set anthropic apiKey YOUR_KEY"
+}
+
+/**
+ * Format a SendMessageError into a user-friendly message
+ * Returns both the message and an optional command suggestion
+ */
+export function formatSendMessageError(error: SendMessageError): FormattedError {
+  switch (error.type) {
+    case "api_key_not_found":
+      return {
+        message: `API key not found for ${error.provider}.`,
+        providerCommand: `/providers set ${error.provider} apiKey YOUR_API_KEY`,
+      };
+
+    case "provider_not_supported":
+      return {
+        message: `Provider ${error.provider} is not supported yet.`,
+      };
+
+    case "invalid_model_string":
+      return {
+        message: error.message,
+      };
+
+    case "unknown":
+      return {
+        message: error.raw || "Unknown error occurred",
+      };
+  }
+}