@prometheus-ai/ai 0.5.4 → 0.5.8

package/src/utils/schema/wire.ts

@@ -50,8 +50,8 @@ export function isZodSchema(value: unknown): value is ZodType {
 }
 
 /** Symbol-stamped caches keyed by schema object identity. */
-const kZodWireSchema = Symbol("pi.schema.zod.wire");
-const kJsonWireSchema = Symbol("pi.schema.json.wire");
+const kZodWireSchema = Symbol("prometheus.schema.zod.wire");
+const kJsonWireSchema = Symbol("prometheus.schema.json.wire");
 
 /**
  * Post-process Zod-emitted JSON Schema so it matches the wire shape providers

package/src/utils/sse-debug.ts

@@ -1,9 +1,6 @@
 import type { ServerSentEvent } from "@prometheus-ai/utils";
 import type { RawSseEvent } from "../types";
 
-type FetchFunction = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-type FetchWithPreconnect = FetchFunction & { preconnect?: typeof fetch.preconnect };
-
 type RawSseObserver = (event: RawSseEvent) => void;
 
 export function notifyRawSseEvent(observer: RawSseObserver | undefined, event: ServerSentEvent | RawSseEvent): void {
@@ -19,271 +16,3 @@ export function notifyRawSseEvent(observer: RawSseObserver | undefined, event: S
 		// Raw stream observers are diagnostic only and must not affect generation.
 	}
 }
-
-function isSseResponse(response: Response): boolean {
-	// `response.body` is non-null for any fetch Response with a body, but we
-	// still guard because user-supplied `fetch` mocks may return `{ body: null }`
-	// for empty responses and we don't want to wrap those.
-	if (!response.ok || !response.body) return false;
-	const contentType = response.headers.get("content-type");
-	// All providers in this repo emit lowercase `text/event-stream` (verified
-	// against anthropic, openai-completions, openai-responses, azure-openai-responses,
-	// google-shared, google-gemini-cli, openai-codex-responses, prometheus-native-client,
-	// and the auth-gateway server). A canonical `includes` check is sufficient;
-	// if a future provider sends mixed case it will fall back to the unwrapped
-	// fetch — observably safe, just no debug tee for that response.
-	return contentType?.includes("text/event-stream") ?? false;
-}
-
-// Reused for every UTF-8 line decode. Safe because lines are split on LF
-// (0x0a), which is single-byte ASCII and never appears inside a UTF-8
-// multi-byte sequence — each line is a complete UTF-8 run, so the decoder
-// carries no state across calls.
-const SSE_LINE_DECODER = new TextDecoder("utf-8");
-
-// Decode bytes [start, end) of an SSE line.
-//
-// A previous revision added an ASCII fast-path using `String.fromCharCode.apply`
-// over chunked subarrays, on the theory that skipping `TextDecoder` would save
-// the ~9.7% `decode` self-time the profile reported. In practice the swap
-// *regressed* total wall time: `fromCharCode` became a new 7.8% hotspot,
-// `Uint8Array` allocations grew 5.3%, and `subarray` rose from 11.5% to 18.3%
-// — net loss of ~10pp. Bun's `TextDecoder.decode` has a fast C++ ASCII path
-// that beats chunked `fromCharCode.apply` for the typical sub-1KB SSE line,
-// so we keep the decoder. The line is bounded by LF (0x0a, single-byte
-// ASCII), so each [start, end) slice is a complete UTF-8 run and the shared
-// stateless decoder is safe to reuse.
-function decodeSseLine(buf: Uint8Array, start: number, end: number): string {
-	if (start === 0 && end === buf.length) return SSE_LINE_DECODER.decode(buf);
-	return SSE_LINE_DECODER.decode(buf.subarray(start, end));
-}
-
-/**
- * Inline SSE event splitter. Walks the byte stream as it flows through a
- * `TransformStream`, dispatching parsed events to the debug observer while
- * the bytes are forwarded unchanged to the response consumer. Replaces the
- * previous `body.tee()` + `readSseEvents` re-parse pipeline so the byte
- * stream is parsed exactly once when a debug observer is attached.
- *
- * Field parsing intentionally mirrors `readSseEvents` in `@prometheus-ai/utils`
- * (only `event` and `data` are observed; `id`/`retry` ignored; CR stripped
- * before LF dispatch; leading space after `:` trimmed; `data:` lines join
- * with `\n`). Reusing `readSseEvents` directly would require a second stream
- * pipeline, which is exactly what this class avoids.
- */
-class SseTeeParser {
-	#observer: RawSseObserver;
-	// Trailing bytes from the previous chunk that did not end with LF.
-	#partial: Uint8Array | null = null;
-	#event: string | null = null;
-	#data: string | null = null;
-	#raw: string[] = [];
-
-	constructor(observer: RawSseObserver) {
-		this.#observer = observer;
-	}
-
-	push(chunk: Uint8Array): void {
-		// Carry-forward path: concat the partial line with the new chunk so the
-		// LF scan walks a single contiguous buffer. The common case (partial is
-		// null) skips the allocation entirely.
-		let buf: Uint8Array;
-		if (this.#partial) {
-			buf = new Uint8Array(this.#partial.length + chunk.length);
-			buf.set(this.#partial, 0);
-			buf.set(chunk, this.#partial.length);
-			this.#partial = null;
-		} else {
-			buf = chunk;
-		}
-
-		const len = buf.length;
-		let i = 0;
-		while (i < len) {
-			const lf = buf.indexOf(0x0a, i);
-			if (lf === -1) {
-				// Retain the tail as a partial line for the next chunk. Copy
-				// because the source `chunk` buffer may be reused upstream.
-				this.#partial = buf.subarray(i).slice();
-				return;
-			}
-			let end = lf;
-			if (end > i && buf[end - 1] === 0x0d) end--;
-			this.#consumeLine(buf, i, end);
-			i = lf + 1;
-		}
-	}
-
-	flush(): void {
-		// Treat any trailing partial line (no terminating LF) as a complete line.
-		if (this.#partial) {
-			const tail = this.#partial;
-			this.#partial = null;
-			let end = tail.length;
-			if (end > 0 && tail[end - 1] === 0x0d) end--;
-			if (end > 0) this.#consumeLine(tail, 0, end);
-		}
-		// Real services don't always close on a blank line — flush any pending event.
-		this.#dispatch();
-	}
-
-	#consumeLine(buf: Uint8Array, start: number, end: number): void {
-		if (end === start) {
-			this.#dispatch();
-			return;
-		}
-		// Comment line: keep verbatim in `raw` for diagnostic context, skip parsing.
-		// SSE spec § 9.2.6: lines beginning with ':' are heartbeats/comments and
-		// MUST NOT contribute to the event dispatch state. Heartbeats are the
-		// single most common line type on long-poll provider streams, so the
-		// early-return here directly avoids ~half the field-parse work.
-		if (buf[start] === 0x3a /* ':' */) {
-			this.#raw.push(decodeSseLine(buf, start, end));
-			return;
-		}
-		// Byte-level field parse. We avoid `text.indexOf(':')` + two `String.slice`
-		// calls (~6% of CPU pre-optimization) by scanning bytes for the field
-		// delimiter and matching the field name byte-for-byte. Field-name bytes
-		// are ASCII per SSE spec, so byte offsets equal char offsets in the
-		// decoded string and we can `slice` the value directly off `text` without
-		// re-decoding.
-		//
-		// ASCII signatures (verified against SSE spec):
-		//   "event" = 0x65 0x76 0x65 0x6e 0x74  (5 bytes)
-		//   "data"  = 0x64 0x61 0x74 0x61       (4 bytes)
-		let colon = -1;
-		for (let k = start; k < end; k++) {
-			if (buf[k] === 0x3a) {
-				colon = k;
-				break;
-			}
-		}
-		const fieldEnd = colon === -1 ? end : colon;
-		let valueStart = colon === -1 ? end : colon + 1;
-		// Per SSE spec, a single leading SP after the colon is stripped.
-		if (valueStart < end && buf[valueStart] === 0x20 /* ' ' */) valueStart++;
-		const fieldLen = fieldEnd - start;
-		const isEvent =
-			fieldLen === 5 &&
-			buf[start] === 0x65 &&
-			buf[start + 1] === 0x76 &&
-			buf[start + 2] === 0x65 &&
-			buf[start + 3] === 0x6e &&
-			buf[start + 4] === 0x74;
-		const isData =
-			!isEvent &&
-			fieldLen === 4 &&
-			buf[start] === 0x64 &&
-			buf[start + 1] === 0x61 &&
-			buf[start + 2] === 0x74 &&
-			buf[start + 3] === 0x61;
-		// Decode the line exactly once. Raw observers (debug buffer) want it
-		// regardless of field kind; `id`/`retry`/unknown lines pay only the
-		// decode cost, not any extra slicing.
-		const text = decodeSseLine(buf, start, end);
-		this.#raw.push(text);
-		if (isEvent) {
-			// `valueStart - start` is a byte offset into the line; since the
-			// "event:" prefix (and the optional SP) are pure ASCII, that byte
-			// offset equals the char offset in the decoded `text`.
-			this.#event = valueStart === end ? "" : text.slice(valueStart - start);
-		} else if (isData) {
-			const value = valueStart === end ? "" : text.slice(valueStart - start);
-			if (this.#data === null) this.#data = value;
-			else this.#data = `${this.#data}\n${value}`;
-		}
-		// `id` and `retry` are intentionally ignored — providers don't use them
-		// and reconnects are handled by the underlying transport.
-	}
-
-	// Hands ownership of the accumulated `raw` array to the observer. The
-	// observer (currently only `RawSseDebugBuffer.recordEvent`) MAY retain the
-	// array; we install a fresh `#raw = []` for the next event before invoking
-	// the observer so there is no aliasing across dispatches. This contract is
-	// mirrored in `notifyRawSseEvent` (no defensive clone) — see its comment.
-	//
-	// TODO(BufferOpt): once the buffer-side audit confirms it never mutates
-	// `event.raw`, the defensive `[...event.raw]` clone in older call paths
-	// (search for `notifyRawSseEvent`) can be dropped repository-wide.
-	#dispatch(): void {
-		if (this.#event === null && this.#data === null) return;
-		const event: RawSseEvent = {
-			event: this.#event,
-			data: this.#data ?? "",
-			raw: this.#raw,
-		};
-		this.#event = null;
-		this.#data = null;
-		this.#raw = [];
-		try {
-			this.#observer(event);
-		} catch {
-			// Raw stream observers are diagnostic only and must not affect generation.
-		}
-	}
-}
-
-export function wrapFetchForSseDebug(
-	fetchImpl: FetchWithPreconnect,
-	observer: RawSseObserver | undefined,
-): FetchWithPreconnect {
-	if (!observer) return fetchImpl;
-
-	const wrapped = Object.assign(
-		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
-			const response = await fetchImpl(input, init);
-			if (!isSseResponse(response)) {
-				return response;
-			}
-
-			const body = response.body;
-			if (!body) return response;
-
-			// Single-pass interception. Previously implemented as
-			// `body.pipeThrough(new TransformStream({...}))`, but the WHATWG
-			// TransformStream machinery imposes a per-chunk Promise boundary
-			// (`#handleNumberResult` showed at 8.8% self-time in CPU profile).
-			// A manual ReadableStream pulling directly from `body.getReader()`
-			// skips that hop: every `read()` immediately feeds both the parser
-			// and the controller in the same microtask.
-			const parser = new SseTeeParser(observer);
-			const reader = body.getReader();
-			const teed = new ReadableStream<Uint8Array>({
-				async pull(controller) {
-					try {
-						const { done, value } = await reader.read();
-						if (done) {
-							parser.flush();
-							controller.close();
-							return;
-						}
-						// Enqueue first so the consumer sees bytes ASAP; parser
-						// dispatch is best-effort diagnostic and runs after.
-						controller.enqueue(value);
-						parser.push(value);
-					} catch (err) {
-						// Mirror TransformStream semantics: surface upstream
-						// errors to the consumer; do not flush a partial event.
-						controller.error(err);
-					}
-				},
-				cancel(reason) {
-					// Propagate downstream cancellation to the source body so the
-					// underlying connection is released. Matches `pipeThrough`'s
-					// cancel-propagation behavior; `flush()` is intentionally NOT
-					// called (TransformStream skips `flush` on abort too).
-					return reader.cancel(reason);
-				},
-			});
-
-			return new Response(teed, {
-				status: response.status,
-				statusText: response.statusText,
-				headers: response.headers,
-			});
-		},
-		fetchImpl.preconnect ? { preconnect: fetchImpl.preconnect } : {},
-	);
-
-	return wrapped;
-}

package/src/utils/stream-markup-healing.ts

@@ -13,6 +13,8 @@
  * deltas for thinking blocks, and holds partial tags across chunk boundaries.
  */
 
+import { isDeepseekModelIdOrName } from "@prometheus-ai/catalog/identity";
+
 import { parseJsonWithRepair } from "./json-parse";
 
 const KIMI_SECTION_BEGIN = "<|tool_calls_section_begin|>";
@@ -36,6 +38,8 @@ const DSML_PARAMETER_OPEN_RE = new RegExp(
 	"y",
 );
 const DSML_PARAMETER_CLOSE_RE = new RegExp(`</${DSML_PIPE}DSML${DSML_PIPE}parameter>`, "y");
+/** Canonical DSML section-open shape; `|` positions accept either pipe variant. */
+const DSML_SECTION_OPEN_TEMPLATE = "<|DSML|tool_calls>";
 
 const THINK_OPEN = "<think>";
 const THINK_CLOSE = "</think>";
@@ -81,6 +85,7 @@ type XmlToolState =
 			readonly paramName: string;
 			readonly isString: boolean;
 			value: string;
+			truncated?: boolean;
 	  };
 
 type ThinkingTag = { readonly open: string; readonly close: string };
@@ -429,12 +434,25 @@ export class StreamMarkupHealing {
 					continue;
 				}
 			} else if (this.#tryMatch(config.parameterClose)) {
-				state.args[state.paramName] = coerceXmlParamValue(state.value, state.isString);
+				// A capped value executes with silently corrupted input unless the
+				// truncation is made explicit — the marker fails JSON params loudly
+				// and tells the model/tool what happened to string params.
+				const paramValue = state.truncated
+					? `${state.value}\n…[parameter truncated: exceeded ${MAX_XML_PARAM_VALUE_LENGTH} bytes]`
+					: state.value;
+				state.args[state.paramName] = coerceXmlParamValue(paramValue, state.isString);
 				config.setState({ kind: "invoke", name: state.invokeName, args: state.args });
 				continue;
 			}
 
