jeopi-ai 16.2.13

package/src/utils/leaked-thinking-stream.ts

@@ -0,0 +1,294 @@
+/**
+ * Central live healing for leaked reasoning markup in the visible text channel.
+ *
+ * Some providers emit their canonical reasoning idioms (` ```thinking `,
+ * `<think>`, Gemma/Harmony channels, …) into the *visible* text stream instead
+ * of a structured thinking part. {@link wrapLeakedThinkingStream} re-projects any
+ * provider stream into a fresh {@link AssistantMessageEventStream}, splitting the
+ * leaked fences out into proper `thinking` blocks *live* as deltas arrive — so
+ * every provider gets the same healing, not just the three with provider-local
+ * {@link StreamMarkupHealing} loops.
+ *
+ * The healing is idempotent: a second pass over already-clean text finds no
+ * fences, so wrapping a provider that already heals (or wrapping twice) is a
+ * harmless pass-through. Signatures are load-bearing for Google/Gemini/Vertex
+ * thought round-tripping, so text sub-blocks carry the source `textSignature`,
+ * forwarded thinking blocks their `thinkingSignature`, and forwarded tool calls
+ * their `thoughtSignature`.
+ *
+ * Modeled on {@link wrapInbandToolStream} / `InbandStreamProjector` in
+ * `../dialect/owned-stream.ts`, minus all in-band tool-call grammar: tool-call
+ * events are forwarded verbatim.
+ */
+
+import type { AssistantMessage, TextContent, ThinkingContent, ToolCall } from "../types";
+import {
+	clearStreamingPartialJson,
+	getStreamingPartialJson,
+	type StreamingPartialJsonCarrier,
+	setStreamingPartialJson,
+} from "./block-symbols";
+import { AssistantMessageEventStream } from "./event-stream";
+import { StreamMarkupHealing, type StreamMarkupHealingEvent } from "./stream-markup-healing";
+
+type StreamingToolCall = ToolCall & StreamingPartialJsonCarrier;
+
+function cloneToolCall(source: StreamingToolCall): StreamingToolCall {
+	const block: StreamingToolCall = { ...source, arguments: source.arguments };
+	const partialJson = getStreamingPartialJson(source);
+	if (partialJson !== undefined) setStreamingPartialJson(block, partialJson);
+	return block;
+}
+
+function syncToolCall(target: StreamingToolCall, source: StreamingToolCall): void {
+	Object.assign(target, source);
+	const partialJson = getStreamingPartialJson(source);
+	if (partialJson === undefined) clearStreamingPartialJson(target);
+	else setStreamingPartialJson(target, partialJson);
+}
+
+/**
+ * Wrap a provider stream so leaked reasoning fences are healed into thinking
+ * blocks live, for every provider. Returns a new stream that re-projects the
+ * inner one; the inner stream is fully consumed.
+ */
+export function wrapLeakedThinkingStream(inner: AssistantMessageEventStream): AssistantMessageEventStream {
+	const out = new AssistantMessageEventStream();
+	void (async () => {
+		try {
+			let projector: LeakedThinkingProjector | undefined;
+			for await (const event of inner) {
+				switch (event.type) {
+					case "start":
+						projector = new LeakedThinkingProjector(out, event.partial);
+						break;
+					case "text_delta": {
+						projector ??= new LeakedThinkingProjector(out, event.partial);
+						const block = event.partial.content[event.contentIndex];
+						projector.text(event.delta, block?.type === "text" ? block.textSignature : undefined);
+						break;
+					}
+					case "thinking_delta": {
+						projector ??= new LeakedThinkingProjector(out, event.partial);
+						const block = event.partial.content[event.contentIndex];
+						projector.thinking(event.delta, block?.type === "thinking" ? block.thinkingSignature : undefined);
+						break;
+					}
+					case "toolcall_start": {
+						projector ??= new LeakedThinkingProjector(out, event.partial);
+						const block = event.partial.content[event.contentIndex];
+						projector.toolStart(event.contentIndex, block?.type === "toolCall" ? block : undefined);
+						break;
+					}
+					case "toolcall_delta": {
+						const block = event.partial.content[event.contentIndex];
+						projector?.toolDelta(event.contentIndex, event.delta, block?.type === "toolCall" ? block : undefined);
+						break;
+					}
+					case "toolcall_end":
+						projector?.toolEnd(event.contentIndex, event.toolCall);
+						break;
+					case "done": {
+						projector ??= new LeakedThinkingProjector(out, event.message);
+						const content = projector.finish(event.message);
+						out.push({ type: "done", reason: event.reason, message: { ...event.message, content } });
+						return;
+					}
+					case "error": {
+						projector ??= new LeakedThinkingProjector(out, event.error);
+						const content = projector.finish(event.error);
+						out.push({ type: "error", reason: event.reason, error: { ...event.error, content } });
+						return;
+					}
+					// text_start/text_end/thinking_start/thinking_end are ignored: the
+					// projector owns block boundaries (matches wrapInbandToolStream).
+				}
+			}
+			// Inner ended via end(result) without a terminal event.
+			if (!out.done) {
+				const result = await inner.result();
+				projector ??= new LeakedThinkingProjector(out, result);
+				const content = projector.finish(result);
+				out.end({ ...result, content });
+			}
+		} catch (err) {
+			if (!out.done) out.fail(err);
+		}
+	})();
+	return out;
+}
+
+type OpenBlock = { index: number } | undefined;
+
+/**
+ * Re-projects an inner stream's events into `out`, healing leaked reasoning out
+ * of the visible text channel while forwarding native thinking and tool calls.
+ */
+class LeakedThinkingProjector {
+	readonly #out: AssistantMessageEventStream;
+	readonly #healer = new StreamMarkupHealing({ pattern: "thinking" });
+	#partial: AssistantMessage;
+	#text: OpenBlock;
+	#thinking: OpenBlock;
+	/** Total visible text length fed to the healer, to replay any un-streamed tail in {@link finish}. */
+	#fedLen = 0;
+	/** Latest non-undefined text signature seen, stamped onto held-back text flushed later. */
+	#lastTextSignature: string | undefined;
+	/** Forwarded native tool calls, keyed by the inner stream's `contentIndex`. */
+	#toolBlocks = new Map<number, { index: number; block: StreamingToolCall }>();
+
+	constructor(out: AssistantMessageEventStream, seed: AssistantMessage) {
+		this.#out = out;
+		this.#partial = { ...seed, content: [] };
+		this.#out.push({ type: "start", partial: this.#partial });
+	}
+
+	/** Feed a visible-text delta through the healer, splitting leaked fences live. */
+	text(delta: string, signature: string | undefined): void {
+		this.#fedLen += delta.length;
+		if (signature !== undefined) this.#lastTextSignature = signature;
+		this.#apply(this.#healer.feedEvents(delta), this.#lastTextSignature);
+	}
+
+	/** Forward a native thinking delta, preserving its signature. */
+	thinking(delta: string, signature: string | undefined): void {
+		const index = this.#openThinking();
+		const block = this.#partial.content[index] as ThinkingContent;
+		block.thinking += delta;
+		if (signature !== undefined) block.thinkingSignature = signature;
+		this.#out.push({ type: "thinking_delta", contentIndex: index, delta, partial: this.#partial });
+	}
+
+	/** Forward a native tool call's start, releasing any held-back text first. */
+	toolStart(srcIndex: number, source: StreamingToolCall | undefined): void {
+		if (!source) return;
+		this.#apply(this.#healer.flushEvents(), this.#lastTextSignature);
+		this.#closeText();
+		this.#closeThinking();
+		const block = cloneToolCall(source);
+		this.#partial.content.push(block);
+		const index = this.#partial.content.length - 1;
+		this.#toolBlocks.set(srcIndex, { index, block });
+		this.#out.push({ type: "toolcall_start", contentIndex: index, partial: this.#partial });
+	}
+
+	toolDelta(srcIndex: number, delta: string, source: StreamingToolCall | undefined): void {
+		let entry = this.#toolBlocks.get(srcIndex);
+		if (!entry && source) {
+			this.toolStart(srcIndex, source);
+			entry = this.#toolBlocks.get(srcIndex);
+		}
+		if (!entry) return;
+		if (source) syncToolCall(entry.block, source);
+		this.#out.push({ type: "toolcall_delta", contentIndex: entry.index, delta, partial: this.#partial });
+	}
+
+	toolEnd(srcIndex: number, toolCall: ToolCall): void {
+		const entry = this.#toolBlocks.get(srcIndex);
+		if (entry) {
+			syncToolCall(entry.block, toolCall);
+			this.#out.push({
+				type: "toolcall_end",
+				contentIndex: entry.index,
+				toolCall: entry.block,
+				partial: this.#partial,
+			});
+			this.#toolBlocks.delete(srcIndex);
+			return;
+		}
+		// `end` without a matching `start` — release held text, then forward whole.
+		this.#apply(this.#healer.flushEvents(), this.#lastTextSignature);
+		this.#closeText();
+		this.#closeThinking();
+		const block = cloneToolCall(toolCall);
+		this.#partial.content.push(block);
+		const index = this.#partial.content.length - 1;
+		this.#out.push({ type: "toolcall_start", contentIndex: index, partial: this.#partial });
+		this.#out.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: this.#partial });
+	}
+
+	/**
+	 * Finalize: replay any un-streamed visible-text tail from `message.content`,
+	 * flush held-back fragments, close open blocks, and return the healed content.
+	 */
+	finish(message: AssistantMessage): AssistantMessage["content"] {
+		let fullText = "";
+		let tailSignature: string | undefined;
+		for (const block of message.content) {
+			if (block.type === "text") {
+				fullText += block.text;
+				tailSignature = block.textSignature;
+			}
+		}
+		if (tailSignature !== undefined) this.#lastTextSignature = tailSignature;
+		if (fullText.length > this.#fedLen) {
+			this.#apply(this.#healer.feedEvents(fullText.slice(this.#fedLen)), this.#lastTextSignature);
+		}
+		this.#apply(this.#healer.flushEvents(), this.#lastTextSignature);
+		this.#closeText();
+		this.#closeThinking();
+		return this.#partial.content;
+	}
+
+	#apply(events: readonly StreamMarkupHealingEvent[], signature?: string): void {
+		for (const event of events) {
+			if (event.type === "text") this.#emitText(event.text, signature);
+			else if (event.type === "thinking") this.#emitHealedThinking(event.thinking);
+		}
+	}
+
+	#emitText(text: string, signature: string | undefined): void {
+		if (text.length === 0) return;
+		this.#closeThinking();
+		if (!this.#text) {
+			const block: TextContent =
+				signature === undefined ? { type: "text", text: "" } : { type: "text", text: "", textSignature: signature };
+			this.#partial.content.push(block);
+			this.#text = { index: this.#partial.content.length - 1 };
+			this.#out.push({ type: "text_start", contentIndex: this.#text.index, partial: this.#partial });
+		} else if (signature !== undefined) {
+			(this.#partial.content[this.#text.index] as TextContent).textSignature = signature;
+		}
+		const block = this.#partial.content[this.#text.index] as TextContent;
+		block.text += text;
+		this.#out.push({ type: "text_delta", contentIndex: this.#text.index, delta: text, partial: this.#partial });
+	}
+
+	/** Healed (leaked) thinking carries no signature, matching the source fence. */
+	#emitHealedThinking(text: string): void {
+		if (text.length === 0) return;
+		const index = this.#openThinking();
+		const block = this.#partial.content[index] as ThinkingContent;
+		block.thinking += text;
+		this.#out.push({ type: "thinking_delta", contentIndex: index, delta: text, partial: this.#partial });
+	}
+
+	#openThinking(): number {
+		this.#closeText();
+		if (!this.#thinking) {
+			this.#partial.content.push({ type: "thinking", thinking: "" });
+			this.#thinking = { index: this.#partial.content.length - 1 };
+			this.#out.push({ type: "thinking_start", contentIndex: this.#thinking.index, partial: this.#partial });
+		}
+		return this.#thinking.index;
+	}
+
+	#closeText(): void {
+		if (!this.#text) return;
+		const block = this.#partial.content[this.#text.index] as TextContent;
+		this.#out.push({ type: "text_end", contentIndex: this.#text.index, content: block.text, partial: this.#partial });
+		this.#text = undefined;
+	}
+
+	#closeThinking(): void {
+		if (!this.#thinking) return;
+		const block = this.#partial.content[this.#thinking.index] as ThinkingContent;
+		this.#out.push({
+			type: "thinking_end",
+			contentIndex: this.#thinking.index,
+			content: block.thinking,
+			partial: this.#partial,
+		});
+		this.#thinking = undefined;
+	}
+}

