@psnext/slingcli 2.4.20260507-2 → 2.4.20260509-1

package/node_modules/@mariozechner/pi-ai/dist/providers/openai-responses.js

@@ -1,220 +0,0 @@
-import OpenAI from "openai";
-import { getEnvApiKey } from "../env-api-keys.js";
-import { clampThinkingLevel } from "../models.js";
-import { AssistantMessageEventStream } from "../utils/event-stream.js";
-import { headersToRecord } from "../utils/headers.js";
-import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
-import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.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"]);
-/**
- * Resolve cache retention preference.
- * Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
- */
-function resolveCacheRetention(cacheRetention) {
-    if (cacheRetention) {
-        return cacheRetention;
-    }
-    if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") {
-        return "long";
-    }
-    return "short";
-}
-function getCompat(model) {
-    return {
-        sendSessionIdHeader: model.compat?.sendSessionIdHeader ?? true,
-        supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
-    };
-}
-function getPromptCacheRetention(compat, cacheRetention) {
-    return cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : undefined;
-}
-/**
- * Generate function for OpenAI Responses API
- */
-export const streamOpenAIResponses = (model, context, options) => {
-    const stream = new AssistantMessageEventStream();
-    // Start async processing
-    (async () => {
-        const output = {
-            role: "assistant",
-            content: [],
-            api: model.api,
-            provider: model.provider,
-            model: model.id,
-            usage: {
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                totalTokens: 0,
-                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-            },
-            stopReason: "stop",
-            timestamp: Date.now(),
-        };
-        try {
-            // Create OpenAI client
-            const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-            const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-            const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-            const client = createClient(model, context, apiKey, options?.headers, cacheSessionId);
-            let params = buildParams(model, context, options);
-            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: openaiStream, response } = await client.responses.create(params, requestOptions).withResponse();
-            await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
-            stream.push({ type: "start", partial: output });
-            await processResponsesStream(openaiStream, output, stream, model, {
-                serviceTier: options?.serviceTier,
-                applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
-            });
-            if (options?.signal?.aborted) {
-                throw new Error("Request was aborted");
-            }
-            if (output.stopReason === "aborted" || output.stopReason === "error") {
-                throw new Error("An unknown error occurred");
-            }
-            stream.push({ type: "done", reason: output.stopReason, message: output });
-            stream.end();
-        }
-        catch (error) {
-            for (const block of output.content) {
-                delete block.index;
-                // partialJson is only a streaming scratch buffer; never persist it.
-                delete block.partialJson;
-            }
-            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-            stream.push({ type: "error", reason: output.stopReason, error: output });
-            stream.end();
-        }
-    })();
-    return stream;
-};
-export const streamSimpleOpenAIResponses = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
-    if (!apiKey) {
-        throw new Error(`No API key for provider: ${model.provider}`);
-    }
-    const base = buildBaseOptions(model, options, apiKey);
-    const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
-    const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
-    return streamOpenAIResponses(model, context, {
-        ...base,
-        reasoningEffort,
-    });
-};
-function createClient(model, context, apiKey, optionsHeaders, sessionId) {
-    if (!apiKey) {
-        if (!process.env.OPENAI_API_KEY) {
-            throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.");
-        }
-        apiKey = process.env.OPENAI_API_KEY;
-    }
-    const compat = getCompat(model);
-    const headers = { ...model.headers };
-    if (model.provider === "github-copilot") {
-        const hasImages = hasCopilotVisionInput(context.messages);
-        const copilotHeaders = buildCopilotDynamicHeaders({
-            messages: context.messages,
-            hasImages,
-        });
-        Object.assign(headers, copilotHeaders);
-    }
-    if (sessionId) {
-        if (compat.sendSessionIdHeader) {
-            headers.session_id = sessionId;
-        }
-        headers["x-client-request-id"] = sessionId;
-    }
-    // Merge options headers last so they can override defaults
-    if (optionsHeaders) {
-        Object.assign(headers, optionsHeaders);
-    }
-    const defaultHeaders = model.provider === "cloudflare-ai-gateway"
-        ? {
-            ...headers,
-            Authorization: headers.Authorization ?? null,
-            "cf-aig-authorization": `Bearer ${apiKey}`,
-        }
-        : headers;
-    return new OpenAI({
-        apiKey,
-        baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl,
-        dangerouslyAllowBrowser: true,
-        defaultHeaders,
-    });
-}
-function buildParams(model, context, options) {
-    const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS);
-    const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-    const compat = getCompat(model);
-    const params = {
-        model: model.id,
-        input: messages,
-        stream: true,
-        prompt_cache_key: cacheRetention === "none" ? undefined : options?.sessionId,
-        prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
-        store: false,
-    };
-    if (options?.maxTokens) {
-        params.max_output_tokens = options?.maxTokens;
-    }
-    if (options?.temperature !== undefined) {
-        params.temperature = options?.temperature;
-    }
-    if (options?.serviceTier !== undefined) {
-        params.service_tier = options.serviceTier;
-    }
-    if (context.tools && context.tools.length > 0) {
-        params.tools = convertResponsesTools(context.tools);
-    }
-    if (model.reasoning) {
-        if (options?.reasoningEffort || options?.reasoningSummary) {
-            const effort = options?.reasoningEffort
-                ? (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort)
-                : "medium";
-            params.reasoning = {
-                effort: effort,
-                summary: options?.reasoningSummary || "auto",
-            };
-            params.include = ["reasoning.encrypted_content"];
-        }
-        else if (model.provider !== "github-copilot" && model.thinkingLevelMap?.off !== null) {
-            params.reasoning = {
-                effort: (model.thinkingLevelMap?.off ?? "none"),
-            };
-        }
-    }
-    return params;
-}
-function getServiceTierCostMultiplier(model, serviceTier) {
-    switch (serviceTier) {
-        case "flex":
-            return 0.5;
-        case "priority":
-            return model.id === "gpt-5.5" ? 2.5 : 2;
-        default:
-            return 1;
-    }
-}
-function applyServiceTierPricing(usage, serviceTier, model) {
-    const multiplier = getServiceTierCostMultiplier(model, serviceTier);
-    if (multiplier === 1)
-        return;
-    usage.cost.input *= multiplier;
-    usage.cost.output *= multiplier;
-    usage.cost.cacheRead *= multiplier;
-    usage.cost.cacheWrite *= multiplier;
-    usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-}
-//# sourceMappingURL=openai-responses.js.map

