fix: propagate model errors from all backend code paths to SSE stream

- Add Action.error and ActionErrorData to queue system so workforce
  background tasks can push errors to the SSE stream
- Fix "simple answer" error handlers to emit SSE error events instead
  of silently swallowing exceptions
- Add PUT fallback when PATCH /invalidate endpoint is not deployed
- Store preferredProvider reference for invalidation fallback

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: eureka0928

backend/app/service/chat_service.py

@@ -592,13 +592,14 @@ async def step_solve(options: Chat, request: Request, task_lock: TaskLock):
                         )
                     except Exception as e:
                         logger.error(f"Error generating simple answer: {e}")
+                        message, error_code, _ = (
+                            normalize_error_to_openai_format(e)
+                        )
                         yield sse_json(
-                            "wait_confirm",
+                            "error",
                             {
-                                "content": "I encountered an error"
-                                " while processing "
-                                "your question.",
-                                "question": question,
+                                "message": message,
+                                "error_code": error_code,
                             },
                         )
 
@@ -1298,13 +1299,14 @@ async def run_decomposition():
                                     "Error generating simple "
                                     f"answer in multi-turn: {e}"
                                 )
+                                message, error_code, _ = (
+                                    normalize_error_to_openai_format(e)
+                                )
                                 yield sse_json(
-                                    "wait_confirm",
+                                    "error",
                                     {
-                                        "content": "I encountered an error "
-                                        "while processing your "
-                                        "question.",
-                                        "question": new_task_content,
+                                        "message": message,
+                                        "error_code": error_code,
                                     },
                                 )
 
@@ -1637,6 +1639,21 @@ def on_stream_text(chunk):
                     },
                 )
 
+            elif item.action == Action.error:
+                logger.error(
+                    "[LIFECYCLE] ERROR action received "
+                    f"for project {options.project_id}, "
+                    f"task {options.task_id}: "
+                    f"{item.data.get('message', 'Unknown error')}"
+                )
+                yield sse_json(
+                    "error",
+                    {
+                        "message": item.data.get("message", "Unknown error"),
+                        "error_code": item.data.get("error_code"),
+                    },
+                )
+
             elif item.action == Action.end:
                 logger.info("=" * 80)
                 logger.info(

backend/app/service/task.py

@@ -65,6 +65,7 @@ class Action(str, Enum):
     resume = "resume"  # user -> backend  user take control
     new_agent = "new_agent"  # user -> backend
     budget_not_enough = "budget_not_enough"  # backend -> user
+    error = "error"  # backend -> user (model/runtime error)
     add_task = "add_task"  # user -> backend
     remove_task = "remove_task"  # user -> backend
     skip_task = "skip_task"  # user -> backend
@@ -255,6 +256,11 @@ class ActionNewAgent(BaseModel):
     custom_model_config: "AgentModelConfig | None" = None
 
 
+class ActionErrorData(BaseModel):
+    action: Literal[Action.error] = Action.error
+    data: dict
+
+
 class ActionBudgetNotEnough(BaseModel):
     action: Literal[Action.budget_not_enough] = Action.budget_not_enough
 
@@ -303,6 +309,7 @@ class ActionSkipTaskData(BaseModel):
     | ActionTakeControl
     | ActionNewAgent
     | ActionBudgetNotEnough
+    | ActionErrorData
     | ActionAddTaskData
     | ActionRemoveTaskData
     | ActionSkipTaskData

backend/app/utils/workforce.py

@@ -42,11 +42,13 @@
 
 from app.agent.listen_chat_agent import ListenChatAgent
 from app.component import code
+from app.component.error_format import normalize_error_to_openai_format
 from app.exception.exception import UserException
 from app.service.task import (
     Action,
     ActionAssignTaskData,
     ActionEndData,
+    ActionErrorData,
     ActionTaskStateData,
     ActionTimeoutData,
     get_camel_task,
@@ -260,6 +262,38 @@ async def eigent_start(self, subtasks: list[Task]):
                 exc_info=True,
             )
             self._state = WorkforceState.STOPPED
+            # Push error event to SSE queue so frontend receives notification
+            try:
+                task_lock = get_task_lock(self.api_task_id)
+                logger.info(
+                    f"[WF-LIFECYCLE] Pushing error to SSE queue, "
+                    f"task_lock={'found' if task_lock else 'None'}"
+                )
+                if task_lock is not None:
+                    message, error_code, _ = normalize_error_to_openai_format(
+                        e
+                    )
+                    logger.info(
+                        f"[WF-LIFECYCLE] Error normalized: "
+                        f"error_code={error_code}, message={message[:100]}"
+                    )
+                    await task_lock.put_queue(
+                        ActionErrorData(
+                            data={
+                                "message": message,
+                                "error_code": error_code,
+                            },
+                        )
+                    )
+                    logger.info(
+                        "[WF-LIFECYCLE] Error event pushed to SSE queue"
+                    )
+            except Exception as queue_err:
+                logger.error(
+                    "[WF-LIFECYCLE] Failed to push error to SSE queue: "
+                    f"{queue_err}",
+                    exc_info=True,
+                )
             raise
         finally:
             if self._state != WorkforceState.STOPPED:

src/store/chatStore.ts

@@ -528,6 +528,7 @@ const chatStore = (initial?: Partial<ChatStore>) =>
         extra_params: {},
       };
       let preferredProviderId: number | null = null;
+      let preferredProvider: any = null;
       if (modelType === 'custom' || modelType === 'local') {
         const res = await proxyFetchGet('/api/providers', {
           prefer: true,
@@ -543,6 +544,7 @@ const chatStore = (initial?: Partial<ChatStore>) =>
         }
 
         preferredProviderId = provider.id ?? null;
+        preferredProvider = provider;
         apiModel = {
           api_key: provider.api_key,
           model_type: provider.model_type,
@@ -1903,9 +1905,23 @@ const chatStore = (initial?: Partial<ChatStore>) =>
               if (errorCode === 'invalid_api_key' && preferredProviderId) {
                 proxyFetchPatch(
                   `/api/provider/${preferredProviderId}/invalidate`
-                ).catch((err: unknown) =>
-                  console.error('Failed to invalidate provider:', err)
-                );
+                ).catch(() => {
+                  // Fallback: PATCH endpoint may not be deployed yet,
+                  // use PUT with full provider data to set is_vaild=1
+                  if (preferredProvider) {
+                    proxyFetchPut(`/api/provider/${preferredProviderId}`, {
+                      provider_name: preferredProvider.provider_name,
+                      model_type: preferredProvider.model_type,
+                      api_key: preferredProvider.api_key,
+                      endpoint_url: preferredProvider.endpoint_url || '',
+                      encrypted_config: preferredProvider.encrypted_config,
+                      is_vaild: 1,
+                      prefer: preferredProvider.prefer ?? false,
+                    }).catch((err: unknown) =>
+                      console.error('Failed to invalidate provider:', err)
+                    );
+                  }
+                });
               }
 
               // Mark all incomplete tasks as failed