-			if (this.#startsWithPartialXmlTag()) break;
+			if (state.kind === "idle") {
+				// In idle, a bare `<` is legitimate output (`a < b`, generics, JSX).
+				// Only hold back tails that could still grow into the DSML
+				// section-open tag; everything else flows through immediately.
+				if (this.#startsWithPartialDsmlSectionOpen()) break;
+			} else if (this.#startsWithPartialXmlTag()) {
+				break;
+			}
 
 			const ch = this.#buffer[this.#offset]!;
 			this.#offset += 1;
@@ -443,11 +461,15 @@ export class StreamMarkupHealing {
 				continue;
 			}
 			if (state.kind === "parameter") {
-				if (state.value.length >= MAX_XML_PARAM_VALUE_LENGTH) {
-					config.setState({ kind: "idle" });
-					continue;
+				if (state.value.length < MAX_XML_PARAM_VALUE_LENGTH) {
+					state.value += ch;
+				} else {
+					// Beyond the cap the value stops growing, but we stay in
+					// `parameter` state so the rest of the envelope — including its
+					// close tags — is still swallowed instead of leaking into
+					// visible text. The close handler appends an explicit marker.
+					state.truncated = true;
 				}
-				state.value += ch;
 			}
 		}
 
@@ -511,6 +533,21 @@ export class StreamMarkupHealing {
 		return true;
 	}
 
+	#startsWithPartialDsmlSectionOpen(): boolean {
+		const tailLength = this.#buffer.length - this.#offset;
+		if (tailLength === 0 || tailLength >= DSML_SECTION_OPEN_TEMPLATE.length) return false;
+		for (let i = 0; i < tailLength; i++) {
+			const ch = this.#buffer[this.#offset + i]!;
+			const expected = DSML_SECTION_OPEN_TEMPLATE[i]!;
+			if (expected === "|") {
+				if (ch !== "|" && ch !== "｜") return false;
+			} else if (ch !== expected) {
+				return false;
+			}
+		}
+		return true;
+	}
+
 	#bufferIsPrefixOf(token: string, remainingLength: number): boolean {
 		for (let i = 0; i < remainingLength; i++) {
 			if (this.#buffer[this.#offset + i] !== token[i]) return false;
@@ -587,7 +624,7 @@ export function modelMayLeakKimiToolCalls(provider: string, modelId: string): bo
 
 /** Cheap model/provider gate for DeepSeek DSML envelope leaks. */
 export function modelMayLeakDsmlToolCalls(provider: string, modelId: string): boolean {
-	if (!/deepseek/i.test(modelId)) return false;
+	if (!isDeepseekModelIdOrName(modelId)) return false;
 	return (
 		provider === "ollama" ||
 		provider === "ollama-cloud" ||
@@ -600,12 +637,17 @@ export function modelMayLeakDsmlToolCalls(provider: string, modelId: string): bo
 	);
 }
 
+/** Cheap model/provider gate for MiniMax plain thinking tag leaks. */
+export function modelMayLeakThinkingTags(provider: string, modelId: string): boolean {
+	return /minimax/i.test(provider) || /minimax/i.test(modelId);
+}
+
 export function getStreamMarkupHealingPattern(
 	provider: string,
 	modelId: string,
 	options?: { readonly parseThinkingTags?: boolean },
 ): StreamMarkupHealingPattern | undefined {
-	if (options?.parseThinkingTags) return "thinking";
+	if (options?.parseThinkingTags || modelMayLeakThinkingTags(provider, modelId)) return "thinking";
 	if (modelMayLeakKimiToolCalls(provider, modelId)) return "kimi";
 	if (modelMayLeakDsmlToolCalls(provider, modelId)) return "dsml";
 	return undefined;

package/src/utils/validation.ts

@@ -724,6 +724,7 @@ interface FlatIssue {
 	keyword: "type" | "unrecognized" | "other";
 	instancePath: string;
 	expectedTypes: string[];
+	unionBranch: boolean;
 }
 
 /**
@@ -759,12 +760,12 @@ function mapZodExpectedToJsonSchemaType(expected: unknown): string | null {
  */
 function flattenIssues(issues: ReadonlyArray<ZodIssue>): FlatIssue[] {
 	const out: FlatIssue[] = [];
-	const walk = (issue: ZodIssue, prefix: ReadonlyArray<PropertyKey>): void => {
+	const walk = (issue: ZodIssue, prefix: ReadonlyArray<PropertyKey>, unionBranch: boolean): void => {
 		const fullPath = prefix.length === 0 ? issue.path : [...prefix, ...issue.path];
 		if (issue.code === "invalid_type") {
 			const mapped = mapZodExpectedToJsonSchemaType((issue as { expected?: unknown }).expected);
 			if (mapped) {
-				out.push({ keyword: "type", instancePath: pathToPointer(fullPath), expectedTypes: [mapped] });
+				out.push({ keyword: "type", instancePath: pathToPointer(fullPath), expectedTypes: [mapped], unionBranch });
 				return;
 			}
 		}
@@ -775,6 +776,7 @@ function flattenIssues(issues: ReadonlyArray<ZodIssue>): FlatIssue[] {
 					keyword: "unrecognized",
 					instancePath: pathToPointer([...fullPath, key]),
 					expectedTypes: [],
+					unionBranch,
 				});
 			}
 			return;
@@ -782,17 +784,21 @@ function flattenIssues(issues: ReadonlyArray<ZodIssue>): FlatIssue[] {
 		if (issue.code === "invalid_union") {
 			const inner = (issue as unknown as { errors?: ReadonlyArray<ReadonlyArray<ZodIssue>> }).errors;
 			if (inner) {
+				// A union-branch issue only competes with a sibling branch when it
+				// sits at the union node's own path. Issues whose own path is
+				// non-empty live on a deeper field that an already-identified
+				// branch owns, so the singleton-array repair should still apply.
 				for (const branch of inner) {
 					for (const child of branch) {
-						walk(child, fullPath);
+						walk(child, fullPath, child.path.length === 0);
 					}
 				}
 			}
 			return;
 		}
-		out.push({ keyword: "other", instancePath: pathToPointer(fullPath), expectedTypes: [] });
+		out.push({ keyword: "other", instancePath: pathToPointer(fullPath), expectedTypes: [], unionBranch });
 	};
-	for (const issue of issues) walk(issue, []);
+	for (const issue of issues) walk(issue, [], false);
 	return out;
 }
 
@@ -801,7 +807,9 @@ function flattenIssues(issues: ReadonlyArray<ZodIssue>): FlatIssue[] {
  *
  * Two kinds of repair are applied:
  *  - **type**: when a value is a JSON-encoded string and the schema wants
- *    something else, parse it and substitute the parsed value.
+ *    something else, parse it and substitute the parsed value. When a
+ *    non-union schema wants an array but receives a singleton value, wrap that
+ *    value in a one-element array.
  *  - **unrecognized**: when a strict object received an extra key (Zod's
  *    `unrecognized_keys` or JSON Schema's `additionalProperties: false`),
  *    drop that key so re-validation succeeds. This effectively coerces every
@@ -811,6 +819,7 @@ function flattenIssues(issues: ReadonlyArray<ZodIssue>): FlatIssue[] {
  * The function is safe and conservative:
  *   - Only processes "type" and "unrecognized" issues
  *   - Only attempts JSON coercion on string values
+ *   - Only wraps singleton array values for non-union type expectations
  *   - Only accepts parsed results that match the expected type
  *   - Clones the args object before mutation (copy-on-write)
  */
@@ -836,12 +845,16 @@ function coerceArgsFromIssues(args: unknown, issues: FlatIssue[]): { value: unkn
 		if (issue.expectedTypes.length === 0) continue;
 
 		const currentValue = getValueAtPointer(nextArgs, issue.instancePath);
-		if (typeof currentValue !== "string") continue;
-
-		const result = tryParseJsonForTypes(currentValue, issue.expectedTypes);
+		const result =
+			typeof currentValue === "string"
+				? tryParseJsonForTypes(currentValue, issue.expectedTypes)
+				: { value: currentValue, changed: false };
 		const coercedValue = result.changed
 			? result.value
-			: issue.expectedTypes.includes("array")
+			: issue.expectedTypes.includes("array") &&
+					!issue.unionBranch &&
+					currentValue !== undefined &&
+					!Array.isArray(currentValue)
 				? [currentValue]
 				: undefined;
 		if (coercedValue === undefined) continue;
@@ -905,17 +918,20 @@ function preserveUnknownRootFields(input: unknown, parsed: unknown): unknown {
 
 function flattenJsonSchemaIssues(issues: ReadonlyArray<JsonSchemaValidationIssue>): FlatIssue[] {
 	return issues.map(issue => {
+		const unionBranch = issue.fromUnionBranch === true;
 		if (issue.keyword === "additionalProperties") {
 			return {
 				keyword: "unrecognized",
 				instancePath: pathToPointer(issue.path),
 				expectedTypes: [],
+				unionBranch,
 			};
 		}
 		return {
 			keyword: issue.keyword === "type" ? "type" : "other",
 			instancePath: pathToPointer(issue.path),
 			expectedTypes: issue.expectedTypes ?? [],
+			unionBranch,
 		};
 	});
 }
@@ -963,6 +979,23 @@ export function validateToolCall(tools: Tool[], toolCall: ToolCall): ToolCall["a
 	return validateToolArguments(tool, toolCall);
 }
 
+/** Cap per-field string lengths when embedding received args in an error message. */
+const MAX_ERROR_ARG_STRING_LENGTH = 256;
+
+function truncateArgsForError(value: unknown): unknown {
+	if (typeof value === "string") {
+		if (value.length <= MAX_ERROR_ARG_STRING_LENGTH) return value;
+		return `${value.slice(0, MAX_ERROR_ARG_STRING_LENGTH)}… [truncated ${value.length - MAX_ERROR_ARG_STRING_LENGTH} chars]`;
+	}
+	if (Array.isArray(value)) return value.map(truncateArgsForError);
+	if (value !== null && typeof value === "object") {
+		const out: Record<string, unknown> = {};
+		for (const [key, entry] of Object.entries(value)) out[key] = truncateArgsForError(entry);
+		return out;
+	}
+	return value;
+}
+
 /**
  * Validates tool call arguments against the tool's schema (Zod or plain JSON
  * Schema). Applies LLM-quirk coercions (numeric strings, JSON-string
@@ -1009,12 +1042,15 @@ export function validateToolArguments(tool: Tool, toolCall: ToolCall): ToolCall[
 	// existing tests; the detailed body is informational.
 	const errors = result.messages.join("\n") || "Unknown validation error";
 
+	// Truncate long per-field strings: the full payload (potentially hundreds
+	// of KB for write/edit-class calls) would otherwise round-trip back to the
+	// model inside the tool error.
 	const receivedArgs = changed
 		? {
-				original: originalArgs,
-				normalized: normalizedArgs,
+				original: truncateArgsForError(originalArgs),
+				normalized: truncateArgsForError(normalizedArgs),
 			}
-		: originalArgs;
+		: truncateArgsForError(originalArgs);
 
 	const errorMessage = `Validation failed for tool "${
 		toolCall.name

package/src/utils.ts

@@ -1,5 +1,5 @@
 import { $env } from "@prometheus-ai/utils";
-import type { ResponseInput } from "openai/resources/responses/responses";
+import type { ResponseInput } from "./providers/openai-responses-wire";
 import type { CacheRetention, OpenAIResponsesHistoryPayload, ProviderPayload } from "./types";
 
 type OpenAIResponsesReplayItem = ResponseInput[number];
@@ -8,27 +8,7 @@ export { isRecord } from "@prometheus-ai/utils";
 export function normalizeSystemPrompts(systemPrompt: readonly string[] | string | undefined | null): string[] {
 	if (systemPrompt === undefined || systemPrompt === null) return [];
 	const prompts = Array.isArray(systemPrompt) ? systemPrompt : typeof systemPrompt === "string" ? [systemPrompt] : [];
-	return prompts.map(prompt => prompt.toWellFormed()).filter(prompt => prompt.length > 0);
-}
-
-export function toNumber(value: unknown): number | undefined {
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string" && value.trim()) {
-		const parsed = Number(value);
-		return Number.isFinite(parsed) ? parsed : undefined;
-	}
-	return undefined;
-}
-
-export function toPositiveNumber(value: unknown, fallback: number): number {
-	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-		return fallback;
-	}
-	return value;
-}
-
-export function toBoolean(value: unknown): boolean | undefined {
-	return typeof value === "boolean" ? value : undefined;
+	return prompts.map(prompt => prompt.toWellFormed()).filter(prompt => prompt.trim().length > 0);
 }
 
 export function normalizeToolCallId(id: string): string {
@@ -160,7 +140,3 @@ export function resolveCacheRetention(cacheRetention?: CacheRetention): CacheRet
 	if ($env.PROMETHEUS_CACHE_RETENTION === "long") return "long";
 	return "short";
 }
-
-export function isAnthropicOAuthToken(key: string): boolean {
-	return key.includes("sk-ant-oat");
-}

package/dist/types/model-cache.d.ts

@@ -1,17 +0,0 @@
-import type { Api, Model } from "./types";
-interface CacheEntry<TApi extends Api = Api> {
-    models: Model<TApi>[];
-    fresh: boolean;
-    authoritative: boolean;
-    updatedAt: number;
-    /**
-     * Hash of the static catalog slice that was merged into `models` when this
-     * row was written. `resolveProviderModels` compares against the current
-     * static fingerprint and bypasses the static+cache re-merge when they
-     * match — the cache already incorporates the same static state.
-     */
-    staticFingerprint: string;
-}
-export declare function readModelCache<TApi extends Api>(providerId: string, ttlMs: number, now: () => number, dbPath?: string): CacheEntry<TApi> | null;
-export declare function writeModelCache<TApi extends Api>(providerId: string, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string): void;
-export {};