package/node_modules/@mariozechner/pi-ai/dist/providers/register-builtins.js

@@ -1,243 +0,0 @@
-import { clearApiProviders, registerApiProvider } from "../api-registry.js";
-import { AssistantMessageEventStream } from "../utils/event-stream.js";
-const importNodeOnlyProvider = (specifier) => import(specifier);
-let anthropicProviderModulePromise;
-let azureOpenAIResponsesProviderModulePromise;
-let googleProviderModulePromise;
-let googleVertexProviderModulePromise;
-let mistralProviderModulePromise;
-let openAICodexResponsesProviderModulePromise;
-let openAICompletionsProviderModulePromise;
-let openAIResponsesProviderModulePromise;
-let bedrockProviderModuleOverride;
-let bedrockProviderModulePromise;
-export function setBedrockProviderModule(module) {
-    bedrockProviderModuleOverride = {
-        stream: module.streamBedrock,
-        streamSimple: module.streamSimpleBedrock,
-    };
-}
-function forwardStream(target, source) {
-    (async () => {
-        for await (const event of source) {
-            target.push(event);
-        }
-        target.end();
-    })();
-}
-function createLazyLoadErrorMessage(model, error) {
-    return {
-        role: "assistant",
-        content: [],
-        api: model.api,
-        provider: model.provider,
-        model: model.id,
-        usage: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
-        stopReason: "error",
-        errorMessage: error instanceof Error ? error.message : String(error),
-        timestamp: Date.now(),
-    };
-}
-function createLazyStream(loadModule) {
-    return (model, context, options) => {
-        const outer = new AssistantMessageEventStream();
-        loadModule()
-            .then((module) => {
-            const inner = module.stream(model, context, options);
-            forwardStream(outer, inner);
-        })
-            .catch((error) => {
-            const message = createLazyLoadErrorMessage(model, error);
-            outer.push({ type: "error", reason: "error", error: message });
-            outer.end(message);
-        });
-        return outer;
-    };
-}
-function createLazySimpleStream(loadModule) {
-    return (model, context, options) => {
-        const outer = new AssistantMessageEventStream();
-        loadModule()
-            .then((module) => {
-            const inner = module.streamSimple(model, context, options);
-            forwardStream(outer, inner);
-        })
-            .catch((error) => {
-            const message = createLazyLoadErrorMessage(model, error);
-            outer.push({ type: "error", reason: "error", error: message });
-            outer.end(message);
-        });
-        return outer;
-    };
-}
-function loadAnthropicProviderModule() {
-    anthropicProviderModulePromise ||= import("./anthropic.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamAnthropic,
-            streamSimple: provider.streamSimpleAnthropic,
-        };
-    });
-    return anthropicProviderModulePromise;
-}
-function loadAzureOpenAIResponsesProviderModule() {
-    azureOpenAIResponsesProviderModulePromise ||= import("./azure-openai-responses.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamAzureOpenAIResponses,
-            streamSimple: provider.streamSimpleAzureOpenAIResponses,
-        };
-    });
-    return azureOpenAIResponsesProviderModulePromise;
-}
-function loadGoogleProviderModule() {
-    googleProviderModulePromise ||= import("./google.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamGoogle,
-            streamSimple: provider.streamSimpleGoogle,
-        };
-    });
-    return googleProviderModulePromise;
-}
-function loadGoogleVertexProviderModule() {
-    googleVertexProviderModulePromise ||= import("./google-vertex.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamGoogleVertex,
-            streamSimple: provider.streamSimpleGoogleVertex,
-        };
-    });
-    return googleVertexProviderModulePromise;
-}
-function loadMistralProviderModule() {
-    mistralProviderModulePromise ||= import("./mistral.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamMistral,
-            streamSimple: provider.streamSimpleMistral,
-        };
-    });
-    return mistralProviderModulePromise;
-}
-function loadOpenAICodexResponsesProviderModule() {
-    openAICodexResponsesProviderModulePromise ||= import("./openai-codex-responses.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamOpenAICodexResponses,
-            streamSimple: provider.streamSimpleOpenAICodexResponses,
-        };
-    });
-    return openAICodexResponsesProviderModulePromise;
-}
-function loadOpenAICompletionsProviderModule() {
-    openAICompletionsProviderModulePromise ||= import("./openai-completions.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamOpenAICompletions,
-            streamSimple: provider.streamSimpleOpenAICompletions,
-        };
-    });
-    return openAICompletionsProviderModulePromise;
-}
-function loadOpenAIResponsesProviderModule() {
-    openAIResponsesProviderModulePromise ||= import("./openai-responses.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamOpenAIResponses,
-            streamSimple: provider.streamSimpleOpenAIResponses,
-        };
-    });
-    return openAIResponsesProviderModulePromise;
-}
-function loadBedrockProviderModule() {
-    if (bedrockProviderModuleOverride) {
-        return Promise.resolve(bedrockProviderModuleOverride);
-    }
-    bedrockProviderModulePromise ||= importNodeOnlyProvider("./amazon-bedrock.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamBedrock,
-            streamSimple: provider.streamSimpleBedrock,
-        };
-    });
-    return bedrockProviderModulePromise;
-}
-export const streamAnthropic = createLazyStream(loadAnthropicProviderModule);
-export const streamSimpleAnthropic = createLazySimpleStream(loadAnthropicProviderModule);
-export const streamAzureOpenAIResponses = createLazyStream(loadAzureOpenAIResponsesProviderModule);
-export const streamSimpleAzureOpenAIResponses = createLazySimpleStream(loadAzureOpenAIResponsesProviderModule);
-export const streamGoogle = createLazyStream(loadGoogleProviderModule);
-export const streamSimpleGoogle = createLazySimpleStream(loadGoogleProviderModule);
-export const streamGoogleVertex = createLazyStream(loadGoogleVertexProviderModule);
-export const streamSimpleGoogleVertex = createLazySimpleStream(loadGoogleVertexProviderModule);
-export const streamMistral = createLazyStream(loadMistralProviderModule);
-export const streamSimpleMistral = createLazySimpleStream(loadMistralProviderModule);
-export const streamOpenAICodexResponses = createLazyStream(loadOpenAICodexResponsesProviderModule);
-export const streamSimpleOpenAICodexResponses = createLazySimpleStream(loadOpenAICodexResponsesProviderModule);
-export const streamOpenAICompletions = createLazyStream(loadOpenAICompletionsProviderModule);
-export const streamSimpleOpenAICompletions = createLazySimpleStream(loadOpenAICompletionsProviderModule);
-export const streamOpenAIResponses = createLazyStream(loadOpenAIResponsesProviderModule);
-export const streamSimpleOpenAIResponses = createLazySimpleStream(loadOpenAIResponsesProviderModule);
-const streamBedrockLazy = createLazyStream(loadBedrockProviderModule);
-const streamSimpleBedrockLazy = createLazySimpleStream(loadBedrockProviderModule);
-export function registerBuiltInApiProviders() {
-    registerApiProvider({
-        api: "anthropic-messages",
-        stream: streamAnthropic,
-        streamSimple: streamSimpleAnthropic,
-    });
-    registerApiProvider({
-        api: "openai-completions",
-        stream: streamOpenAICompletions,
-        streamSimple: streamSimpleOpenAICompletions,
-    });
-    registerApiProvider({
-        api: "mistral-conversations",
-        stream: streamMistral,
-        streamSimple: streamSimpleMistral,
-    });
-    registerApiProvider({
-        api: "openai-responses",
-        stream: streamOpenAIResponses,
-        streamSimple: streamSimpleOpenAIResponses,
-    });
-    registerApiProvider({
-        api: "azure-openai-responses",
-        stream: streamAzureOpenAIResponses,
-        streamSimple: streamSimpleAzureOpenAIResponses,
-    });
-    registerApiProvider({
-        api: "openai-codex-responses",
-        stream: streamOpenAICodexResponses,
-        streamSimple: streamSimpleOpenAICodexResponses,
-    });
-    registerApiProvider({
-        api: "google-generative-ai",
-        stream: streamGoogle,
-        streamSimple: streamSimpleGoogle,
-    });
-    registerApiProvider({
-        api: "google-vertex",
-        stream: streamGoogleVertex,
-        streamSimple: streamSimpleGoogleVertex,
-    });
-    registerApiProvider({
-        api: "bedrock-converse-stream",
-        stream: streamBedrockLazy,
-        streamSimple: streamSimpleBedrockLazy,
-    });
-}
-export function resetApiProviders() {
-    clearApiProviders();
-    registerBuiltInApiProviders();
-}
-registerBuiltInApiProviders();
-//# sourceMappingURL=register-builtins.js.map

