xonecas.io
64875
Mc

mini-coder / commit b1ed99a

fix: normalize provider error payloads

xonecas2026-03-16 b1ed99a0936d829d20e6c50b182eee2d2f153792 parent 0f10aec

10 files changed

TODO.md+2−0
@@ -1,5 +1,7 @@
11 # TODO
22
3+- Chat completions endpoint models sometimes print empty assistant messages.
4+
35 ---
46
57 ## UI Audit
research.md+38−0
@@ -0,0 +1,38 @@
1+I want your help exploring how could we use yoctocolor to add color ouput to commonly used shell commands. Let's first check the db, check the recent past sessions for a sample. Then check for the shell usage and assert the most common commands
2+
3+Response:
4+
5+## Shell Usage Analysis (from 101 sessions)
6+
7+Most common commands:
8+| Command | Count | Opportunity |
9+|---------|-------|-------------|
10+| `cat` | 72 | File content preview |
11+| `git` | 54 | Status/diff output |
12+| `bun` | 32 | Test/build output |
13+| `sed` | 29 | Transform preview |
14+| `mc-edit` | 26 | File edits |
15+| `nl` | 12 | Line numbers |
16+| `rg` | 11 | Search matches |
17+| `npm` | 9 | Package output |
18+| `grep` | 7 | Match highlighting |
19+| `ls` | 5 | File listings |
20+
21+## Current Shell Output Coloring (in `tool-result-renderers.ts`)
22+
23+The shell result renderer already uses yoctocolors:
24+
25+- **Status badges**: `c.green("done")` / `c.red("error")` / `c.yellow("timeout")`
26+- **Stderr lines**: `c.red()` for error emphasis
27+- **Stdout/stderr line separators**: `c.dim()` or colored pipe character
28+
29+## Enhancement Opportunities
30+
31+1. **Command syntax highlighting** - Color `git`, `bun`, `npm` commands differently in the tool call line
32+2. **File path highlighting** - Use `c.cyan()` for paths in output
33+3. **Git diffs from mc-edit** - Render a colored diff
34+4. **Line numbers** - `nl` output could use `c.yellow()` for numbers
35+5. **Git output** - Branch names in `c.cyan()`, commit hashes in `c.yellow()`, file statuses (M/A/D) in color
36+6. **rg/grep matches** - Highlight matching text in `c.greenBright()` or `c.yellow()`
37+7. **Exit code** - Non-zero codes in `c.red()` or `c.yellow()`
38+8. **Test output** - `bun test` results: passes in `c.green()`, fails in `c.red()`, skips in `c.yellow()`
src/cli/error-parse.test.ts+26−3
@@ -149,6 +149,14 @@ test("parseAppError - ECONNRESET code", () => {
149149 });
150150 });
151151
152+test("parseAppError - empty message Error with ECONNRESET code", () => {
153+ const err = Object.assign(new Error(""), { code: "ECONNRESET" });
154+ expect(parseAppError(err)).toEqual({
155+ headline: "Connection lost",
156+ hint: "The server closed the connection — retry or switch model with /model",
157+ });
158+});
159+
152160 test("parseAppError - socket closed unexpectedly message", () => {
153161 const err = new Error(
154162 "The socket connection was closed unexpectedly. For more information, pass `verbose: true`",
@@ -166,12 +174,27 @@ test("parseAppError - fallback", () => {
166174 });
167175 });
168176
169-test("parseAppError - nested error object (SSE stream error payload)", () => {
177+test("parseAppError - object payload prefers nested error message", () => {
170178 const err = { type: "error", error: { message: "model_not_found" } };
171179 expect(parseAppError(err)).toEqual({ headline: "model_not_found" });
172180 });
173181
174-test("parseAppError - nested error object with empty message falls back", () => {
182+test("parseAppError - nested error object with empty message falls back to payload", () => {
175183 const err = { type: "error", error: { message: "" } };
176- expect(parseAppError(err)).toEqual({ headline: "[object Object]" });
184+ expect(parseAppError(err)).toEqual({
185+ headline: '{"type":"error","error":{"message":""}}',
186+ });
187+});
188+
189+test("parseAppError - nested errors array falls back to payload", () => {
190+ const err = { errors: [{ detail: "token expired" }] };
191+ expect(parseAppError(err)).toEqual({
192+ headline: '{"errors":[{"detail":"token expired"}]}',
193+ });
194+});
195+
196+test("parseAppError - circular object fallback", () => {
197+ const circular: Record<string, unknown> = {};
198+ circular.self = circular;
199+ expect(parseAppError(circular)).toEqual({ headline: "Unknown error" });
177200 });
src/cli/error-parse.ts+58−16
@@ -6,6 +6,63 @@ import {
66 RetryError,
77 } from "ai";
88
9+function safeStringifyErrorObject(value: object): string {
10+ try {
11+ const json = JSON.stringify(value);
12+ if (!json || json === "{}") {
13+ return "Unknown error";
14+ }
15+ const maxLen = 240;
16+ return json.length > maxLen ? `${json.slice(0, maxLen - 1)}…` : json;
17+ } catch {
18+ return "Unknown error";
19+ }
20+}
21+
22+function extractObjectMessage(err: object): string | null {
23+ const record = err as Record<string, unknown>;
24+ const direct = record.message;
25+ if (typeof direct === "string" && direct.trim()) return direct.trim();
26+
27+ const nested = record.error;
28+ if (typeof nested === "object" && nested !== null) {
29+ const nestedMessage = (nested as Record<string, unknown>).message;
30+ if (typeof nestedMessage === "string" && nestedMessage.trim()) {
31+ return nestedMessage.trim();
32+ }
33+ }
34+
35+ return null;
36+}
37+
38+function toUserErrorMessage(err: unknown): string {
39+ if (err instanceof Error) {
40+ const msg = err.message.trim();
41+ if (msg) return msg;
42+ }
43+
44+ if (typeof err === "string") {
45+ const msg = err.trim();
46+ if (msg) return msg;
47+ }
48+
49+ if (
50+ typeof err === "number" ||
51+ typeof err === "boolean" ||
52+ typeof err === "bigint"
53+ ) {
54+ return String(err);
55+ }
56+
57+ if (typeof err === "object" && err !== null) {
58+ const objectMessage = extractObjectMessage(err);
59+ if (objectMessage) return objectMessage;
60+ return safeStringifyErrorObject(err);
61+ }
62+
63+ return "Unknown error";
64+}
65+
966 export function parseAppError(err: unknown): {
1067 headline: string;
1168 hint?: string;
@@ -76,22 +133,7 @@ export function parseAppError(err: unknown): {
76133
77134 const isObj = typeof err === "object" && err !== null;
78135 const code = isObj && "code" in err ? String(err.code) : undefined;
79-
80- // Handle streaming API error events, e.g. { type: "error", error: { message: "..." } }
81- // from the OpenAI responses API or similar SSE error payloads.
82- if (
83- isObj &&
84- "error" in err &&
85- typeof (err as { error: unknown }).error === "object" &&
86- (err as { error: unknown }).error !== null
87- ) {
88- const inner = (err as { error: { message?: unknown } }).error;
89- if (typeof inner.message === "string" && inner.message) {
90- return { headline: inner.message };
91- }
92- }
93-
94- const message = isObj && "message" in err ? String(err.message) : String(err);
136+ const message = toUserErrorMessage(err);
95137
96138 if (code === "ECONNREFUSED" || message.includes("ECONNREFUSED")) {
97139 return {
src/llm-api/error-utils.test.ts+30−0
@@ -0,0 +1,30 @@
1+import { describe, expect, test } from "bun:test";
2+import { normalizeUnknownError } from "./error-utils.ts";
3+
4+describe("normalizeUnknownError", () => {
5+ test("returns existing Error instances with messages", () => {
6+ const error = new Error("boom");
7+ expect(normalizeUnknownError(error)).toBe(error);
8+ });
9+
10+ test("preserves empty-message Error metadata", () => {
11+ const error = Object.assign(new Error(""), { code: "ECONNRESET" });
12+ const normalized = normalizeUnknownError(error) as Error & {
13+ code?: string;
14+ };
15+ expect(normalized).toBe(error);
16+ expect(normalized.code).toBe("ECONNRESET");
17+ });
18+
19+ test("prefers shallow nested object message", () => {
20+ expect(
21+ normalizeUnknownError({ error: { message: "model_not_found" } }).message,
22+ ).toBe("model_not_found");
23+ });
24+
25+ test("falls back to Unknown error for circular objects", () => {
26+ const circular: Record<string, unknown> = {};
27+ circular.self = circular;
28+ expect(normalizeUnknownError(circular).message).toBe("Unknown error");
29+ });
30+});
src/llm-api/error-utils.ts+48−0
@@ -0,0 +1,48 @@
1+function extractObjectMessage(error: object): string | null {
2+ const record = error as Record<string, unknown>;
3+ const direct = record.message;
4+ if (typeof direct === "string" && direct.trim()) return direct.trim();
5+
6+ const nested = record.error;
7+ if (typeof nested === "object" && nested !== null) {
8+ const nestedMessage = (nested as Record<string, unknown>).message;
9+ if (typeof nestedMessage === "string" && nestedMessage.trim()) {
10+ return nestedMessage.trim();
11+ }
12+ }
13+
14+ return null;
15+}
16+
17+function stringifyUnknown(error: unknown): string {
18+ if (error === null || error === undefined) return "Unknown error";
19+ if (typeof error === "string") {
20+ const message = error.trim();
21+ return message || "Unknown error";
22+ }
23+ if (
24+ typeof error === "number" ||
25+ typeof error === "boolean" ||
26+ typeof error === "bigint"
27+ ) {
28+ return String(error);
29+ }
30+ if (typeof error !== "object") return "Unknown error";
31+
32+ const objectMessage = extractObjectMessage(error);
33+ if (objectMessage) return objectMessage;
34+
35+ try {
36+ const value = JSON.stringify(error);
37+ if (!value || value === "{}") return "Unknown error";
38+ const maxLen = 500;
39+ return value.length > maxLen ? `${value.slice(0, maxLen - 1)}…` : value;
40+ } catch {
41+ return "Unknown error";
42+ }
43+}
44+
45+export function normalizeUnknownError(error: unknown): Error {
46+ if (error instanceof Error) return error;
47+ return new Error(stringifyUnknown(error));
48+}
src/llm-api/turn-execution.ts+2−1
@@ -1,5 +1,6 @@
11 import type { FlexibleSchema, StepResult } from "ai";
22 import { dynamicTool, jsonSchema, type streamText } from "ai";
3+import { normalizeUnknownError } from "./error-utils.ts";
34 import {
45 extractToolArgs,
56 hasRenderableToolArgs,
@@ -46,7 +47,7 @@ function toCoreTool(def: ToolDef): ReturnType<typeof dynamicTool> {
4647 try {
4748 return await def.execute(input);
4849 } catch (err) {
49- throw err instanceof Error ? err : new Error(String(err));
50+ throw normalizeUnknownError(err);
5051 }
5152 },
5253 });
src/llm-api/turn-stream-events.test.ts+9−0
@@ -118,4 +118,13 @@ describe("mapStreamChunkToTurnEvent", () => {
118118 mapStreamChunkToTurnEvent({ type: "error", error: new Error("boom") }),
119119 ).toThrow("boom");
120120 });
121+
122+ test("throws nested provider message for object error chunks", () => {
123+ expect(() =>
124+ mapStreamChunkToTurnEvent({
125+ type: "error",
126+ error: { error: { message: "model_not_found" } },
127+ }),
128+ ).toThrow("model_not_found");
129+ });
121130 });
src/llm-api/turn-stream-events.ts+2−2
@@ -1,3 +1,4 @@
1+import { normalizeUnknownError } from "./error-utils.ts";
12 import { getReasoningDeltaFromStreamChunk } from "./history-transforms.ts";
23 import type { TurnEvent } from "./types.ts";
34
@@ -79,8 +80,7 @@ export function mapStreamChunkToTurnEvent(c: StreamChunk): TurnEvent | null {
7980 isError: true,
8081 };
8182 case "error": {
82- const err = c.error;
83- throw err instanceof Error ? err : new Error(String(err));
83+ throw normalizeUnknownError(c.error);
8484 }
8585 default:
8686 return null;
src/llm-api/turn.ts+4−2
@@ -1,5 +1,6 @@
11 import { streamText } from "ai";
22 import { isApiLogEnabled, logApiEvent } from "./api-log.ts";
3+import { normalizeUnknownError } from "./error-utils.ts";
34 import type { ThinkingEffort } from "./provider-options.ts";
45 import {
56 type ContextPruningMode,
@@ -165,10 +166,11 @@ export async function* runTurn(options: {
165166 };
166167 } catch (err) {
167168 const finalState = stepTracker.getState();
168- logApiEvent("turn error", err);
169+ const normalizedError = normalizeUnknownError(err);
170+ logApiEvent("turn error", normalizedError);
169171 yield {
170172 type: "turn-error",
171- error: err instanceof Error ? err : new Error(String(err)),
173+ error: normalizedError,
172174 partialMessages: finalState.partialMessages,
173175 };
174176 }