@psnext/slingcli 2.4.20260507-3 → 2.4.20260509-1

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

@@ -1,208 +0,0 @@
-import { AzureOpenAI } 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 { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
-import { buildBaseOptions } from "./simple-options.js";
-const DEFAULT_AZURE_API_VERSION = "v1";
-const AZURE_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode", "azure-openai-responses"]);
-function parseDeploymentNameMap(value) {
-    const map = new Map();
-    if (!value)
-        return map;
-    for (const entry of value.split(",")) {
-        const trimmed = entry.trim();
-        if (!trimmed)
-            continue;
-        const [modelId, deploymentName] = trimmed.split("=", 2);
-        if (!modelId || !deploymentName)
-            continue;
-        map.set(modelId.trim(), deploymentName.trim());
-    }
-    return map;
-}
-function resolveDeploymentName(model, options) {
-    if (options?.azureDeploymentName) {
-        return options.azureDeploymentName;
-    }
-    const mappedDeployment = parseDeploymentNameMap(process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP).get(model.id);
-    return mappedDeployment || model.id;
-}
-/**
- * Generate function for Azure OpenAI Responses API
- */
-export const streamAzureOpenAIResponses = (model, context, options) => {
-    const stream = new AssistantMessageEventStream();
-    // Start async processing
-    (async () => {
-        const deploymentName = resolveDeploymentName(model, options);
-        const output = {
-            role: "assistant",
-            content: [],
-            api: "azure-openai-responses",
-            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 Azure OpenAI client
-            const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-            const client = createClient(model, apiKey, options);
-            let params = buildParams(model, context, options, deploymentName);
-            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);
-            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 streamSimpleAzureOpenAIResponses = (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 streamAzureOpenAIResponses(model, context, {
-        ...base,
-        reasoningEffort,
-    });
-};
-function normalizeAzureBaseUrl(baseUrl) {
-    const trimmed = baseUrl.trim().replace(/\/+$/, "");
-    let url;
-    try {
-        url = new URL(trimmed);
-    }
-    catch {
-        throw new Error(`Invalid Azure OpenAI base URL: ${baseUrl}`);
-    }
-    const isAzureHost = url.hostname.endsWith(".openai.azure.com") || url.hostname.endsWith(".cognitiveservices.azure.com");
-    const normalizedPath = url.pathname.replace(/\/+$/, "");
-    // Ensure Azure hosts have /openai/v1 as base path so the AzureOpenAI SDK
-    // can append /deployments/<model>/... and ?api-version=v1 correctly.
-    if (isAzureHost && (normalizedPath === "" || normalizedPath === "/" || normalizedPath === "/openai")) {
-        url.pathname = "/openai/v1";
-        url.search = "";
-    }
-    return url.toString().replace(/\/+$/, "");
-}
-function buildDefaultBaseUrl(resourceName) {
-    return `https://${resourceName}.openai.azure.com/openai/v1`;
-}
-function resolveAzureConfig(model, options) {
-    const apiVersion = options?.azureApiVersion || process.env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION;
-    const baseUrl = options?.azureBaseUrl?.trim() || process.env.AZURE_OPENAI_BASE_URL?.trim() || undefined;
-    const resourceName = options?.azureResourceName || process.env.AZURE_OPENAI_RESOURCE_NAME;
-    let resolvedBaseUrl = baseUrl;
-    if (!resolvedBaseUrl && resourceName) {
-        resolvedBaseUrl = buildDefaultBaseUrl(resourceName);
-    }
-    if (!resolvedBaseUrl && model.baseUrl) {
-        resolvedBaseUrl = model.baseUrl;
-    }
-    if (!resolvedBaseUrl) {
-        throw new Error("Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or pass azureBaseUrl, azureResourceName, or model.baseUrl.");
-    }
-    return {
-        baseUrl: normalizeAzureBaseUrl(resolvedBaseUrl),
-        apiVersion,
-    };
-}
-function createClient(model, apiKey, options) {
-    if (!apiKey) {
-        if (!process.env.AZURE_OPENAI_API_KEY) {
-            throw new Error("Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY environment variable or pass it as an argument.");
-        }
-        apiKey = process.env.AZURE_OPENAI_API_KEY;
-    }
-    const headers = { ...model.headers };
-    if (options?.headers) {
-        Object.assign(headers, options.headers);
-    }
-    const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
-    return new AzureOpenAI({
-        apiKey,
-        apiVersion,
-        dangerouslyAllowBrowser: true,
-        defaultHeaders: headers,
-        baseURL: baseUrl,
-    });
-}
-function buildParams(model, context, options, deploymentName) {
-    const messages = convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS);
-    const params = {
-        model: deploymentName,
-        input: messages,
-        stream: true,
-        prompt_cache_key: options?.sessionId,
-    };
-    if (options?.maxTokens) {
-        params.max_output_tokens = options?.maxTokens;
-    }
-    if (options?.temperature !== undefined) {
-        params.temperature = options?.temperature;
-    }
-    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.thinkingLevelMap?.off !== null) {
-            params.reasoning = {
-                effort: (model.thinkingLevelMap?.off ?? "none"),
-            };
-        }
-    }
-    return params;
-}
-//# sourceMappingURL=azure-openai-responses.js.map

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

@@ -1,26 +0,0 @@
-/** Workers AI direct endpoint. */
-export const CLOUDFLARE_WORKERS_AI_BASE_URL = "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1";
-/** AI Gateway Unified API. https://developers.cloudflare.com/ai-gateway/usage/unified-api/ */
-export const CLOUDFLARE_AI_GATEWAY_COMPAT_BASE_URL = "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/compat";
-/** AI Gateway → OpenAI passthrough. Used until /compat supports /v1/responses. */
-export const CLOUDFLARE_AI_GATEWAY_OPENAI_BASE_URL = "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai";
-/** AI Gateway → Anthropic passthrough. */
-export const CLOUDFLARE_AI_GATEWAY_ANTHROPIC_BASE_URL = "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic";
-export function isCloudflareProvider(provider) {
-    return provider === "cloudflare-workers-ai" || provider === "cloudflare-ai-gateway";
-}
-/** Substitute `{VAR}` placeholders in a Cloudflare baseUrl from process.env. */
-export function resolveCloudflareBaseUrl(model) {
-    const url = model.baseUrl;
-    if (!url.includes("{"))
-        return url;
-    const baseUrl = url.replace(/\{([A-Z_][A-Z0-9_]*)\}/g, (_match, name) => {
-        const value = process.env[name];
-        if (!value) {
-            throw new Error(`${name} is required for provider ${model.provider} but is not set.`);
-        }
-        return value;
-    });
-    return baseUrl;
-}
-//# sourceMappingURL=cloudflare.js.map

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

@@ -1,368 +0,0 @@
-import { registerApiProvider, unregisterApiProviders } from "../api-registry.js";
-import { createAssistantMessageEventStream } from "../utils/event-stream.js";
-const DEFAULT_API = "faux";
-const DEFAULT_PROVIDER = "faux";
-const DEFAULT_MODEL_ID = "faux-1";
-const DEFAULT_MODEL_NAME = "Faux Model";
-const DEFAULT_BASE_URL = "http://localhost:0";
-const DEFAULT_MIN_TOKEN_SIZE = 3;
-const DEFAULT_MAX_TOKEN_SIZE = 5;
-const DEFAULT_USAGE = {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    totalTokens: 0,
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-};
-export function fauxText(text) {
-    return { type: "text", text };
-}
-export function fauxThinking(thinking) {
-    return { type: "thinking", thinking };
-}
-export function fauxToolCall(name, arguments_, options = {}) {
-    return {
-        type: "toolCall",
-        id: options.id ?? randomId("tool"),
-        name,
-        arguments: arguments_,
-    };
-}
-function normalizeFauxAssistantContent(content) {
-    if (typeof content === "string") {
-        return [fauxText(content)];
-    }
-    return Array.isArray(content) ? content : [content];
-}
-export function fauxAssistantMessage(content, options = {}) {
-    return {
-        role: "assistant",
-        content: normalizeFauxAssistantContent(content),
-        api: DEFAULT_API,
-        provider: DEFAULT_PROVIDER,
-        model: DEFAULT_MODEL_ID,
-        usage: DEFAULT_USAGE,
-        stopReason: options.stopReason ?? "stop",
-        errorMessage: options.errorMessage,
-        responseId: options.responseId,
-        timestamp: options.timestamp ?? Date.now(),
-    };
-}
-function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}
-function randomId(prefix) {
-    return `${prefix}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
-}
-function contentToText(content) {
-    if (typeof content === "string") {
-        return content;
-    }
-    return content
-        .map((block) => {
-        if (block.type === "text") {
-            return block.text;
-        }
-        return `[image:${block.mimeType}:${block.data.length}]`;
-    })
-        .join("\n");
-}
-function assistantContentToText(content) {
-    return content
-        .map((block) => {
-        if (block.type === "text") {
-            return block.text;
-        }
-        if (block.type === "thinking") {
-            return block.thinking;
-        }
-        return `${block.name}:${JSON.stringify(block.arguments)}`;
-    })
-        .join("\n");
-}
-function toolResultToText(message) {
-    return [message.toolName, ...message.content.map((block) => contentToText([block]))].join("\n");
-}
-function messageToText(message) {
-    if (message.role === "user") {
-        return contentToText(message.content);
-    }
-    if (message.role === "assistant") {
-        return assistantContentToText(message.content);
-    }
-    return toolResultToText(message);
-}
-function serializeContext(context) {
-    const parts = [];
-    if (context.systemPrompt) {
-        parts.push(`system:${context.systemPrompt}`);
-    }
-    for (const message of context.messages) {
-        parts.push(`${message.role}:${messageToText(message)}`);
-    }
-    if (context.tools?.length) {
-        parts.push(`tools:${JSON.stringify(context.tools)}`);
-    }
-    return parts.join("\n\n");
-}
-function commonPrefixLength(a, b) {
-    const length = Math.min(a.length, b.length);
-    let index = 0;
-    while (index < length && a[index] === b[index]) {
-        index++;
-    }
-    return index;
-}
-function withUsageEstimate(message, context, options, promptCache) {
-    const promptText = serializeContext(context);
-    const promptTokens = estimateTokens(promptText);
-    const outputTokens = estimateTokens(assistantContentToText(message.content));
-    let input = promptTokens;
-    let cacheRead = 0;
-    let cacheWrite = 0;
-    const sessionId = options?.sessionId;
-    if (sessionId && options?.cacheRetention !== "none") {
-        const previousPrompt = promptCache.get(sessionId);
-        if (previousPrompt) {
-            const cachedChars = commonPrefixLength(previousPrompt, promptText);
-            cacheRead = estimateTokens(previousPrompt.slice(0, cachedChars));
-            cacheWrite = estimateTokens(promptText.slice(cachedChars));
-            input = Math.max(0, promptTokens - cacheRead);
-        }
-        else {
-            cacheWrite = promptTokens;
-        }
-        promptCache.set(sessionId, promptText);
-    }
-    return {
-        ...message,
-        usage: {
-            input,
-            output: outputTokens,
-            cacheRead,
-            cacheWrite,
-            totalTokens: input + outputTokens + cacheRead + cacheWrite,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
-    };
-}
-function splitStringByTokenSize(text, minTokenSize, maxTokenSize) {
-    const chunks = [];
-    let index = 0;
-    while (index < text.length) {
-        const tokenSize = minTokenSize + Math.floor(Math.random() * (maxTokenSize - minTokenSize + 1));
-        const charSize = Math.max(1, tokenSize * 4);
-        chunks.push(text.slice(index, index + charSize));
-        index += charSize;
-    }
-    return chunks.length > 0 ? chunks : [""];
-}
-function cloneMessage(message, api, provider, modelId) {
-    const cloned = structuredClone(message);
-    return {
-        ...cloned,
-        api,
-        provider,
-        model: modelId,
-        timestamp: cloned.timestamp ?? Date.now(),
-        usage: cloned.usage ?? DEFAULT_USAGE,
-    };
-}
-function createErrorMessage(error, api, provider, modelId) {
-    return {
-        role: "assistant",
-        content: [],
-        api,
-        provider,
-        model: modelId,
-        usage: DEFAULT_USAGE,
-        stopReason: "error",
-        errorMessage: error instanceof Error ? error.message : String(error),
-        timestamp: Date.now(),
-    };
-}
-function createAbortedMessage(partial) {
-    return {
-        ...partial,
-        stopReason: "aborted",
-        errorMessage: "Request was aborted",
-        timestamp: Date.now(),
-    };
-}
-function scheduleChunk(chunk, tokensPerSecond) {
-    if (!tokensPerSecond || tokensPerSecond <= 0) {
-        return new Promise((resolve) => queueMicrotask(resolve));
-    }
-    const delayMs = (estimateTokens(chunk) / tokensPerSecond) * 1000;
-    return new Promise((resolve) => setTimeout(resolve, delayMs));
-}
-async function streamWithDeltas(stream, message, minTokenSize, maxTokenSize, tokensPerSecond, signal) {
-    const partial = { ...message, content: [] };
-    if (signal?.aborted) {
-        const aborted = createAbortedMessage(partial);
-        stream.push({ type: "error", reason: "aborted", error: aborted });
-        stream.end(aborted);
-        return;
-    }
-    stream.push({ type: "start", partial: { ...partial } });
-    for (let index = 0; index < message.content.length; index++) {
-        if (signal?.aborted) {
-            const aborted = createAbortedMessage(partial);
-            stream.push({ type: "error", reason: "aborted", error: aborted });
-            stream.end(aborted);
-            return;
-        }
-        const block = message.content[index];
-        if (block.type === "thinking") {
-            partial.content = [...partial.content, { type: "thinking", thinking: "" }];
-            stream.push({ type: "thinking_start", contentIndex: index, partial: { ...partial } });
-            for (const chunk of splitStringByTokenSize(block.thinking, minTokenSize, maxTokenSize)) {
-                await scheduleChunk(chunk, tokensPerSecond);
-                if (signal?.aborted) {
-                    const aborted = createAbortedMessage(partial);
-                    stream.push({ type: "error", reason: "aborted", error: aborted });
-                    stream.end(aborted);
-                    return;
-                }
-                partial.content[index].thinking += chunk;
-                stream.push({ type: "thinking_delta", contentIndex: index, delta: chunk, partial: { ...partial } });
-            }
-            stream.push({
-                type: "thinking_end",
-                contentIndex: index,
-                content: block.thinking,
-                partial: { ...partial },
-            });
-            continue;
-        }
-        if (block.type === "text") {
-            partial.content = [...partial.content, { type: "text", text: "" }];
-            stream.push({ type: "text_start", contentIndex: index, partial: { ...partial } });
-            for (const chunk of splitStringByTokenSize(block.text, minTokenSize, maxTokenSize)) {
-                await scheduleChunk(chunk, tokensPerSecond);
-                if (signal?.aborted) {
-                    const aborted = createAbortedMessage(partial);
-                    stream.push({ type: "error", reason: "aborted", error: aborted });
-                    stream.end(aborted);
-                    return;
-                }
-                partial.content[index].text += chunk;
-                stream.push({ type: "text_delta", contentIndex: index, delta: chunk, partial: { ...partial } });
-            }
-            stream.push({ type: "text_end", contentIndex: index, content: block.text, partial: { ...partial } });
-            continue;
-        }
-        partial.content = [...partial.content, { type: "toolCall", id: block.id, name: block.name, arguments: {} }];
-        stream.push({ type: "toolcall_start", contentIndex: index, partial: { ...partial } });
-        for (const chunk of splitStringByTokenSize(JSON.stringify(block.arguments), minTokenSize, maxTokenSize)) {
-            await scheduleChunk(chunk, tokensPerSecond);
-            if (signal?.aborted) {
-                const aborted = createAbortedMessage(partial);
-                stream.push({ type: "error", reason: "aborted", error: aborted });
-                stream.end(aborted);
-                return;
-            }
-            stream.push({ type: "toolcall_delta", contentIndex: index, delta: chunk, partial: { ...partial } });
-        }
-        partial.content[index].arguments = block.arguments;
-        stream.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: { ...partial } });
-    }
-    if (message.stopReason === "error" || message.stopReason === "aborted") {
-        stream.push({ type: "error", reason: message.stopReason, error: message });
-        stream.end(message);
-        return;
-    }
-    stream.push({ type: "done", reason: message.stopReason, message });
-    stream.end(message);
-}
-export function registerFauxProvider(options = {}) {
-    const api = options.api ?? randomId(DEFAULT_API);
-    const provider = options.provider ?? DEFAULT_PROVIDER;
-    const sourceId = randomId("faux-provider");
-    const minTokenSize = Math.max(1, Math.min(options.tokenSize?.min ?? DEFAULT_MIN_TOKEN_SIZE, options.tokenSize?.max ?? DEFAULT_MAX_TOKEN_SIZE));
-    const maxTokenSize = Math.max(minTokenSize, options.tokenSize?.max ?? DEFAULT_MAX_TOKEN_SIZE);
-    let pendingResponses = [];
-    const tokensPerSecond = options.tokensPerSecond;
-    const state = { callCount: 0 };
-    const promptCache = new Map();
-    const modelDefinitions = options.models?.length
-        ? options.models
-        : [
-            {
-                id: DEFAULT_MODEL_ID,
-                name: DEFAULT_MODEL_NAME,
-                reasoning: false,
-                input: ["text", "image"],
-                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-                contextWindow: 128000,
-                maxTokens: 16384,
-            },
-        ];
-    const models = modelDefinitions.map((definition) => ({
-        id: definition.id,
-        name: definition.name ?? definition.id,
-        api,
-        provider,
-        baseUrl: DEFAULT_BASE_URL,
-        reasoning: definition.reasoning ?? false,
-        input: definition.input ?? ["text", "image"],
-        cost: definition.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-        contextWindow: definition.contextWindow ?? 128000,
-        maxTokens: definition.maxTokens ?? 16384,
-    }));
-    const stream = (requestModel, context, streamOptions) => {
-        const outer = createAssistantMessageEventStream();
-        const step = pendingResponses.shift();
-        state.callCount++;
-        queueMicrotask(async () => {
-            try {
-                await streamOptions?.onResponse?.({ status: 200, headers: {} }, requestModel);
-                if (!step) {
-                    let message = createErrorMessage(new Error("No more faux responses queued"), api, provider, requestModel.id);
-                    message = withUsageEstimate(message, context, streamOptions, promptCache);
-                    outer.push({ type: "error", reason: "error", error: message });
-                    outer.end(message);
-                    return;
-                }
-                const resolved = typeof step === "function" ? await step(context, streamOptions, state, requestModel) : step;
-                let message = cloneMessage(resolved, api, provider, requestModel.id);
-                message = withUsageEstimate(message, context, streamOptions, promptCache);
-                await streamWithDeltas(outer, message, minTokenSize, maxTokenSize, tokensPerSecond, streamOptions?.signal);
-            }
-            catch (error) {
-                const message = createErrorMessage(error, api, provider, requestModel.id);
-                outer.push({ type: "error", reason: "error", error: message });
-                outer.end(message);
-            }
-        });
-        return outer;
-    };
-    const streamSimple = (streamModel, context, streamOptions) => stream(streamModel, context, streamOptions);
-    registerApiProvider({ api, stream, streamSimple }, sourceId);
-    function getModel(requestedModelId) {
-        if (!requestedModelId) {
-            return models[0];
-        }
-        return models.find((candidate) => candidate.id === requestedModelId);
-    }
-    return {
-        api,
-        models,
-        getModel,
-        state,
-        setResponses(responses) {
-            pendingResponses = [...responses];
-        },
-        appendResponses(responses) {
-            pendingResponses.push(...responses);
-        },
-        getPendingResponseCount() {
-            return pendingResponses.length;
-        },
-        unregister() {
-            unregisterApiProviders(sourceId);
-        },
-    };
-}
-//# sourceMappingURL=faux.js.map

package/node_modules/@mariozechner/pi-ai/dist/providers/github-copilot-headers.js

@@ -1,29 +0,0 @@
-// Copilot expects X-Initiator to indicate whether the request is user-initiated
-// or agent-initiated (e.g. follow-up after assistant/tool messages).
-export function inferCopilotInitiator(messages) {
-    const last = messages[messages.length - 1];
-    return last && last.role !== "user" ? "agent" : "user";
-}
-// Copilot requires Copilot-Vision-Request header when sending images
-export function hasCopilotVisionInput(messages) {
-    return messages.some((msg) => {
-        if (msg.role === "user" && Array.isArray(msg.content)) {
-            return msg.content.some((c) => c.type === "image");
-        }
-        if (msg.role === "toolResult" && Array.isArray(msg.content)) {
-            return msg.content.some((c) => c.type === "image");
-        }
-        return false;
-    });
-}
-export function buildCopilotDynamicHeaders(params) {
-    const headers = {
-        "X-Initiator": inferCopilotInitiator(params.messages),
-        "Openai-Intent": "conversation-edits",
-    };
-    if (params.hasImages) {
-        headers["Copilot-Vision-Request"] = "true";
-    }
-    return headers;
-}
-//# sourceMappingURL=github-copilot-headers.js.map