fix(chat): tighten error status parsing to HTTP-shaped tokens + connection-before-text; dedup isAbortError/messages

Author: blove

libs/ag-ui/src/lib/to-agent.ts

@@ -2,7 +2,7 @@
 import { computed, signal, type Signal } from '@angular/core';
 import { Subject } from 'rxjs';
 import type { AbstractAgent } from '@ag-ui/client';
-import { toAgentError, type AgentError } from '@threadplane/chat';
+import { toAgentError, isAbortError, type AgentError } from '@threadplane/chat';
 import type {
   Agent, Message, AgentStatus, ToolCall, AgentEvent,
   AgentInterrupt,
@@ -109,11 +109,6 @@ export function toAgent(source: AbstractAgent, options: ToAgentOptions = {}): Ag
   // duplicating the user message. Set at the top of submit()'s message path.
   let lastInput: AgentSubmitInput | undefined;
 
-  function isAbortError(error: unknown): boolean {
-    return error instanceof Error
-      && (error.name === 'AbortError' || /abort/i.test(error.message));
-  }
-
   /** Settles the store as idle for stop()-induced failures; returns true if handled. */
   function settleIfAborted(error: unknown): boolean {
     // If we already settled this abort (duplicate delivery — e.g. RUN_ERROR

libs/chat/src/lib/agent/to-agent-error.spec.ts

@@ -41,4 +41,27 @@ describe('toAgentError', () => {
     const e = toAgentError({ status: 503, message: 'Service Unavailable' });
     expect(e.kind).toBe('server'); expect(e.status).toBe(503); expect(e.retryable).toBe(true);
   });
+
+  // NEW: bare 3-digit tokens in model names must NOT yield a bogus status
+  it('does NOT extract status from a bare 3-digit model version string', () => {
+    const e = toAgentError(new Error('model gpt-500 is not available'));
+    expect(e.kind).toBe('server');
+    expect(e.retryable).toBe(true);
+    expect(e.status).toBeUndefined();
+  });
+
+  // NEW: connection detection must fire BEFORE loose text parsing
+  it('classifies "Failed to fetch (502 upstream)" as connection, not server', () => {
+    const e = toAgentError(new TypeError('Failed to fetch (502 upstream)'));
+    expect(e.kind).toBe('connection');
+    expect(e.retryable).toBe(true);
+  });
+
+  // NEW: structured cause.status path
+  it('reads structured status via cause.status', () => {
+    const e = toAgentError({ cause: { status: 403 } });
+    expect(e.kind).toBe('auth');
+    expect(e.status).toBe(403);
+    expect(e.retryable).toBe(false);
+  });
 });

libs/chat/src/lib/agent/to-agent-error.ts

@@ -6,15 +6,17 @@ export function isAbortError(raw: unknown): boolean {
   return raw instanceof Error && (raw.name === 'AbortError' || /\babort/i.test(raw.message));
 }
 
