@psnext/slingcli 2.5.20260710-1 → 2.5.20260718-2

package/node_modules/@earendil-works/pi-ai/dist/api/openai-responses-shared.js

@@ -36,6 +36,7 @@ function parseTextSignature(signature) {
 // =============================================================================
 export function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
     const messages = [];
+    const loadedToolNames = new Set();
     const normalizeIdPart = (part) => {
         const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
         const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
@@ -189,13 +190,39 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
                 output = contentParts;
             }
             else {
-                output = sanitizeSurrogates(hasText ? textResult : "(see attached image)");
+                output = sanitizeSurrogates(hasText ? textResult : hasImages ? "(see attached image)" : "(no tool output)");
             }
             messages.push({
                 type: "function_call_output",
                 call_id: callId,
                 output,
             });
+            const deferredTools = [];
+            for (const name of msg.addedToolNames ?? []) {
+                const tool = options?.deferredTools?.get(name);
+                if (!tool || loadedToolNames.has(name))
+                    continue;
+                loadedToolNames.add(name);
+                deferredTools.push(tool);
+            }
+            if (deferredTools.length > 0) {
+                const names = deferredTools.map((tool) => tool.name);
+                const searchCallId = `pi_tool_load_${shortHash(`${msg.toolCallId}:${names.join(",")}`)}`;
+                messages.push({
+                    type: "tool_search_call",
+                    call_id: searchCallId,
+                    execution: "client",
+                    status: "completed",
+                    arguments: { query: names.join(" "), limit: names.length },
+                });
+                messages.push({
+                    type: "tool_search_output",
+                    call_id: searchCallId,
+                    execution: "client",
+                    status: "completed",
+                    tools: convertResponsesTools(deferredTools, { deferLoading: true }),
+                });
+            }
         }
         msgIndex++;
     }
