@psnext/slingcli 2.4.20260507-3 → 2.4.20260509-1

package/node_modules/@earendil-works/pi-ai/dist/providers/images/openrouter.js

@@ -0,0 +1,129 @@
+import OpenAI from "openai";
+import { getEnvApiKey } from "../../env-api-keys.js";
+import { headersToRecord } from "../../utils/headers.js";
+import { sanitizeSurrogates } from "../../utils/sanitize-unicode.js";
+export const generateImagesOpenRouter = async (model, context, options) => {
+    const output = {
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        output: [],
+        stopReason: "stop",
+        timestamp: Date.now(),
+    };
+    try {
+        const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+        if (!apiKey) {
+            throw new Error(`No API key available for provider: ${model.provider}`);
+        }
+        const client = createClient(model, apiKey, options?.headers);
+        let params = buildParams(model, context);
+        const nextParams = await options?.onPayload?.(params, model);
+        if (nextParams !== undefined) {
+            params = nextParams;
+        }
+        const requestOptions = {
+            ...(options?.signal ? { signal: options.signal } : {}),
+            ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+            ...(options?.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {}),
+        };
+        const { data: response, response: rawResponse } = await client.chat.completions
+            .create(params, requestOptions)
+            .withResponse();
+        await options?.onResponse?.({ status: rawResponse.status, headers: headersToRecord(rawResponse.headers) }, model);
+        const imageResponse = response;
+        output.responseId = imageResponse.id;
+        if (imageResponse.usage) {
+            output.usage = parseUsage(imageResponse.usage, model);
+        }
+        const choice = imageResponse.choices[0];
+        if (choice) {
+            const content = choice.message.content;
+            if (typeof content === "string" && content.length > 0) {
+                output.output.push({ type: "text", text: content });
+            }
+            for (const image of choice.message.images ?? []) {
+                const imageUrl = typeof image.image_url === "string" ? image.image_url : image.image_url?.url;
+                if (!imageUrl?.startsWith("data:"))
+                    continue;
+                const matches = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
+                if (!matches)
+                    continue;
+                output.output.push({
+                    type: "image",
+                    mimeType: matches[1],
+                    data: matches[2],
+                });
+            }
+        }
+        return output;
+    }
+    catch (error) {
+        output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+        output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+        return output;
+    }
+};
+function createClient(model, apiKey, optionsHeaders) {
+    return new OpenAI({
+        apiKey,
+        baseURL: model.baseUrl,
+        dangerouslyAllowBrowser: true,
+        defaultHeaders: {
+            ...model.headers,
+            ...optionsHeaders,
+        },
+    });
+}
+function buildParams(model, context) {
+    const content = context.input.map((item) => {
+        if (item.type === "text") {
+            return {
+                type: "text",
+                text: sanitizeSurrogates(item.text),
+            };
+        }
+        return {
+            type: "image_url",
+            image_url: {
+                url: `data:${item.mimeType};base64,${item.data}`,
+            },
+        };
+    });
+    return {
+        model: model.id,
+        messages: [
+            {
+                role: "user",
+                content,
+            },
+        ],
+        stream: false,
+        modalities: model.output.includes("text") ? ["image", "text"] : ["image"],
+    };
+}
+function parseUsage(rawUsage, model) {
+    const promptTokens = rawUsage.prompt_tokens || 0;
+    const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
+    const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
+    const cacheReadTokens = cacheWriteTokens > 0 ? Math.max(0, reportedCachedTokens - cacheWriteTokens) : reportedCachedTokens;
+    const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
+    const output = rawUsage.completion_tokens || 0;
+    const usage = {
+        input,
+        output,
+        cacheRead: cacheReadTokens,
+        cacheWrite: cacheWriteTokens,
+        totalTokens: input + output + cacheReadTokens + cacheWriteTokens,
+        cost: {
+            input: (model.cost.input / 1000000) * input,
+            output: (model.cost.output / 1000000) * output,
+            cacheRead: (model.cost.cacheRead / 1000000) * cacheReadTokens,
+            cacheWrite: (model.cost.cacheWrite / 1000000) * cacheWriteTokens,
+            total: 0,
+        },
+    };
+    usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+    return usage;
+}
+//# sourceMappingURL=openrouter.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/images/register-builtins.js

