@sigil0/looking-glass 0.2.4 → 0.3.0

package/dist/model/codex-lb.js

@@ -1,14 +1,43 @@
-import OpenAI from "openai";
-import { redactSensitiveText } from "../security.js";
+import { providerError, providerHttpError } from "../errors.js";
+// Current llama.cpp grammar generation can emit invalid GBNF for nested string
+// maxLength constraints at or above 2000. Keep the original schemas for local
+// validation and only relax the cloned schema sent to LM Studio.
+function omitLmStudioLongMaxLengths(value) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            omitLmStudioLongMaxLengths(item);
+        return;
+    }
+    if (!value || typeof value !== "object")
+        return;
+    const object = value;
+    for (const [key, child] of Object.entries(object)) {
+        if (key === "maxLength" && typeof child === "number" && child >= 2_000) {
+            delete object[key];
+            continue;
+        }
+        omitLmStudioLongMaxLengths(child);
+    }
+}
+function lmStudioTools(tools) {
+    return tools.map((tool) => {
+        const parameters = tool.parameters === null ? null : structuredClone(tool.parameters);
+        if (parameters !== null)
+            omitLmStudioLongMaxLengths(parameters);
+        return { ...tool, parameters };
+    });
+}
 export function buildResponseParams(provider, request) {
+    if (provider === "openrouter")
+        return buildOpenRouterParams(request);
     const common = {
         model: request.model,
         instructions: request.instructions,
         input: provider === "lm-studio"
             ? request.input.filter((item) => item.type !== "reasoning")
             : request.input,
-        tools: request.tools,
-        parallel_tool_calls: true,
+        tools: provider === "lm-studio" ? lmStudioTools(request.tools) : request.tools,
+        ...(request.supportsParallelToolCalls ? { parallel_tool_calls: true } : {}),
         ...(request.supportsReasoning ? {
             reasoning: {
                 // codex-lb advertises "ultra" before the public SDK type includes it.
@@ -38,14 +67,14 @@ function detailFrom(value) {
     const outer = value;
     return outer.error && typeof outer.error === "object" ? outer.error : outer;
 }
-async function* responseEvents(response) {
+async function* responseEvents(response, context) {
     if (!response.body)
-        throw new Error("Response stream had no body");
-    const reader = response.body.getReader();
+        throw providerError({ code: "malformed_response", message: "response had no body" }, { ...(context ?? { provider: "provider", operation: "stream" }), protocol: true });
+    const streamReader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
     let data = [];
-    const parse = () => {
+    const parseResponseEvent = () => {
         const payload = data.join("\n");
         data = [];
         if (!payload || payload === "[DONE]")
@@ -58,20 +87,20 @@ async function* responseEvents(response) {
             return event;
         }
         catch (error) {
-            throw Object.assign(new Error(`Malformed response stream event: ${error instanceof Error ? error.message : String(error)}`), {
+            throw providerError(Object.assign(new Error(`Malformed response stream event: ${error instanceof Error ? error.message : String(error)}`), {
                 code: "malformed_response_event",
-            });
+            }), { ...(context ?? { provider: "provider", operation: "stream" }), protocol: true });
         }
     };
     while (true) {
-        const chunk = await reader.read();
+        const chunk = context ? await readStreamChunk(streamReader, context) : await streamReader.read();
         buffer += decoder.decode(chunk.value ?? new Uint8Array(), { stream: !chunk.done });
         let newline = buffer.indexOf("\n");
         while (newline >= 0) {
             const line = buffer.slice(0, newline).replace(/\r$/, "");
             buffer = buffer.slice(newline + 1);
             if (line === "") {
-                const event = parse();
+                const event = parseResponseEvent();
                 if (event)
                     yield event;
             }
@@ -85,7 +114,7 @@ async function* responseEvents(response) {
     }
     if (buffer.startsWith("data:"))
         data.push(buffer.slice(5).trimStart());
-    const event = parse();
+    const event = parseResponseEvent();
     if (event)
         yield event;
 }
@@ -175,6 +204,42 @@ export function lmStudioModelInfo(raw) {
         priority: raw.loaded_instances?.length ? 0 : 1_000,
     };
 }
+function numericPrice(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value !== "string" || value.trim() === "")
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+export function openRouterModelInfo(raw) {
+    const supported = new Set(raw.supported_parameters ?? []);
+    const architecture = raw.architecture ?? {};
+    const pricing = raw.pricing ?? {};
+    const isFree = raw.id.toLowerCase().endsWith(":free")
+        || (numericPrice(pricing.prompt) === 0 && numericPrice(pricing.completion) === 0);
+    const supportsReasoning = supported.has("reasoning");
+    const supportsImages = (architecture.input_modalities ?? []).some((value) => /image/i.test(value));
+    const supportsTools = supported.has("tools") || supported.has("tool_choice")
+        || supported.has("parallel_tool_calls") || supported.has("function_calling");
+    return {
+        id: raw.id,
+        name: raw.name ?? raw.id,
+        description: raw.description ?? "",
+        contextWindow: raw.context_length ?? raw.top_provider?.context_length ?? 128_000,
+        maxOutputTokens: raw.max_completion_tokens ?? raw.top_provider?.max_completion_tokens
+            ?? raw.max_output_tokens ?? null,
+        reasoningEfforts: supportsReasoning ? ["low", "medium", "high"] : ["none"],
+        defaultReasoningEffort: supportsReasoning ? "medium" : "none",
+        defaultVerbosity: "low",
+        supportsReasoning,
+        supportsImages,
+        supportsParallelToolCalls: supportsTools && supported.has("parallel_tool_calls"),
+        supportsFast: false,
+        priority: isFree ? 0 : 1_000,
+        isFree,
+    };
+}
 export function responseText(response) {
     if (response.output_text)
         return response.output_text;
@@ -229,40 +294,285 @@ function lmStudioModelsURL(baseURL) {
     url.pathname = `${url.pathname.replace(/\/?v1\/?$/, "")}/api/v1/models`.replace(/\/+/g, "/");
     return url.toString();
 }
+function chatContent(value) {
+    if (typeof value === "string")
+        return value;
+    if (!Array.isArray(value))
+        return "";
+    const parts = value.flatMap((part) => {
+        if (!part || typeof part !== "object")
+            return [];
+        const item = part;
+        if ((item.type === "input_text" || item.type === "output_text" || item.type === "text")
+            && typeof item.text === "string")
+            return [{ type: "text", text: item.text }];
+        if (item.type === "input_image" && typeof item.image_url === "string") {
+            return [{ type: "image_url", image_url: { url: item.image_url } }];
+        }
+        return [];
+    });
+    return parts.length === 1 && typeof parts[0] === "string" ? parts[0] : parts;
+}
+export function openRouterMessages(instructions, input) {
+    const messages = [];
+    if (instructions.trim())
+        messages.push({ role: "system", content: instructions });
+    for (const raw of input) {
+        const item = raw;
+        if (item.type === "reasoning" || item.type === "compaction")
+            continue;
+        if (item.type === "function_call") {
+            const previous = messages.at(-1);
+            const call = {
+                id: typeof item.call_id === "string" ? item.call_id : String(item.id ?? "call_unknown"),
+                type: "function",
+                function: {
+                    name: typeof item.name === "string" ? item.name : "tool",
+                    arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {}),
+                },
+            };
+            if (previous?.role === "assistant") {
+                if (Array.isArray(previous.tool_calls))
+                    previous.tool_calls.push(call);
+                else
+                    previous.tool_calls = [call];
+            }
+            else
+                messages.push({ role: "assistant", content: null, tool_calls: [call] });
+            continue;
+        }
+        if (item.type === "function_call_output") {
+            messages.push({
+                role: "tool",
+                tool_call_id: typeof item.call_id === "string" ? item.call_id : String(item.id ?? "call_unknown"),
+                content: typeof item.output === "string" ? item.output : JSON.stringify(item.output ?? ""),
+            });
+            continue;
+        }
+        const role = item.role === "developer" ? "system"
+            : item.role === "assistant" ? "assistant" : item.role === "system" ? "system" : "user";
+        messages.push({ role, content: chatContent(item.content) });
+    }
+    return messages;
+}
+export function buildOpenRouterParams(request) {
+    const tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+            ...(tool.strict === undefined ? {} : { strict: tool.strict }),
+        },
+    }));
+    return {
+        model: request.model,
+        messages: openRouterMessages(request.instructions, request.input),
+        ...(tools.length > 0
+            ? { tools, ...(request.supportsParallelToolCalls ? { parallel_tool_calls: true } : {}) }
+            : {}),
+        ...(request.supportsReasoning && request.reasoningEffort !== "none"
+            ? { reasoning: { effort: request.reasoningEffort } } : {}),
+    };
+}
+const MAX_HTTP_ERROR_BYTES = 64 * 1024;
+async function boundedText(response, limit = MAX_HTTP_ERROR_BYTES) {
+    if (!response.body)
+        return "";
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (total < limit) {
+        const next = await reader.read();
+        if (next.done)
+            break;
+        const chunk = next.value ?? new Uint8Array();
+        const take = Math.min(chunk.byteLength, limit - total);
+        if (take > 0)
+            chunks.push(chunk.slice(0, take));
+        total += take;
+        if (take < chunk.byteLength) {
+            await reader.cancel();
+            break;
+        }
+    }
+    return new TextDecoder().decode(Buffer.concat(chunks));
+}
+async function boundedResponseText(response, context) {
+    try {
+        return await boundedText(response);
+    }
+    catch (error) {
+        throw providerError(error, context);
+    }
+}
+function parseJsonBody(text) {
+    if (!text.trim())
+        return "";
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function normalizedUsage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const usage = value;
+    const numberValue = (...keys) => {
+        for (const key of keys) {
+            const candidate = usage[key];
+            if (typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0)
+                return candidate;
+        }
+        return 0;
+    };
+    const inputTokens = numberValue("input_tokens", "prompt_tokens");
+    const outputTokens = numberValue("output_tokens", "completion_tokens");
+    return {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: numberValue("total_tokens") || inputTokens + outputTokens,
+    };
+}
+function requestContext(provider, operation, apiKey, signal, timeoutSignal) {
+    return {
+        provider,
+        operation,
+        configuredSecrets: [apiKey],
+        ...(signal ? { callerSignal: signal } : {}),
+        ...(timeoutSignal ? { timeoutSignal } : {}),
+    };
+}
+async function readJsonResponse(response, context) {
+    let text;
+    try {
+        text = response.ok ? await response.text() : await boundedText(response);
+    }
+    catch (error) {
+        throw providerError(error, context);
+    }
+    if (!response.ok)
+        throw providerHttpError(response.status, parseJsonBody(text), context);
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw providerError(Object.assign(new Error("response was not valid JSON"), { cause: error }), {
+            ...context,
+            protocol: true,
+        });
+    }
+}
+function objectPayload(payload, context, message) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        throw providerError({ code: "malformed_response", message }, { ...context, protocol: true });
+    }
+    return payload;
+}
+async function readStreamChunk(reader, context) {
+    try {
+        return await reader.read();
+    }
+    catch (error) {
+        throw providerError(error, context);
+    }
+}
+async function* openRouterEvents(response, context) {
+    if (!response.body)
+        throw providerError({ code: "malformed_response", message: "response had no body" }, { ...context, protocol: true });
+    const streamReader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let data = [];
+    let ended = false;
+    const emit = () => {
+        const payload = data.join("\n").trim();
+        data = [];
+        if (!payload)
+            return null;
+        if (payload === "[DONE]")
+            return { done: true };
+        try {
+            return JSON.parse(payload);
+        }
+        catch (error) {
+            throw providerError(Object.assign(new Error("malformed SSE event JSON"), {
+                cause: error,
+                code: "malformed_response_event",
+            }), { ...context, protocol: true });
+        }
+    };
+    try {
+        while (true) {
+            const chunk = await readStreamChunk(streamReader, context);
+            buffer += decoder.decode(chunk.value ?? new Uint8Array(), { stream: !chunk.done });
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline).replace(/\r$/, "");
+                buffer = buffer.slice(newline + 1);
+                if (line === "") {
+                    const event = emit();
+                    if (event) {
+                        if (typeof event === "object" && event !== null && "done" in event)
+                            ended = true;
+                        yield event;
+                    }
+                }
+                else if (line.startsWith("data:"))
+                    data.push(line.slice(5).trimStart());
+                newline = buffer.indexOf("\n");
+            }
+            if (chunk.done)
+                break;
+        }
+        if (buffer.startsWith("data:"))
+            data.push(buffer.slice(5).trimStart());
+        const event = emit();
+        if (event) {
+            if (typeof event === "object" && event !== null && "done" in event)
+                ended = true;
+            yield event;
+        }
+        if (!ended)
+            throw providerError({ code: "stream_incomplete", message: "response stream ended without [DONE]" }, context);
+    }
+    finally {
+        try {
+            await streamReader.cancel();
+        }
+        catch {
+            // The stream may already be closed by the fetch implementation.
+        }
+        streamReader.releaseLock();
+    }
+}
 export class CodexLbClient {
     config;
-    client;
     apiKey;
     constructor(config) {
         this.config = config;
         this.apiKey = process.env[config.gateway.apiKeyEnv] || "local-looking-glass";
-        this.client = new OpenAI({
-            apiKey: this.apiKey,
-            baseURL: config.gateway.baseURL,
-            maxRetries: 0,
-            timeout: config.gateway.timeoutMs,
-        });
     }
     supportsResponseContinuity() {
         return this.config.gateway.provider === "codex-lb";
     }
-    safeErrorMessage(message) {
-        return redactSensitiveText(message, [this.apiKey]);
-    }
     async models(signal) {
+        const provider = this.config.gateway.provider;
+        const timeout = AbortSignal.timeout(this.config.gateway.timeoutMs);
+        const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+        const context = requestContext(provider, "models", this.apiKey, signal, timeout);
         if (this.config.gateway.provider === "lm-studio") {
             try {
-                const timeout = AbortSignal.timeout(this.config.gateway.timeoutMs);
-                const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
                 const response = await fetch(lmStudioModelsURL(this.config.gateway.baseURL), {
                     headers: { authorization: `Bearer ${this.apiKey}` },
                     signal: requestSignal,
                 });
-                if (!response.ok)
-                    throw new Error(`LM Studio model metadata failed with HTTP ${response.status}`);
-                const payload = await response.json();
-                const models = (payload.models ?? [])
-                    .filter((model) => model.type === "llm")
+                const nativeContext = { ...context, operation: "models (native catalog)" };
+                const payload = objectPayload(await readJsonResponse(response, nativeContext), nativeContext, "model catalog returned an invalid payload");
+                const models = (Array.isArray(payload.models) ? payload.models : [])
+                    .filter((model) => model && typeof model === "object" && model.type === "llm" && typeof model.key === "string")
                     .map(lmStudioModelInfo)
                     .sort((left, right) => left.priority - right.priority || left.name.localeCompare(right.name));
                 if (models.length > 0)
@@ -274,47 +584,196 @@ export class CodexLbClient {
                 // Older LM Studio versions and restricted tokens may only expose /v1/models.
             }
         }
-        const page = await this.client.models.list(signal ? { signal } : undefined);
-        return page.data
+        let response;
+        try {
+            response = await fetch(`${this.config.gateway.baseURL.replace(/\/$/, "")}/models`, {
+                headers: { authorization: `Bearer ${this.apiKey}` },
+                signal: requestSignal,
+            });
+        }
+        catch (error) {
+            throw providerError(error, context);
+        }
+        const payload = objectPayload(await readJsonResponse(response, context), context, "model catalog returned an invalid payload");
+        if (payload.data !== undefined && !Array.isArray(payload.data)) {
+            throw providerError({ code: "malformed_response", message: "model catalog data was not an array" }, { ...context, protocol: true });
+        }
+        const models = (payload.data ?? []).filter((model) => model && typeof model === "object" && typeof model.id === "string");
+        if (provider === "openrouter") {
+            return models
+                .map((model) => openRouterModelInfo(model))
+                .sort((left, right) => left.priority - right.priority || left.name.localeCompare(right.name));
+        }
+        return models
             .filter((model) => model.metadata?.supported_in_api !== false)
             .map(modelInfo)
             .sort((left, right) => left.priority - right.priority || left.name.localeCompare(right.name));
     }
-    async stream(request, callbacks = {}) {
-        const params = buildResponseParams(this.config.gateway.provider, request);
+    async openRouterStream(request, callbacks) {
         const timeout = AbortSignal.timeout(this.config.gateway.timeoutMs);
         const signal = request.signal ? AbortSignal.any([request.signal, timeout]) : timeout;
-        const http = await fetch(`${this.config.gateway.baseURL}/responses`, {
-            method: "POST",
-            headers: {
-                authorization: `Bearer ${this.apiKey}`,
-                "content-type": "application/json",
-                accept: "text/event-stream",
-            },
-            body: JSON.stringify({ ...params, stream: true }),
-            signal,
-        });
+        const context = requestContext("openrouter", "stream", this.apiKey, request.signal, timeout);
+        let http;
+        try {
+            http = await fetch(`${this.config.gateway.baseURL.replace(/\/$/, "")}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${this.apiKey}`,
+                    "content-type": "application/json",
+                    accept: "text/event-stream",
+                },
+                body: JSON.stringify({ ...buildOpenRouterParams(request), stream: true, stream_options: { include_usage: true } }),
+                signal,
+            });
+        }
+        catch (error) {
+            throw providerError(error, context);
+        }
         if (!http.ok) {
-            const text = await http.text();
-            let payload = text;
-            try {
-                payload = JSON.parse(text);
-            }
-            catch {
-                // Preserve non-JSON gateway errors as their response text.
+            const text = await boundedResponseText(http, context);
+            throw providerHttpError(http.status, parseJsonBody(text), context);
+        }
+        const outputText = [];
+        const reasoningText = [];
+        const toolCalls = new Map();
+        let id = "";
+        let model = request.model;
+        let usage;
+        callbacks.onEvent?.({ type: "response.created", response: { id: "", status: "in_progress", model, output: [] } });
+        for await (const raw of openRouterEvents(http, context)) {
+            if (!raw || typeof raw !== "object")
+                continue;
+            if (raw.done)
+                break;
+            const event = raw;
+            if (event.error !== undefined)
+                throw providerError(event.error, context);
+            if (typeof event.id === "string")
+                id ||= event.id;
+            if (typeof event.model === "string")
+                model = event.model;
+            if (event.usage && typeof event.usage === "object")
+                usage = event.usage;
+            const choices = Array.isArray(event.choices) ? event.choices : [];
+            for (const choice of choices) {
+                if (!choice || typeof choice !== "object")
+                    continue;
+                const delta = choice.delta;
+                if (!delta || typeof delta !== "object")
+                    continue;
+                const item = delta;
+                const text = typeof item.content === "string" ? item.content : "";
+                if (text) {
+                    outputText.push(text);
+                    callbacks.onTextDelta?.(text);
+                    callbacks.onEvent?.({ type: "response.output_text.delta", delta: text });
+                }
+                const detailReasoning = Array.isArray(item.reasoning_details)
+                    ? item.reasoning_details.map((detail) => detail && typeof detail === "object"
+                        && typeof detail.text === "string"
+                        ? detail.text : "").join("")
+                    : "";
+                const reasoning = typeof item.reasoning === "string" ? item.reasoning
+                    : typeof item.reasoning_content === "string" ? item.reasoning_content : detailReasoning;
+                if (reasoning) {
+                    reasoningText.push(reasoning);
+                    callbacks.onReasoningDelta?.(reasoning);
+                    callbacks.onEvent?.({ type: "response.reasoning_summary_text.delta", delta: reasoning });
+                }
+                if (Array.isArray(item.tool_calls)) {
+                    for (const tool of item.tool_calls) {
+                        if (!tool || typeof tool !== "object")
+                            continue;
+                        const call = tool;
+                        const index = typeof call.index === "number" ? call.index : toolCalls.size;
+                        const fn = call.function && typeof call.function === "object" ? call.function : {};
+                        const current = toolCalls.get(index) ?? { id: "", name: "", arguments: "" };
+                        if (typeof call.id === "string")
+                            current.id = call.id;
+                        if (typeof fn.name === "string")
+                            current.name += fn.name;
+                        if (typeof fn.arguments === "string")
+                            current.arguments += fn.arguments;
+                        toolCalls.set(index, current);
+                        if (typeof fn.arguments === "string")
+                            callbacks.onEvent?.({
+                                type: "response.function_call_arguments.delta", delta: fn.arguments,
+                            });
+                    }
+                }
             }
-            const detail = detailFrom(payload);
-            const message = this.safeErrorMessage(detail.message ?? (text || `Response failed with HTTP ${http.status}`));
-            throw Object.assign(new Error(message), detail, {
-                status: http.status,
+        }
+        id ||= `chatcmpl_${Date.now().toString(36)}`;
+        const output = [];
+        if (reasoningText.length > 0)
+            output.push({
+                id: `reasoning_${id}`, type: "reasoning", status: "completed", summary: [{ type: "summary_text", text: reasoningText.join("") }], content: [],
+            });
+        if (outputText.length > 0)
+            output.push({
+                id: `msg_${id}`, type: "message", role: "assistant", status: "completed",
+                content: [{ type: "output_text", text: outputText.join(""), annotations: [], logprobs: [] }],
+            });
+        const callOutputIndices = new Map();
+        for (const [index, call] of [...toolCalls.entries()].sort(([left], [right]) => left - right)) {
+            callOutputIndices.set(index, output.length);
+            output.push({ id: call.id || `call_${id}_${index}`, type: "function_call", call_id: call.id || `call_${id}_${index}`, name: call.name, arguments: call.arguments, status: "completed" });
+        }
+        if (output.length === 0)
+            throw providerError({ code: "malformed_response", message: "response contained no output" }, { ...context, protocol: true });
+        for (const [index, item] of output.entries())
+            callbacks.onEvent?.({ type: "response.output_item.done", output_index: index, item });
+        for (const [index, call] of [...toolCalls.entries()].sort(([left], [right]) => left - right)) {
+            callbacks.onEvent?.({
+                type: "response.function_call_arguments.done", output_index: callOutputIndices.get(index), arguments: call.arguments,
+            });
+        }
+        const response = {
+            id, object: "response", created: Math.floor(Date.now() / 1000), model, status: "completed", output,
+            output_text: outputText.join(""),
+            ...(usage ? { usage: {
+                    input_tokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
+                    output_tokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
+                    total_tokens: typeof usage.total_tokens === "number" ? usage.total_tokens
+                        : (typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0)
+                            + (typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0),
+                } } : {}),
+        };
+        callbacks.onEvent?.({ type: "response.completed", response });
+        return response;
+    }
+    async stream(request, callbacks = {}) {
+        if (this.config.gateway.provider === "openrouter")
+            return this.openRouterStream(request, callbacks);
+        const params = buildResponseParams(this.config.gateway.provider, request);
+        const timeout = AbortSignal.timeout(this.config.gateway.timeoutMs);
+        const signal = request.signal ? AbortSignal.any([request.signal, timeout]) : timeout;
+        const context = requestContext(this.config.gateway.provider, "stream", this.apiKey, request.signal, timeout);
+        let http;
+        try {
+            http = await fetch(`${this.config.gateway.baseURL}/responses`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${this.apiKey}`,
+                    "content-type": "application/json",
+                    accept: "text/event-stream",
+                },
+                body: JSON.stringify({ ...params, stream: true }),
+                signal,
             });
         }
+        catch (error) {
+            throw providerError(error, context);
+        }
+        if (!http.ok) {
+            throw providerHttpError(http.status, parseJsonBody(await boundedResponseText(http, context)), context);
+        }
         let created = {};
         let terminal = null;
         let streamedError = null;
         let sawTerminal = false;
         const output = new Map();
-        for await (const event of responseEvents(http)) {
+        for await (const event of responseEvents(http, context)) {
             callbacks.onEvent?.(event);
             if (event.type === "response.output_text.delta" && typeof event.delta === "string") {
                 callbacks.onTextDelta?.(event.delta);
@@ -342,10 +801,9 @@ export class CodexLbClient {
         }
         if (!sawTerminal) {
             if (streamedError) {
-                const detail = detailFrom(streamedError);
-                throw Object.assign(new Error(this.safeErrorMessage(detail.message ?? "Response stream failed")), detail);
+                throw providerError(streamedError, context);
             }
-            throw Object.assign(new Error("Response stream ended without a terminal event"), { code: "stream_incomplete" });
+            throw providerError({ code: "stream_incomplete", message: "response stream ended without a terminal event" }, context);
         }
         const combined = { ...created, ...(terminal ?? {}) };
         const terminalOutput = Array.isArray(combined.output) ? combined.output : [];
@@ -356,12 +814,15 @@ export class CodexLbClient {
             ? combined.status
             : streamedError ? "failed" : "completed";
         if (streamedError || status === "failed" || status === "incomplete") {
-            const detail = detailFrom(streamedError ?? combined.error ?? combined.incomplete_details);
-            throw Object.assign(new Error(this.safeErrorMessage(detail.message ?? `Response ${status}`)), detail, { responseStatus: status });
+            throw providerError(streamedError ?? combined.error ?? combined.incomplete_details ?? { message: `Response ${status}` }, {
+                ...context,
+                responseStatus: status,
+            });
         }
         if (typeof combined.id !== "string" || !combined.id || canonicalOutput.length === 0) {
-            throw Object.assign(new Error("Response stream returned an invalid completed response"), {
-                code: "malformed_response",
+            throw providerError({ code: "malformed_response", message: "response stream returned an invalid completed response" }, {
+                ...context,
+                protocol: true,
             });
         }
         const canonical = {
@@ -375,10 +836,68 @@ export class CodexLbClient {
         return this.config.gateway.provider === "lm-studio" ? redactLmStudioReasoning(canonical) : canonical;
     }
     async compact(request) {
+        if (this.config.gateway.provider === "openrouter") {
+            const transcript = compactTranscript(request.input);
+            if (!transcript)
+                throw providerError({ code: "malformed_response", message: "compaction received no semantic transcript" }, {
+                    ...requestContext("openrouter", "compact", this.apiKey, request.signal), protocol: true,
+                });
+            const timeout = AbortSignal.timeout(this.config.gateway.timeoutMs);
+            const signal = request.signal ? AbortSignal.any([request.signal, timeout]) : timeout;
+            const context = requestContext("openrouter", "compact", this.apiKey, request.signal, timeout);
+            let http;
+            try {
+                http = await fetch(`${this.config.gateway.baseURL.replace(/\/$/, "")}/chat/completions`, {
+                    method: "POST",
+                    headers: { authorization: `Bearer ${this.apiKey}`, "content-type": "application/json" },
+                    body: JSON.stringify({
+                        model: request.model,
+                        messages: openRouterMessages([
+                            request.instructions,
+                            "Create a dense, durable checkpoint of the supplied conversation.",
+                            "Preserve user requirements, decisions, relevant facts, file paths, code changes, tool outcomes, unresolved work, and safety constraints.",
+                            "Do not continue the task, call tools, or add commentary. Return only the checkpoint text.",
+                        ].filter((part) => part.trim()).join(" "), [{ role: "user", content: [{ type: "input_text", text: `Conversation transcript:\n\n${transcript}` }] }]),
+                        stream: false,
+                    }),
+                    signal,
+                });
+            }
+            catch (error) {
+                throw providerError(error, context);
+            }
+            const payload = objectPayload(await readJsonResponse(http, context), context, "compaction returned an invalid payload");
+            const choices = Array.isArray(payload.choices) ? payload.choices : [];
+            const first = choices[0] && typeof choices[0] === "object" ? choices[0] : {};
+            const message = first.message && typeof first.message === "object" ? first.message : {};
+            const summaryValue = typeof message.content === "string" ? message.content : chatContent(message.content);
+            const summary = typeof summaryValue === "string"
+                ? summaryValue.trim()
+                : Array.isArray(summaryValue)
+                    ? summaryValue.map((part) => part && typeof part === "object" && typeof part.text === "string"
+                        ? part.text : "").join("\n").trim()
+                    : "";
+            if (!summary)
+                throw providerError({ code: "malformed_response", message: "compaction returned no checkpoint text" }, { ...context, protocol: true });
+            const id = typeof payload.id === "string" ? payload.id : `compact_${Date.now().toString(36)}`;
+            const usage = normalizedUsage(payload.usage);
+            return {
+                id: `compact_${id}`,
+                object: "response.compaction",
+                output: [{
+                        id: `msg_compact_${id}`, type: "message", role: "user", status: "completed",
+                        content: [{ type: "input_text", text: `Conversation checkpoint generated by Looking Glass:\n${summary}` }],
+                    }],
+                ...(usage ? { usage } : {}),
+            };
+        }
         if (this.config.gateway.provider === "lm-studio") {
             const transcript = compactTranscript(request.input);
+            const compactContext = requestContext("lm-studio", "compact", this.apiKey, request.signal);
             if (!transcript)
-                throw new Error("LM Studio compaction received no semantic transcript");
+                throw providerError({ code: "malformed_response", message: "compaction received no semantic transcript" }, {
+                    ...compactContext, protocol: true,
+                });
             const profile = {
                 model: request.model,
                 instructions: [
@@ -397,14 +916,44 @@ export class CodexLbClient {
                 promptCacheKey: request.promptCacheKey,
                 reasoningEffort: "none",
                 supportsReasoning: true,
+                supportsParallelToolCalls: false,
                 verbosity: "high",
                 fast: false,
                 ...(request.signal ? { signal: request.signal } : {}),
             };
-            const response = await this.client.responses.create(buildResponseParams("lm-studio", profile), request.signal ? { signal: request.signal } : undefined);
+            const timeout = AbortSignal.timeout(this.config.gateway.timeoutMs);
+            const signal = request.signal ? AbortSignal.any([request.signal, timeout]) : timeout;
+            const context = requestContext("lm-studio", "compact", this.apiKey, request.signal, timeout);
+            let http;
+            try {
+                http = await fetch(`${this.config.gateway.baseURL.replace(/\/$/, "")}/responses`, {
+                    method: "POST",
+                    headers: {
+                        authorization: `Bearer ${this.apiKey}`,
+                        "content-type": "application/json",
+                    },
+                    body: JSON.stringify(buildResponseParams("lm-studio", profile)),
+                    signal,
+                });
+            }
+            catch (error) {
+                throw providerError(error, context);
+            }
+            const payload = await readJsonResponse(http, context);
+            if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+                throw providerError({ code: "malformed_response", message: "compaction returned an invalid payload" }, { ...context, protocol: true });
+            }
+            const response = payload;
+            if (!Array.isArray(response.output)) {
+                throw providerError({ code: "malformed_response", message: "compaction response did not contain output items" }, {
+                    ...context, protocol: true,
+                });
+            }
             const summary = responseText(response).trim();
             if (!summary)
-                throw new Error("LM Studio compaction returned no checkpoint text");
+                throw providerError({ code: "malformed_response", message: "compaction returned no checkpoint text" }, {
+                    ...context, protocol: true,
+                });
             return {
                 id: `compact_${response.id}`,
                 object: "response.compaction",
@@ -430,29 +979,30 @@ export class CodexLbClient {
         };
         const timeout = AbortSignal.timeout(this.config.gateway.timeoutMs);
         const signal = request.signal ? AbortSignal.any([request.signal, timeout]) : timeout;
-        const response = await fetch(`${this.config.gateway.baseURL}/responses/compact`, {
-            method: "POST",
-            headers: {
-                authorization: `Bearer ${this.apiKey}`,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify(body),
-            signal,
-        });
-        const payload = await response.json();
-        if (!response.ok) {
-            const detail = detailFrom(payload);
-            throw Object.assign(new Error(this.safeErrorMessage(detail.message ?? `Compaction failed with HTTP ${response.status}`)), detail, {
-                status: response.status,
+        const context = requestContext(this.config.gateway.provider, "compact", this.apiKey, request.signal, timeout);
+        let response;
+        try {
+            response = await fetch(`${this.config.gateway.baseURL}/responses/compact`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${this.apiKey}`,
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal,
             });
         }
+        catch (error) {
+            throw providerError(error, context);
+        }
+        const payload = await readJsonResponse(response, context);
         if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-            throw new Error("Compaction returned an invalid payload");
+            throw providerError({ code: "malformed_response", message: "compaction returned an invalid payload" }, { ...context, protocol: true });
         }
         const output = payload.output;
         if (!Array.isArray(output) || output.length === 0
             || output.some((item) => !item || typeof item !== "object" || Array.isArray(item))) {
-            throw new Error("Compaction response did not contain valid output items");
+            throw providerError({ code: "malformed_response", message: "compaction response did not contain valid output items" }, { ...context, protocol: true });
         }
         return payload;
     }