@@ -212,11 +239,13 @@ export function convertResponsesTools(tools, options) {
         description: tool.description,
         parameters: tool.parameters, // TypeBox already generates JSON Schema
         strict,
+        ...(options?.deferLoading ? { defer_loading: true } : {}),
     }));
 }
 export async function processResponsesStream(openaiStream, output, stream, model, options) {
     let sawTerminalResponseEvent = false;
     const outputSlots = new Map();
+    const reasoningBlocksById = new Map();
     const getSlot = (outputIndex, type) => {
         const slot = outputSlots.get(outputIndex);
         return slot?.type === type ? slot : undefined;
@@ -265,19 +294,42 @@ export async function processResponsesStream(openaiStream, output, stream, model
     const getOrCreateSlot = (outputIndex, item) => {
         return outputSlots.get(outputIndex) ?? createSlot(outputIndex, item);
     };
+    // Azure OpenAI can omit reasoning.encrypted_content from response.output_item.done
+    // and provide it only in response.completed.response.output. Backfill the
+    // persisted reasoning signature from the terminal response to keep store:false
+    // multi-turn replay stateless. See https://github.com/earendil-works/pi/issues/6409.
+    const backfillReasoningSignatures = (responseOutput) => {
+        for (const item of responseOutput) {
+            if (item.type !== "reasoning" || !item.encrypted_content)
+                continue;
+            const block = reasoningBlocksById.get(item.id);
+            if (!block?.thinkingSignature)
+                continue;
+            const storedItem = JSON.parse(block.thinkingSignature);
+            if (storedItem.encrypted_content)
+                continue;
+            block.thinkingSignature = JSON.stringify({
+                ...storedItem,
+                encrypted_content: item.encrypted_content,
+            });
+        }
+    };
     const finalizeResponse = (response) => {
         sawTerminalResponseEvent = true;
+        backfillReasoningSignatures(response.output ?? []);
         if (response?.id) {
             output.responseId = response.id;
         }
         if (response?.usage) {
-            const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
+            const inputDetails = response.usage.input_tokens_details;
+            const cachedTokens = inputDetails?.cached_tokens || 0;
+            const cacheWriteTokens = inputDetails?.cache_write_tokens || 0;
             output.usage = {
-                // OpenAI includes cached tokens in input_tokens, so subtract to get non-cached input
-                input: (response.usage.input_tokens || 0) - cachedTokens,
+                // OpenAI includes cached and cache-write tokens in input_tokens, so subtract both.
+                input: Math.max(0, (response.usage.input_tokens || 0) - cachedTokens - cacheWriteTokens),
                 output: response.usage.output_tokens || 0,
                 cacheRead: cachedTokens,
-                cacheWrite: 0,
+                cacheWrite: cacheWriteTokens,
                 reasoning: response.usage.output_tokens_details?.reasoning_tokens || 0,
                 totalTokens: response.usage.total_tokens || 0,
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
@@ -403,6 +455,7 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
                 slot.block.thinking = summaryText || contentText || slot.block.thinking;
                 slot.block.thinkingSignature = JSON.stringify(item);
+                reasoningBlocksById.set(item.id, slot.block);
                 stream.push({
                     type: "thinking_end",
                     contentIndex: slot.contentIndex,

package/node_modules/@earendil-works/pi-ai/dist/api/openai-responses.js

@@ -1,5 +1,6 @@
 import OpenAI from "openai";
 import { clampThinkingLevel } from "../models.js";
+import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
@@ -9,6 +10,8 @@ import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 const OPENAI_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
+// OpenAI Responses rejects max_output_tokens below 16: https://github.com/earendil-works/pi/issues/6265
+const OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
 function hasHeader(headers, name) {
     if (!headers)
         return false;
@@ -26,6 +29,9 @@ function getClientApiKey(provider, apiKey, headers) {
         return "unused";
     throw new Error(`No API key for provider: ${provider}`);
 }
+function detectSessionAffinityFormat(model) {
+    return model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai") ? "openrouter" : "openai";
+}
 /**
  * Resolve cache retention preference.
  * Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
@@ -42,8 +48,9 @@ function resolveCacheRetention(cacheRetention, env) {
 function getCompat(model) {
     return {
         supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
-        sendSessionIdHeader: model.compat?.sendSessionIdHeader ?? true,
+        sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? detectSessionAffinityFormat(model),
         supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+        supportsToolSearch: model.compat?.supportsToolSearch ?? false,
     };
 }
 function getPromptCacheRetention(compat, cacheRetention) {
@@ -144,10 +151,15 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId) {
         Object.assign(headers, copilotHeaders);
     }
     if (sessionId) {
-        if (compat.sendSessionIdHeader) {
-            headers.session_id = sessionId;
+        if (compat.sessionAffinityFormat === "openrouter") {
+            headers["x-session-id"] = sessionId;
+        }
+        else {
+            if (compat.sessionAffinityFormat === "openai") {
+                headers.session_id = sessionId;
+            }
+            headers["x-client-request-id"] = sessionId;
         }
-        headers["x-client-request-id"] = sessionId;
     }
     // Merge options headers last so they can override defaults
     if (optionsHeaders) {
@@ -161,9 +173,12 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId) {
     });
 }
 function buildParams(model, context, options) {
-    const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS);
-    const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
     const compat = getCompat(model);
+    const toolPlacement = splitDeferredTools(context, compat.supportsToolSearch);
+    const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
+        deferredTools: toolPlacement.deferred,
+    });
+    const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
     const params = {
         model: model.id,
         input: messages,
@@ -173,7 +188,7 @@ function buildParams(model, context, options) {
         store: false,
     };
     if (options?.maxTokens) {
-        params.max_output_tokens = options?.maxTokens;
+        params.max_output_tokens = Math.max(options.maxTokens, OPENAI_RESPONSES_MIN_OUTPUT_TOKENS);
     }
     if (options?.temperature !== undefined) {
         params.temperature = options?.temperature;
@@ -181,8 +196,11 @@ function buildParams(model, context, options) {
     if (options?.serviceTier !== undefined) {
         params.service_tier = options.serviceTier;
     }
-    if (context.tools && context.tools.length > 0) {
-        params.tools = convertResponsesTools(context.tools);
+    if (toolPlacement.immediate.length > 0) {
+        params.tools = convertResponsesTools(toolPlacement.immediate);
+    }
+    if (options?.toolChoice !== undefined) {
+        params.tool_choice = options.toolChoice;
     }
     if (model.reasoning) {
         if (options?.reasoningEffort || options?.reasoningSummary) {
@@ -200,6 +218,8 @@ function buildParams(model, context, options) {
                 effort: (model.thinkingLevelMap?.off ?? "none"),
             };
         }
+        if (model.provider === "xai")
+            params.include = ["reasoning.encrypted_content"];
     }
     return params;
 }

package/node_modules/@earendil-works/pi-ai/dist/api/pi-messages.js

@@ -0,0 +1,309 @@
+/**
+ * pi-messages API implementation.
+ *
+ * Streams pi's own message protocol directly to a backend: the request is a
+ * single POST of `{ model, context, options }` to `<baseUrl>/messages`, the
+ * response is an SSE stream of serialized assistant-message events plus a
+ * terminal `done`/`error` event. This is the wire protocol spoken by the
+ * Radius gateway, but any backend implementing it can be used, e.g. via a
+ * models.json custom provider with `"api": "pi-messages"`.
+ */
+import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic } from "../utils/diagnostics.js";
+import { AssistantMessageEventStream } from "../utils/event-stream.js";
+import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
+import { parseStreamingJson } from "../utils/json-parse.js";
+import { getProviderEnvValue } from "../utils/provider-env.js";
+export class PiMessagesResponseError extends Error {
+    code;
+    diagnosticDetails;
+    constructor(message, code, diagnosticDetails) {
+        super(message);
+        this.name = "PiMessagesResponseError";
+        this.code = code;
+        this.diagnosticDetails = diagnosticDetails;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parsePiMessagesErrorBody(body) {
+    try {
+        const parsed = JSON.parse(body);
+        return isRecord(parsed) && isRecord(parsed.error) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function truncateDiagnosticString(value) {
+    const maxLength = 8192;
+    return value.length > maxLength ? `${value.slice(0, maxLength)}…` : value;
+}
+function formatPiMessagesResponseError(response, body, errorBody) {
+    const message = typeof errorBody?.error?.message === "string" ? errorBody.error.message : undefined;
+    const code = typeof errorBody?.error?.code === "string" ? errorBody.error.code : undefined;
+    const suffix = message ?? body;
+    const codeSuffix = code ? ` (${code})` : "";
+    return `${response.status} ${response.statusText}: ${suffix}${codeSuffix}`;
+}
+function createPiMessagesResponseError(model, url, response, body) {
+    const errorBody = parsePiMessagesErrorBody(body);
+    const code = typeof errorBody?.error?.code === "string" ? errorBody.error.code : undefined;
+    return new PiMessagesResponseError(formatPiMessagesResponseError(response, body, errorBody), code, {
+        version: 1,
+        provider: model.provider,
+        model: model.id,
+        url: url.toString(),
+        status: response.status,
+        statusText: response.statusText,
+        error: errorBody?.error,
+        body: errorBody ? undefined : truncateDiagnosticString(body),
+        timestampMs: Date.now(),
+    });
+}
+function createEmptyUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+function appendRewriteDiagnostic(message, rewrite) {
+    if (!rewrite) {
+        return;
+    }
+    appendAssistantMessageDiagnostic(message, {
+        type: "pi_messages_rewrite",
+        timestamp: Date.now(),
+        details: { ...rewrite },
+    });
+}
+function createEventConverter(model) {
+    const partial = {
+        role: "assistant",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: createEmptyUsage(),
+        stopReason: "stop",
+        timestamp: Date.now(),
+    };
+    const toolJson = new Map();
+    return (event) => {
+        switch (event.type) {
+            case "done":
+                Object.assign(partial, {
+                    stopReason: event.reason,
+                    usage: event.usage,
+                    responseId: event.responseId,
+                });
+                appendRewriteDiagnostic(partial, event.rewrite);
+                return { type: "done", reason: event.reason, message: partial };
+            case "error":
+                Object.assign(partial, {
+                    stopReason: event.reason,
+                    usage: event.usage,
+                    errorMessage: event.errorMessage,
+                    responseId: event.responseId,
+                });
+                appendRewriteDiagnostic(partial, event.rewrite);
+                return { type: "error", reason: event.reason, error: partial };
+            case "start":
+                break;
+            case "text_start":
+                partial.content[event.contentIndex] = { type: "text", text: "" };
+                break;
+            case "text_delta":
+                partial.content[event.contentIndex].text += event.delta;
+                break;
+            case "text_end":
+                Object.assign(partial.content[event.contentIndex], {
+                    text: event.content,
+                    textSignature: event.contentSignature,
+                });
+                break;
+            case "thinking_start":
+                partial.content[event.contentIndex] = { type: "thinking", thinking: "" };
+                break;
+            case "thinking_delta":
+                partial.content[event.contentIndex].thinking += event.delta;
+                break;
+            case "thinking_end":
+                Object.assign(partial.content[event.contentIndex], {
+                    thinking: event.content,
+                    thinkingSignature: event.contentSignature,
+                    redacted: event.redacted,
+                });
+                break;
+            case "toolcall_start":
+                partial.content[event.contentIndex] = {
+                    type: "toolCall",
+                    id: event.id,
+                    name: event.toolName,
+                    arguments: {},
+                };
+                toolJson.set(event.contentIndex, "");
+                break;
+            case "toolcall_delta": {
+                const json = `${toolJson.get(event.contentIndex) ?? ""}${event.delta}`;
+                toolJson.set(event.contentIndex, json);
+                partial.content[event.contentIndex].arguments =
+                    parseStreamingJson(json);
+                break;
+            }
+            case "toolcall_end":
+                Object.assign(partial.content[event.contentIndex], event.toolCall);
+                toolJson.delete(event.contentIndex);
+                return {
+                    type: "toolcall_end",
+                    contentIndex: event.contentIndex,
+                    toolCall: partial.content[event.contentIndex],
+                    partial,
+                };
+        }
+        return { ...event, partial };
+    };
+}
+async function* readPiMessagesEvents(stream) {
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+            buffer = buffer.replace(/\r\n/g, "\n");
+            let split = buffer.indexOf("\n\n");
+            while (split !== -1) {
+                const event = parsePiMessagesEvent(buffer.slice(0, split));
+                if (event) {
+                    yield event;
+                }
+                buffer = buffer.slice(split + 2);
+                split = buffer.indexOf("\n\n");
+            }
+            if (done) {
+                break;
+            }
+        }
+        if (buffer.trim()) {
+            const event = parsePiMessagesEvent(buffer);
+            if (event) {
+                yield event;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function parsePiMessagesEvent(raw) {
+    const data = raw
+        .split("\n")
+        .find((line) => line.startsWith("data:"))
+        ?.slice(5)
+        .trim();
+    return data && data !== "[DONE]" ? JSON.parse(data) : undefined;
+}
+function createErrorEvent(model, error, aborted) {
+    const reason = aborted ? "aborted" : "error";
+    const assistantMessage = {
+        role: "assistant",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: createEmptyUsage(),
+        stopReason: reason,
+        errorMessage: error instanceof Error ? error.message : String(error),
+        timestamp: Date.now(),
+    };
+    if (!aborted && error instanceof PiMessagesResponseError) {
+        appendAssistantMessageDiagnostic(assistantMessage, createAssistantMessageDiagnostic("pi_messages_response_failure", error, error.diagnosticDetails));
+    }
+    return { type: "error", reason, error: assistantMessage };
+}
+function resolveCacheRetention(cacheRetention, env) {
+    if (cacheRetention) {
+        return cacheRetention;
+    }
+    // Backend defaults apply when unset; only the legacy env opt-in is mapped.
+    return getProviderEnvValue("PI_CACHE_RETENTION", env) === "long" ? "long" : undefined;
+}
+export const stream = (model, context, options) => {
+    const eventStream = new AssistantMessageEventStream();
+    const convertEvent = createEventConverter(model);
+    void (async () => {
+        try {
+            const apiKey = options?.apiKey;
+            if (!apiKey) {
+                throw new Error(`No API key provided for provider "${model.provider}"`);
+            }
+            const url = new URL(`${model.baseUrl.replace(/\/+$/u, "")}/messages`);
+            if (options?.debug) {
+                url.searchParams.set("debug", "1");
+            }
+            let payload = {
+                model: model.id,
+                context,
+                options: {
+                    temperature: options?.temperature,
+                    maxTokens: options?.maxTokens,
+                    reasoning: options?.reasoning,
+                    cacheRetention: resolveCacheRetention(options?.cacheRetention, options?.env),
+                    sessionId: options?.sessionId,
+                    toolChoice: options?.toolChoice,
+                },
+            };
+            const nextPayload = await options?.onPayload?.(payload, model);
+            if (nextPayload !== undefined) {
+                payload = nextPayload;
+            }
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${apiKey}`,
+                    accept: "text/event-stream",
+                    "content-type": "application/json",
+                    ...providerHeadersToRecord(options?.headers),
+                },
+                body: JSON.stringify(payload),
+                signal: options?.signal,
+            });
+            await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
+            if (!response.ok) {
+                const body = await response.text();
+                throw createPiMessagesResponseError(model, url, response, body);
+            }
+            if (!response.body) {
+                throw new Error(`${model.provider} response has no body`);
+            }
+            for await (const piEvent of readPiMessagesEvents(response.body)) {
+                const event = convertEvent(piEvent);
+                eventStream.push(event);
+                if (event.type === "done" || event.type === "error") {
+                    return;
+                }
+            }
+            throw new Error(`${model.provider} stream ended without a terminal event`);
+        }
+        catch (error) {
+            eventStream.push(createErrorEvent(model, error, options?.signal?.aborted ?? false));
+        }
+    })();
+    return eventStream;
+};
+export const streamSimple = (model, context, options) => {
+    const extra = options;
+    return stream(model, context, {
+        ...options,
+        reasoning: options?.reasoning,
+        toolChoice: extra?.toolChoice,
+        debug: extra?.debug,
+    });
+};
+//# sourceMappingURL=pi-messages.js.map

package/node_modules/@earendil-works/pi-ai/dist/api/pi-messages.lazy.js

@@ -0,0 +1,3 @@
+import { lazyApi } from "./lazy.js";
+export const piMessagesApi = () => lazyApi(() => import("./pi-messages.js"));
+//# sourceMappingURL=pi-messages.lazy.js.map

package/node_modules/@earendil-works/pi-ai/dist/api/simple-options.js

@@ -28,7 +28,7 @@ export function buildBaseOptions(model, context, options, apiKey) {
     };
 }
 export function clampReasoning(effort) {
-    return effort === "xhigh" ? "high" : effort;
+    return effort === "xhigh" || effort === "max" ? "high" : effort;
 }
 export function adjustMaxTokensForThinking(
 // Undefined means no explicit caller cap. Use the model cap and fit thinking inside it.

package/node_modules/@earendil-works/pi-ai/dist/api/transform-messages.js

@@ -44,7 +44,10 @@ function downgradeUnsupportedImages(messages, model) {
 export function transformMessages(messages, model, normalizeToolCallId) {
     // Build a map of original tool call IDs to normalized IDs
     const toolCallIdMap = new Map();
-    const imageAwareMessages = downgradeUnsupportedImages(messages, model);
+    // Normalize null/undefined content from untyped callers (custom tools, hand-built
+    // histories, old session files) so downstream code can rely on the type contract.
+    const normalizedMessages = messages.map((msg) => (msg.content == null ? { ...msg, content: [] } : msg));
+    const imageAwareMessages = downgradeUnsupportedImages(normalizedMessages, model);
     // First pass: transform messages (unsupported image downgrade, thinking blocks, tool call ID normalization)
     const transformed = imageAwareMessages.map((msg) => {
         // User messages pass through unchanged

package/node_modules/@earendil-works/pi-ai/dist/auth/credential-store.js

@@ -19,6 +19,9 @@ export class InMemoryCredentialStore {
     async read(providerId) {
         return this.credentials.get(providerId);
     }
+    async list() {
+        return [...this.credentials].map(([providerId, credential]) => ({ providerId, type: credential.type }));
+    }
     modify(providerId, fn) {
         return this.enqueue(providerId, async () => {
             const current = this.credentials.get(providerId);

package/node_modules/@earendil-works/pi-ai/dist/auth/helpers.js

@@ -7,8 +7,8 @@
 export function envApiKeyAuth(name, envVars) {
     return {
         name,
-        login: async (callbacks) => {
-            const key = await callbacks.prompt({ type: "secret", message: `Enter ${name}` });
+        login: async (interaction) => {
+            const key = await interaction.prompt({ type: "secret", message: `Enter ${name}` });
             return { type: "api_key", key };
         },
         resolve: async ({ ctx, credential }) => {
@@ -38,7 +38,8 @@ export function lazyOAuth(input) {
     };
     return {
         name: input.name,
-        login: async (callbacks) => (await loaded()).login(callbacks),
+        loginLabel: input.loginLabel,
+        login: async (interaction) => (await loaded()).login(interaction),
         refresh: async (credential) => (await loaded()).refresh(credential),
         toAuth: async (credential) => (await loaded()).toAuth(credential),
     };