-function readStatus(raw: unknown): number | undefined {
+/**
+ * Reads a numeric status from `raw.status` or `raw.cause.status` only.
+ * No text parsing — structured fields only.
+ */
+function structuredStatus(raw: unknown): number | undefined {
   const obj = raw as { status?: unknown; cause?: { status?: unknown } } | null;
   const direct = typeof obj?.status === 'number' ? obj.status : undefined;
   const viaCause = typeof obj?.cause?.status === 'number' ? obj!.cause!.status : undefined;
   if (direct !== undefined) return direct;
   if (viaCause !== undefined) return viaCause;
-  const msg = raw instanceof Error ? raw.message : typeof raw === 'string' ? raw : '';
-  const m = /\b(\d{3})\b/.exec(msg);
-  return m ? Number(m[1]) : undefined;
+  return undefined;
 }
 
 function isConnectionError(raw: unknown): boolean {
@@ -24,23 +26,60 @@ function isConnectionError(raw: unknown): boolean {
   );
 }
 
+/**
+ * Extracts an HTTP status code from a message string, but ONLY when the token
+ * is unambiguously HTTP-shaped:
+ *  - `HTTP/502`, `HTTP 404`, `HTTP404`
+ *  - `status: 503`, `status=503`, `code: 404`
+ *
+ * Bare 3-digit numbers (e.g. model version strings like "gpt-500") are NOT matched.
+ */
+function httpStatusFromMessage(raw: unknown): number | undefined {
+  const msg =
+    raw instanceof Error ? raw.message : typeof raw === 'string' ? raw : '';
+  if (!msg) return undefined;
+
+  // "HTTP 500", "HTTP/500", "HTTP500"
+  const httpToken = /\bHTTP[ /]?(\d{3})\b/i.exec(msg);
+  if (httpToken) return Number(httpToken[1]);
+
+  // "status: 503", "status=503", "status 503" (up to 4 non-digit chars between keyword and digits)
+  // Also matches "code: 404", "code=404", etc.
+  const prefixed = /\b(?:status|code)\b\D{0,4}(\d{3})\b/i.exec(msg);
+  if (prefixed) return Number(prefixed[1]);
+
+  return undefined;
+}
+
 function make(kind: AgentErrorKind, retryable: boolean, raw: unknown, status?: number, message?: string): AgentError {
   return new AgentError({ kind, retryable, status, cause: raw, message: message ?? AGENT_ERROR_MESSAGES[kind] });
 }
 
+function classifyByStatus(status: number, raw: unknown): AgentError {
+  if (status === 401 || status === 403) return make('auth', false, raw, status);
+  if (status >= 500) return make('server', true, raw, status);
+  if (status >= 400) return make('server', false, raw, status, `The request was rejected (HTTP ${status}).`);
+  // Stray 2xx/3xx from a status field — treat as unknown transient failure, no status.
+  return make('server', true, raw, undefined, 'Something went wrong. You can try again.');
+}
+
 /** Classify any raw error into a structured {@link AgentError}. Idempotent. */
 export function toAgentError(raw: unknown): AgentError {
   if (raw instanceof AgentError) return raw;
   if (isAbortError(raw)) return make('aborted', false, raw);
 
-  const status = readStatus(raw);
-  if (status !== undefined) {
-    if (status === 401 || status === 403) return make('auth', false, raw, status);
-    if (status >= 500) return make('server', true, raw, status);
-    if (status >= 400) return make('server', false, raw, status, `The request was rejected (HTTP ${status}).`);
-  }
+  // 1. Structured status (authoritative): raw.status or raw.cause.status.
+  const structured = structuredStatus(raw);
+  if (structured !== undefined) return classifyByStatus(structured, raw);
+
+  // 2. Network/connection markers are definitive — before any loose text parsing.
   if (isConnectionError(raw)) return make('connection', true, raw);
 
+  // 3. Best-effort: only an HTTP-shaped status token in the message counts.
+  const httpStatus = httpStatusFromMessage(raw);
+  if (httpStatus !== undefined) return classifyByStatus(httpStatus, raw);
+
+  // 4. Fallback: unknown failure, assume transient.
   const msg = raw instanceof Error && raw.message ? raw.message : 'Something went wrong. You can try again.';
-  return make('server', true, raw, status, msg);
+  return make('server', true, raw, undefined, msg);
 }

libs/langgraph/src/lib/internals/stream-manager.bridge.ts

@@ -20,7 +20,7 @@ import type {
   AgentRuntimeTelemetryProperties,
   AgentRuntimeTelemetrySink,
 } from '@threadplane/chat';
-import { AgentError, toAgentError, isAbortError } from '@threadplane/chat';
+import { AgentError, AGENT_ERROR_MESSAGES, toAgentError, isAbortError } from '@threadplane/chat';
 import {
   SubagentTracker,
   TrackedSubagent,
@@ -450,8 +450,8 @@ export function createStreamManagerBridge<T, ResolvedBag extends BagTemplate = B
         // A non-user-requested abort: interrupted if a stream had started, else a
         // connect-phase failure. Never "aborted" (that's reserved for user stop).
         const e = streamingStarted
-          ? new AgentError({ kind: 'interrupted', message: 'The response was interrupted. Try again.', retryable: true, cause: err })
-          : new AgentError({ kind: 'connection', message: "Can't reach the server. Check your connection and try again.", retryable: true, cause: err });
+          ? new AgentError({ kind: 'interrupted', message: AGENT_ERROR_MESSAGES.interrupted, retryable: true, cause: err })
+          : new AgentError({ kind: 'connection', message: AGENT_ERROR_MESSAGES.connection, retryable: true, cause: err });
         subjects.error$.next(e);
         subjects.status$.next(ResourceStatus.Error);
         captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_errored', {