@@ -0,0 +1,34 @@
+import { registerImagesApiProvider } from "../../images-api-registry.js";
+let openRouterImagesProviderModulePromise;
+function createLazyLoadErrorImages(model, error) {
+    return {
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        output: [],
+        stopReason: "error",
+        errorMessage: error instanceof Error ? error.message : String(error),
+        timestamp: Date.now(),
+    };
+}
+function loadOpenRouterImagesProviderModule() {
+    openRouterImagesProviderModulePromise ||= import("./openrouter.js").then((module) => module);
+    return openRouterImagesProviderModulePromise;
+}
+export const generateImagesOpenRouter = async (model, context, options) => {
+    try {
+        const module = await loadOpenRouterImagesProviderModule();
+        return await module.generateImagesOpenRouter(model, context, options);
+    }
+    catch (error) {
+        return createLazyLoadErrorImages(model, error);
+    }
+};
+export function registerBuiltInImagesApiProviders() {
+    registerImagesApiProvider({
+        api: "openrouter-images",
+        generateImages: generateImagesOpenRouter,
+    });
+}
+registerBuiltInImagesApiProviders();
+//# sourceMappingURL=register-builtins.js.map

package/node_modules/{@mariozechner → @earendil-works}/pi-ai/dist/providers/openai-codex-responses.js

@@ -232,7 +232,7 @@ function buildRequestBody(model, context, options) {
         model: model.id,
         store: false,
         stream: true,
-        instructions: context.systemPrompt,
+        instructions: context.systemPrompt || "You are a helpful assistant.",
         input: messages,
         text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],

package/node_modules/{@mariozechner/pi-agent-core/node_modules/@mariozechner → @earendil-works}/pi-ai/dist/providers/openai-completions.js