package/src/utils/openai-http.ts

@@ -0,0 +1,122 @@
+/**
+ * JSON-POST → SSE transport for OpenAI-wire streaming endpoints (chat
+ * completions, responses, azure responses). Replaces the `openai` SDK client:
+ *
+ * - Retries: `fetchWithRetry` (Retry-After/quota-hint aware; 5xx/408/429 and
+ *   transient network errors). Default 6 total attempts — parity with the
+ *   SDK's former `maxRetries: 5`.
+ * - SSE decode: `readSseJson` (spec-compliant framing, `[DONE]`-aware).
+ *   `onSseEvent` observers now receive real wire frames instead of events
+ *   re-synthesized from decoded SDK objects.
+ * - Errors: {@link OpenAIHttpError} exposes `status`/`headers`/`code`
+ *   structurally (ProviderHttpError contract — `extractHttpStatusFromError`,
+ *   retry-after extraction, copilot transient classification) and carries the
+ *   captured response body for the strict-tools fallback and the responses
+ *   chain-state detectors, which regex over `error.message`.
+ */
+import { fetchWithRetry, readSseJson, type SseEventObserver } from "jeopi-utils";
+import * as AIError from "../error";
+import { OpenAIHttpError } from "../error";
+
+export { OpenAIHttpError };
+
+import type { FetchImpl } from "../types";
+import type { CapturedHttpErrorResponse } from "./http-inspector";
+
+/**
+ * Total attempts when the caller has no first-event deadline armed. The
+ * removed SDK clients ran `maxRetries: 5`, i.e. 6 requests.
+ */
+const DEFAULT_MAX_ATTEMPTS = 6;
+
+/** Bound the `Error.message` allocation for proxy HTML error pages and the like. */
+const MAX_DETAIL_CHARS = 4096;
+
+export interface OpenAIStreamRequestInit {
+	url: string;
+	headers: Record<string, string>;
+	/** JSON request body; serialized once per call (retries resend the same bytes). */
+	body: unknown;
+	signal: AbortSignal;
+	fetch?: FetchImpl;
+	/**
+	 * Total attempts (initial + retries). Defaults to {@link DEFAULT_MAX_ATTEMPTS}.
+	 * Pass `1` when a first-event watchdog is armed so retries cannot silently
+	 * extend the caller's deadline (mirrors the old `maxRetries: 0` hint).
+	 */
+	maxAttempts?: number;
+	/** Raw wire-frame observer (`onSseEvent` debug pipeline). */
+	onSseEvent?: SseEventObserver;
+}
+
+export interface OpenAIStreamHandle<TEvent> {
+	/** Decoded `data:` payloads; terminates on `[DONE]` or stream end. */
+	events: AsyncGenerator<TEvent>;
+	response: Response;
+	/** `x-request-id` response header (the SDK's former `request_id`). */
+	requestId: string | null;
+}
+
+/**
+ * POST a JSON body and stream back decoded SSE events.
+ *
+ * Throws {@link OpenAIHttpError} on a non-2xx terminal response. Aborts on
+ * `signal` propagate from `fetchWithRetry`/`readSseJson`; callers own the
+ * watchdog timers and abort-reason bookkeeping.
+ */
+export async function postOpenAIStream<TEvent>(init: OpenAIStreamRequestInit): Promise<OpenAIStreamHandle<TEvent>> {
+	const response = await fetchWithRetry(init.url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json", Accept: "text/event-stream", ...init.headers },
+		body: JSON.stringify(init.body),
+		signal: init.signal,
+		fetch: init.fetch,
+		maxAttempts: init.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+		// Bun's native fetch enforces a hard ~300s pre-response timeout (issue #2422).
+		// Cold large-context streams legitimately exceed it; the caller's
+		// `firstEventTimeoutMs`/`AbortSignal` already govern stuck requests.
+		timeout: false,
+	});
+	if (!response.ok) {
+		throw await captureOpenAIHttpError(response);
+	}
+	if (!response.body) {
+		throw new AIError.ProviderResponseError(`OpenAI stream response has no body (status ${response.status})`, {
+			kind: "envelope",
+		});
+	}
+	return {
+		events: readSseJson<TEvent>(response.body, init.signal, init.onSseEvent),
+		response,
+		requestId: response.headers.get("x-request-id"),
+	};
+}
+
+/** Decode a non-2xx response into an {@link OpenAIHttpError} without consuming it twice. */
+export async function captureOpenAIHttpError(response: Response): Promise<AIError.OpenAIHttpError> {
+	let bodyText: string | undefined;
+	let bodyJson: unknown;
+	try {
+		bodyText = await response.text();
+		if (bodyText.trim().length > 0) {
+			try {
+				bodyJson = JSON.parse(bodyText);
+			} catch {}
+		} else {
+			bodyText = undefined;
+		}
+	} catch {}
+	const captured: CapturedHttpErrorResponse = {
+		status: response.status,
+		headers: response.headers,
+		bodyText,
+		bodyJson,
+	};
+	const { detail, code } = OpenAIHttpError.parseEnvelope(bodyJson, bodyText);
+	// "status code (no body)" matches the SDK's former APIError phrasing;
+	// `finalizeErrorMessage` keys a repair path on that exact wording.
+	const message = detail
+		? `${response.status} ${detail.length > MAX_DETAIL_CHARS ? detail.slice(0, MAX_DETAIL_CHARS) : detail}`
+		: `${response.status} status code (no body)`;
+	return new AIError.OpenAIHttpError(message, captured, code);
+}