package/node_modules/@mariozechner/pi-ai/dist/providers/simple-options.js

@@ -1,39 +0,0 @@
-export function buildBaseOptions(model, options, apiKey) {
-    return {
-        temperature: options?.temperature,
-        maxTokens: options?.maxTokens ?? (model.maxTokens > 0 ? Math.min(model.maxTokens, 32000) : undefined),
-        signal: options?.signal,
-        apiKey: apiKey || options?.apiKey,
-        transport: options?.transport,
-        cacheRetention: options?.cacheRetention,
-        sessionId: options?.sessionId,
-        headers: options?.headers,
-        onPayload: options?.onPayload,
-        onResponse: options?.onResponse,
-        timeoutMs: options?.timeoutMs,
-        maxRetries: options?.maxRetries,
-        maxRetryDelayMs: options?.maxRetryDelayMs,
-        metadata: options?.metadata,
-    };
-}
-export function clampReasoning(effort) {
-    return effort === "xhigh" ? "high" : effort;
-}
-export function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
-    const defaultBudgets = {
-        minimal: 1024,
-        low: 2048,
-        medium: 8192,
-        high: 16384,
-    };
-    const budgets = { ...defaultBudgets, ...customBudgets };
-    const minOutputTokens = 1024;
-    const level = clampReasoning(reasoningLevel);
-    let thinkingBudget = budgets[level];
-    const maxTokens = Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
-    if (maxTokens <= thinkingBudget) {
-        thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
-    }
-    return { maxTokens, thinkingBudget };
-}
-//# sourceMappingURL=simple-options.js.map