@@ -89,46 +89,103 @@ export const streamOpenAICompletions = (model, context, options) => {
                 .withResponse();
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
-            let currentBlock = null;
+            let textBlock = null;
+            let thinkingBlock = null;
+            const toolCallBlocksByIndex = new Map();
+            const toolCallBlocksById = new Map();
             const blocks = output.content;
-            const getContentIndex = (block) => (block ? blocks.indexOf(block) : -1);
-            const currentContentIndex = () => getContentIndex(currentBlock);
-            const finishCurrentBlock = (block) => {
-                if (block) {
-                    const contentIndex = getContentIndex(block);
-                    if (contentIndex === -1) {
-                        return;
-                    }
-                    if (block.type === "text") {
-                        stream.push({
-                            type: "text_end",
-                            contentIndex,
-                            content: block.text,
-                            partial: output,
-                        });
-                    }
-                    else if (block.type === "thinking") {
-                        stream.push({
-                            type: "thinking_end",
-                            contentIndex,
-                            content: block.thinking,
-                            partial: output,
-                        });
+            const getContentIndex = (block) => blocks.indexOf(block);
+            const finishBlock = (block) => {
+                const contentIndex = getContentIndex(block);
+                if (contentIndex === -1) {
+                    return;
+                }
+                if (block.type === "text") {
+                    stream.push({
+                        type: "text_end",
+                        contentIndex,
+                        content: block.text,
+                        partial: output,
+                    });
+                }
+                else if (block.type === "thinking") {
+                    stream.push({
+                        type: "thinking_end",
+                        contentIndex,
+                        content: block.thinking,
+                        partial: output,
+                    });
+                }
+                else if (block.type === "toolCall") {
+                    block.arguments = parseStreamingJson(block.partialArgs);
+                    // Finalize in-place and strip the scratch buffers so replay only
+                    // carries parsed arguments.
+                    delete block.partialArgs;
+                    delete block.streamIndex;
+                    stream.push({
+                        type: "toolcall_end",
+                        contentIndex,
+                        toolCall: block,
+                        partial: output,
+                    });
+                }
+            };
+            const ensureTextBlock = () => {
+                if (!textBlock) {
+                    textBlock = { type: "text", text: "" };
+                    blocks.push(textBlock);
+                    stream.push({ type: "text_start", contentIndex: getContentIndex(textBlock), partial: output });
+                }
+                return textBlock;
+            };
+            const ensureThinkingBlock = (thinkingSignature) => {
+                if (!thinkingBlock) {
+                    thinkingBlock = {
+                        type: "thinking",
+                        thinking: "",
+                        thinkingSignature,
+                    };
+                    blocks.push(thinkingBlock);
+                    stream.push({ type: "thinking_start", contentIndex: getContentIndex(thinkingBlock), partial: output });
+                }
+                return thinkingBlock;
+            };
+            const ensureToolCallBlock = (toolCall) => {
+                const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;
+                let block = streamIndex !== undefined ? toolCallBlocksByIndex.get(streamIndex) : undefined;
+                if (!block && toolCall.id) {
+                    block = toolCallBlocksById.get(toolCall.id);
+                }
+                if (!block) {
+                    block = {
+                        type: "toolCall",
+                        id: toolCall.id || "",
+                        name: toolCall.function?.name || "",
+                        arguments: {},
+                        partialArgs: "",
+                        streamIndex,
+                    };
+                    if (streamIndex !== undefined) {
+                        toolCallBlocksByIndex.set(streamIndex, block);
                     }
-                    else if (block.type === "toolCall") {
-                        block.arguments = parseStreamingJson(block.partialArgs);
-                        // Finalize in-place and strip the scratch buffers so replay only
-                        // carries parsed arguments.
-                        delete block.partialArgs;
-                        delete block.streamIndex;
-                        stream.push({
-                            type: "toolcall_end",
-                            contentIndex,
-                            toolCall: block,
-                            partial: output,
-                        });
+                    if (toolCall.id) {
+                        toolCallBlocksById.set(toolCall.id, block);
                     }
+                    blocks.push(block);
+                    stream.push({
+                        type: "toolcall_start",
+                        contentIndex: getContentIndex(block),
+                        partial: output,
+                    });
+                }
+                if (streamIndex !== undefined && block.streamIndex === undefined) {
+                    block.streamIndex = streamIndex;
+                    toolCallBlocksByIndex.set(streamIndex, block);
+                }
+                if (toolCall.id) {
+                    toolCallBlocksById.set(toolCall.id, block);
                 }
+                return block;
             };
             for await (const chunk of openaiStream) {
                 if (!chunk || typeof chunk !== "object")
@@ -161,55 +218,37 @@ export const streamOpenAICompletions = (model, context, options) => {
                     if (choice.delta.content !== null &&
                         choice.delta.content !== undefined &&
                         choice.delta.content.length > 0) {
-                        if (!currentBlock || currentBlock.type !== "text") {
-                            finishCurrentBlock(currentBlock);
-                            currentBlock = { type: "text", text: "" };
-                            output.content.push(currentBlock);
-                            stream.push({ type: "text_start", contentIndex: currentContentIndex(), partial: output });
-                        }
-                        if (currentBlock.type === "text") {
-                            currentBlock.text += choice.delta.content;
-                            stream.push({
-                                type: "text_delta",
-                                contentIndex: currentContentIndex(),
-                                delta: choice.delta.content,
-                                partial: output,
-                            });
-                        }
+                        const block = ensureTextBlock();
+                        block.text += choice.delta.content;
+                        stream.push({
+                            type: "text_delta",
+                            contentIndex: getContentIndex(block),
+                            delta: choice.delta.content,
+                            partial: output,
+                        });
                     }
                     // Some endpoints return reasoning in reasoning_content (llama.cpp),
                     // or reasoning (other openai compatible endpoints)
                     // Use the first non-empty reasoning field to avoid duplication
                     // (e.g., chutes.ai returns both reasoning_content and reasoning with same content)
                     const reasoningFields = ["reasoning_content", "reasoning", "reasoning_text"];
+                    const deltaFields = choice.delta;
                     let foundReasoningField = null;
                     for (const field of reasoningFields) {
-                        if (choice.delta[field] !== null &&
-                            choice.delta[field] !== undefined &&
-                            choice.delta[field].length > 0) {
-                            if (!foundReasoningField) {
-                                foundReasoningField = field;
-                                break;
-                            }
+                        const value = deltaFields[field];
+                        if (typeof value === "string" && value.length > 0) {
+                            foundReasoningField = field;
+                            break;
                         }
                     }
                     if (foundReasoningField) {
-                        if (!currentBlock || currentBlock.type !== "thinking") {
-                            finishCurrentBlock(currentBlock);
-                            currentBlock = {
-                                type: "thinking",
-                                thinking: "",
-                                thinkingSignature: foundReasoningField,
-                            };
-                            output.content.push(currentBlock);
-                            stream.push({ type: "thinking_start", contentIndex: currentContentIndex(), partial: output });
-                        }
-                        if (currentBlock.type === "thinking") {
-                            const delta = choice.delta[foundReasoningField];
-                            currentBlock.thinking += delta;
+                        const delta = deltaFields[foundReasoningField];
+                        if (typeof delta === "string" && delta.length > 0) {
+                            const block = ensureThinkingBlock(foundReasoningField);
+                            block.thinking += delta;
                             stream.push({
                                 type: "thinking_delta",
-                                contentIndex: currentContentIndex(),
+                                contentIndex: getContentIndex(block),
                                 delta,
                                 partial: output,
                             });
@@ -217,50 +256,26 @@ export const streamOpenAICompletions = (model, context, options) => {
                     }
                     if (choice?.delta?.tool_calls) {
                         for (const toolCall of choice.delta.tool_calls) {
-                            const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;
-                            const sameToolCall = currentBlock?.type === "toolCall" &&
-                                ((streamIndex !== undefined && currentBlock.streamIndex === streamIndex) ||
-                                    (streamIndex === undefined && toolCall.id && currentBlock.id === toolCall.id));
-                            if (!sameToolCall) {
-                                finishCurrentBlock(currentBlock);
-                                currentBlock = {
-                                    type: "toolCall",
-                                    id: toolCall.id || "",
-                                    name: toolCall.function?.name || "",
-                                    arguments: {},
-                                    partialArgs: "",
-                                    streamIndex,
-                                };
-                                output.content.push(currentBlock);
-                                stream.push({
-                                    type: "toolcall_start",
-                                    contentIndex: getContentIndex(currentBlock),
-                                    partial: output,
-                                });
+                            const block = ensureToolCallBlock(toolCall);
+                            if (!block.id && toolCall.id) {
+                                block.id = toolCall.id;
+                                toolCallBlocksById.set(toolCall.id, block);
                             }
-                            const currentToolCallBlock = currentBlock?.type === "toolCall" ? currentBlock : null;
-                            if (currentToolCallBlock) {
-                                if (!currentToolCallBlock.id && toolCall.id)
-                                    currentToolCallBlock.id = toolCall.id;
-                                if (!currentToolCallBlock.name && toolCall.function?.name) {
-                                    currentToolCallBlock.name = toolCall.function.name;
-                                }
-                                if (currentToolCallBlock.streamIndex === undefined && streamIndex !== undefined) {
-                                    currentToolCallBlock.streamIndex = streamIndex;
-                                }
-                                let delta = "";
-                                if (toolCall.function?.arguments) {
-                                    delta = toolCall.function.arguments;
-                                    currentToolCallBlock.partialArgs += toolCall.function.arguments;
-                                    currentToolCallBlock.arguments = parseStreamingJson(currentToolCallBlock.partialArgs);
-                                }
-                                stream.push({
-                                    type: "toolcall_delta",
-                                    contentIndex: getContentIndex(currentToolCallBlock),
-                                    delta,
-                                    partial: output,
-                                });
+                            if (!block.name && toolCall.function?.name) {
+                                block.name = toolCall.function.name;
+                            }
+                            let delta = "";
+                            if (toolCall.function?.arguments) {
+                                delta = toolCall.function.arguments;
+                                block.partialArgs = (block.partialArgs ?? "") + toolCall.function.arguments;
+                                block.arguments = parseStreamingJson(block.partialArgs);
                             }
+                            stream.push({
+                                type: "toolcall_delta",
+                                contentIndex: getContentIndex(block),
+                                delta,
+                                partial: output,
+                            });
                         }
                     }
                     const reasoningDetails = choice.delta.reasoning_details;
@@ -276,7 +291,9 @@ export const streamOpenAICompletions = (model, context, options) => {
                     }
                 }
             }
-            finishCurrentBlock(currentBlock);
+            for (const block of blocks) {
+                finishBlock(block);
+            }
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
@@ -439,6 +456,13 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
             openRouterParams.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
         }
     }
+    else if (compat.thinkingFormat === "together" && model.reasoning) {
+        const togetherParams = params;
+        togetherParams.reasoning = { enabled: !!options?.reasoningEffort };
+        if (options?.reasoningEffort && compat.supportsReasoningEffort) {
+            togetherParams.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+        }
+    }
     else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
         // OpenAI-style reasoning_effort
         params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
@@ -831,6 +855,7 @@ function detectCompat(model) {
     const provider = model.provider;
     const baseUrl = model.baseUrl;
     const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
+    const isTogether = provider === "together" || baseUrl.includes("api.together.ai") || baseUrl.includes("api.together.xyz");
     const isMoonshot = provider === "moonshotai" || provider === "moonshotai-cn" || baseUrl.includes("api.moonshot.");
     const isCloudflareWorkersAI = provider === "cloudflare-workers-ai" || baseUrl.includes("api.cloudflare.com");
     const isCloudflareAiGateway = provider === "cloudflare-ai-gateway" || baseUrl.includes("gateway.ai.cloudflare.com");
@@ -838,6 +863,7 @@ function detectCompat(model) {
         baseUrl.includes("cerebras.ai") ||
         provider === "xai" ||
         baseUrl.includes("api.x.ai") ||
+        isTogether ||
         baseUrl.includes("chutes.ai") ||
         baseUrl.includes("deepseek.com") ||
         isZai ||
@@ -846,14 +872,14 @@ function detectCompat(model) {
         baseUrl.includes("opencode.ai") ||
         isCloudflareWorkersAI ||
         isCloudflareAiGateway;
-    const useMaxTokens = baseUrl.includes("chutes.ai") || isMoonshot || isCloudflareAiGateway;
+    const useMaxTokens = baseUrl.includes("chutes.ai") || isMoonshot || isCloudflareAiGateway || isTogether;
     const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
     const isDeepSeek = provider === "deepseek" || baseUrl.includes("deepseek.com");
     const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : undefined;
     return {
         supportsStore: !isNonStandard,
         supportsDeveloperRole: !isNonStandard,
-        supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isCloudflareAiGateway,
+        supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isTogether && !isCloudflareAiGateway,
         supportsUsageInStreaming: true,
         maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
         requiresToolResultName: false,
@@ -864,16 +890,18 @@ function detectCompat(model) {
             ? "deepseek"
             : isZai
                 ? "zai"
-                : provider === "openrouter" || baseUrl.includes("openrouter.ai")
-                    ? "openrouter"
-                    : "openai",
+                : isTogether
+                    ? "together"
+                    : provider === "openrouter" || baseUrl.includes("openrouter.ai")
+                        ? "openrouter"
+                        : "openai",
         openRouterRouting: {},
         vercelGatewayRouting: {},
         zaiToolStream: false,
-        supportsStrictMode: !isMoonshot && !isCloudflareAiGateway,
+        supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway,
         cacheControlFormat,
         sendSessionAffinityHeaders: false,
-        supportsLongCacheRetention: !(isCloudflareWorkersAI || isCloudflareAiGateway),
+        supportsLongCacheRetention: !(isTogether || isCloudflareWorkersAI || isCloudflareAiGateway),
     };
 }
 /**

package/node_modules/{@mariozechner → @earendil-works}/pi-ai/dist/providers/openai-responses-shared.js

@@ -287,6 +287,17 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 }
             }
         }
+        else if (event.type === "response.reasoning_text.delta") {
+            if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
+                currentBlock.thinking += event.delta;
+                stream.push({
+                    type: "thinking_delta",
+                    contentIndex: blockIndex(),
+                    delta: event.delta,
+                    partial: output,
+                });
+            }
+        }
         else if (event.type === "response.content_part.added") {
             if (currentItem?.type === "message") {
                 currentItem.content = currentItem.content || [];
@@ -365,7 +376,9 @@ export async function processResponsesStream(openaiStream, output, stream, model
         else if (event.type === "response.output_item.done") {
             const item = event.item;
             if (item.type === "reasoning" && currentBlock?.type === "thinking") {
-                currentBlock.thinking = item.summary?.map((s) => s.text).join("\n\n") || "";
+                const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";
+                const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
+                currentBlock.thinking = summaryText || contentText || currentBlock.thinking;
                 currentBlock.thinkingSignature = JSON.stringify(item);
                 stream.push({
                     type: "thinking_end",

package/node_modules/{@mariozechner → @earendil-works}/pi-ai/dist/utils/oauth/openai-codex.js

@@ -84,13 +84,18 @@ async function exchangeAuthorizationCode(code, verifier, redirectUri = REDIRECT_
     });
     if (!response.ok) {
         const text = await response.text().catch(() => "");
-        console.error("[openai-codex] code->token failed:", response.status, text);
-        return { type: "failed" };
+        return {
+            type: "failed",
+            status: response.status,
+            message: `OpenAI Codex token exchange failed (${response.status}): ${text || response.statusText}`,
+        };
     }
     const json = (await response.json());
     if (!json.access_token || !json.refresh_token || typeof json.expires_in !== "number") {
-        console.error("[openai-codex] token response missing fields:", json);
-        return { type: "failed" };
+        return {
+            type: "failed",
+            message: `OpenAI Codex token exchange response missing fields: ${JSON.stringify(json)}`,
+        };
     }
     return {
         type: "success",
@@ -112,13 +117,18 @@ async function refreshAccessToken(refreshToken) {
         });
         if (!response.ok) {
             const text = await response.text().catch(() => "");
-            console.error("[openai-codex] Token refresh failed:", response.status, text);
-            return { type: "failed" };
+            return {
+                type: "failed",
+                status: response.status,
+                message: `OpenAI Codex token refresh failed (${response.status}): ${text || response.statusText}`,
+            };
         }
         const json = (await response.json());
         if (!json.access_token || !json.refresh_token || typeof json.expires_in !== "number") {
-            console.error("[openai-codex] Token refresh response missing fields:", json);
-            return { type: "failed" };
+            return {
+                type: "failed",
+                message: `OpenAI Codex token refresh response missing fields: ${JSON.stringify(json)}`,
+            };
         }
         return {
             type: "success",
@@ -128,8 +138,10 @@ async function refreshAccessToken(refreshToken) {
         };
     }
     catch (error) {
-        console.error("[openai-codex] Token refresh error:", error);
-        return { type: "failed" };
+        return {
+            type: "failed",
+            message: `OpenAI Codex token refresh error: ${error instanceof Error ? error.message : String(error)}`,
+        };
     }
 }
 async function createAuthorizationFlow(originator = "pi") {
@@ -206,8 +218,7 @@ function startLocalOAuthServer(state) {
                 waitForCode: () => waitForCodePromise,
             });
         })
-            .on("error", (err) => {
-            console.error(`[openai-codex] Failed to bind http://${CALLBACK_HOST}:1455 (`, err.code, ") Falling back to manual paste.");
+            .on("error", (_err) => {
             settleWait?.(null);
             resolve({
                 close: () => {
@@ -316,7 +327,7 @@ export async function loginOpenAICodex(options) {
         }
         const tokenResult = await exchangeAuthorizationCode(code, verifier);
         if (tokenResult.type !== "success") {
-            throw new Error("Token exchange failed");
+            throw new Error(tokenResult.message);
         }
         const accountId = getAccountId(tokenResult.access);
         if (!accountId) {
@@ -339,7 +350,7 @@ export async function loginOpenAICodex(options) {
 export async function refreshOpenAICodexToken(refreshToken) {
     const result = await refreshAccessToken(refreshToken);
     if (result.type !== "success") {
-        throw new Error("Failed to refresh OpenAI Codex token");
+        throw new Error(result.message);
     }
     const accountId = getAccountId(result.access);
     if (!accountId) {