package/src/utils/openrouter-headers.ts

@@ -0,0 +1,12 @@
+import packageJson from "../../package.json" with { type: "json" };
+
+export function getOpenRouterHeaders(): Record<string, string> {
+	return {
+		"User-Agent": `Oh-My-Pi/${packageJson.version}`,
+		"HTTP-Referer": "https://omp.sh/",
+		"X-OpenRouter-Title": "Oh-My-Pi",
+		"X-OpenRouter-Categories": "cli-agent",
+		"X-OpenRouter-Cache": "true",
+		"X-OpenRouter-Cache-TTL": "3600",
+	};
+}

package/src/utils/parse-bind.ts

@@ -0,0 +1,56 @@
+/**
+ * Shared `host:port` parser used by the auth-broker and auth-gateway boot
+ * paths. Centralized so the two servers can't drift on what they accept (the
+ * gateway used to silently allow empty hostnames; this fixes it).
+ */
+
+import * as AIError from "../error";
+
+export interface ParsedBind {
+	hostname: string;
+	port: number;
+}
+
+function parsePort(raw: string, bind: string): number {
+	if (!/^\d+$/.test(raw)) {
+		throw new AIError.ConfigurationError(`Invalid bind '${bind}'; port must be an integer.`);
+	}
+	const port = Number.parseInt(raw, 10);
+	if (!Number.isFinite(port) || port < 0 || port > 65535) {
+		throw new AIError.ConfigurationError(`Invalid bind '${bind}'; port out of range.`);
+	}
+	return port;
+}
+
+/**
+ * Parse a `host:port` (or bare `port`, which assumes loopback) string.
+ *
+ * Accepts:
+ *   - `"4000"`            → `127.0.0.1:4000`
+ *   - `"0.0.0.0:4000"`    → as written
+ *   - `"[::1]:4000"`      → as written (brackets retained, Bun handles them)
+ *
+ * Rejects:
+ *   - empty input
+ *   - empty hostname (`":4000"`)
+ *   - non-integer / out-of-range port
+ */
+export function parseBind(raw: string): ParsedBind {
+	const trimmed = raw.trim();
+	if (trimmed.length === 0) {
+		throw new AIError.ConfigurationError("Invalid bind; expected 'host:port' or 'port'.");
+	}
+	if (/^\d+$/.test(trimmed)) {
+		return { hostname: "127.0.0.1", port: parsePort(trimmed, raw) };
+	}
+	const lastColon = trimmed.lastIndexOf(":");
+	if (lastColon < 0) {
+		throw new AIError.ConfigurationError(`Invalid bind '${raw}'; expected 'host:port' or 'port'.`);
+	}
+	const hostPart = trimmed.slice(0, lastColon);
+	const portPart = trimmed.slice(lastColon + 1);
+	if (hostPart.length === 0) {
+		throw new AIError.ConfigurationError(`Invalid bind '${raw}'; host must not be empty.`);
+	}
+	return { hostname: hostPart, port: parsePort(portPart, raw) };
+}

package/src/utils/provider-response.ts

@@ -0,0 +1,30 @@
+import type { Api, Model, ProviderResponseMetadata, StreamOptions } from "../types";
+
+export function normalizeProviderResponse(
+	response: Response,
+	requestId?: string | null,
+	metadata?: Record<string, unknown>,
+): ProviderResponseMetadata {
+	const headers: Record<string, string> = {};
+	response.headers.forEach((value, key) => {
+		headers[key.toLowerCase()] = value;
+	});
+	const providerResponse: ProviderResponseMetadata = {
+		status: response.status,
+		headers,
+	};
+	if (requestId !== undefined) providerResponse.requestId = requestId;
+	if (metadata !== undefined) providerResponse.metadata = metadata;
+	return providerResponse;
+}
+
+export async function notifyProviderResponse(
+	options: Pick<StreamOptions, "onResponse"> | undefined,
+	response: Response,
+	model?: Model<Api>,
+	requestId?: string | null,
+	metadata?: Record<string, unknown>,
+): Promise<void> {
+	if (!options?.onResponse) return;
+	await options.onResponse(normalizeProviderResponse(response, requestId, metadata), model);
+}