package/node_modules/@mariozechner/pi-ai/dist/providers/transform-messages.js

@@ -1,184 +0,0 @@
-const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
-const NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
-function replaceImagesWithPlaceholder(content, placeholder) {
-    const result = [];
-    let previousWasPlaceholder = false;
-    for (const block of content) {
-        if (block.type === "image") {
-            if (!previousWasPlaceholder) {
-                result.push({ type: "text", text: placeholder });
-            }
-            previousWasPlaceholder = true;
-            continue;
-        }
-        result.push(block);
-        previousWasPlaceholder = block.text === placeholder;
-    }
-    return result;
-}
-function downgradeUnsupportedImages(messages, model) {
-    if (model.input.includes("image")) {
-        return messages;
-    }
-    return messages.map((msg) => {
-        if (msg.role === "user" && Array.isArray(msg.content)) {
-            return {
-                ...msg,
-                content: replaceImagesWithPlaceholder(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER),
-            };
-        }
-        if (msg.role === "toolResult") {
-            return {
-                ...msg,
-                content: replaceImagesWithPlaceholder(msg.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER),
-            };
-        }
-        return msg;
-    });
-}
-/**
- * Normalize tool call ID for cross-provider compatibility.
- * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
- * Anthropic APIs require IDs matching ^[a-zA-Z0-9_-]+$ (max 64 chars).
- */
-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);
-    // First pass: transform messages (unsupported image downgrade, thinking blocks, tool call ID normalization)
-    const transformed = imageAwareMessages.map((msg) => {
-        // User messages pass through unchanged
-        if (msg.role === "user") {
-            return msg;
-        }
-        // Handle toolResult messages - normalize toolCallId if we have a mapping
-        if (msg.role === "toolResult") {
-            const normalizedId = toolCallIdMap.get(msg.toolCallId);
-            if (normalizedId && normalizedId !== msg.toolCallId) {
-                return { ...msg, toolCallId: normalizedId };
-            }
-            return msg;
-        }
-        // Assistant messages need transformation check
-        if (msg.role === "assistant") {
-            const assistantMsg = msg;
-            const isSameModel = assistantMsg.provider === model.provider &&
-                assistantMsg.api === model.api &&
-                assistantMsg.model === model.id;
-            const transformedContent = assistantMsg.content.flatMap((block) => {
-                if (block.type === "thinking") {
-                    // Redacted thinking is opaque encrypted content, only valid for the same model.
-                    // Drop it for cross-model to avoid API errors.
-                    if (block.redacted) {
-                        return isSameModel ? block : [];
-                    }
-                    // For same model: keep thinking blocks with signatures (needed for replay)
-                    // even if the thinking text is empty (OpenAI encrypted reasoning)
-                    if (isSameModel && block.thinkingSignature)
-                        return block;
-                    // Skip empty thinking blocks, convert others to plain text
-                    if (!block.thinking || block.thinking.trim() === "")
-                        return [];
-                    if (isSameModel)
-                        return block;
-                    return {
-                        type: "text",
-                        text: block.thinking,
-                    };
-                }
-                if (block.type === "text") {
-                    if (isSameModel)
-                        return block;
-                    return {
-                        type: "text",
-                        text: block.text,
-                    };
-                }
-                if (block.type === "toolCall") {
-                    const toolCall = block;
-                    let normalizedToolCall = toolCall;
-                    if (!isSameModel && toolCall.thoughtSignature) {
-                        normalizedToolCall = { ...toolCall };
-                        delete normalizedToolCall.thoughtSignature;
-                    }
-                    if (!isSameModel && normalizeToolCallId) {
-                        const normalizedId = normalizeToolCallId(toolCall.id, model, assistantMsg);
-                        if (normalizedId !== toolCall.id) {
-                            toolCallIdMap.set(toolCall.id, normalizedId);
-                            normalizedToolCall = { ...normalizedToolCall, id: normalizedId };
-                        }
-                    }
-                    return normalizedToolCall;
-                }
-                return block;
-            });
-            return {
-                ...assistantMsg,
-                content: transformedContent,
-            };
-        }
-        return msg;
-    });
-    // Second pass: insert synthetic empty tool results for orphaned tool calls
-    // This preserves thinking signatures and satisfies API requirements
-    const result = [];
-    let pendingToolCalls = [];
-    let existingToolResultIds = new Set();
-    const insertSyntheticToolResults = () => {
-        if (pendingToolCalls.length > 0) {
-            for (const tc of pendingToolCalls) {
-                if (!existingToolResultIds.has(tc.id)) {
-                    result.push({
-                        role: "toolResult",
-                        toolCallId: tc.id,
-                        toolName: tc.name,
-                        content: [{ type: "text", text: "No result provided" }],
-                        isError: true,
-                        timestamp: Date.now(),
-                    });
-                }
-            }
-            pendingToolCalls = [];
-            existingToolResultIds = new Set();
-        }
-    };
-    for (let i = 0; i < transformed.length; i++) {
-        const msg = transformed[i];
-        if (msg.role === "assistant") {
-            // If we have pending orphaned tool calls from a previous assistant, insert synthetic results now
-            insertSyntheticToolResults();
-            // Skip errored/aborted assistant messages entirely.
-            // These are incomplete turns that shouldn't be replayed:
-            // - May have partial content (reasoning without message, incomplete tool calls)
-            // - Replaying them can cause API errors (e.g., OpenAI "reasoning without following item")
-            // - The model should retry from the last valid state
-            const assistantMsg = msg;
-            if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
-                continue;
-            }
-            // Track tool calls from this assistant message
-            const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall");
-            if (toolCalls.length > 0) {
-                pendingToolCalls = toolCalls;
-                existingToolResultIds = new Set();
-            }
-            result.push(msg);
-        }
-        else if (msg.role === "toolResult") {
-            existingToolResultIds.add(msg.toolCallId);
-            result.push(msg);
-        }
-        else if (msg.role === "user") {
-            // User message interrupts tool flow - insert synthetic results for orphaned calls
-            insertSyntheticToolResults();
-            result.push(msg);
-        }
-        else {
-            result.push(msg);
-        }
-    }
-    // If the conversation ends with unresolved tool calls, synthesize results now.
-    insertSyntheticToolResults();
-    return result;
-}
-//# sourceMappingURL=transform-messages.js.map