@code-yeongyu/senpi 2026.6.21 → 2026.6.30-2

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

@@ -1,657 +1,2 @@
-import OpenAI from "openai";
-import { registerApiProvider } from "../api-registry.js";
-import { clampThinkingLevel, supportsXhigh } from "../models.js";
-import { AssistantMessageEventStream } from "../utils/event-stream.js";
-import { headersToRecord } from "../utils/headers.js";
-import { getProviderEnvValue } from "../utils/provider-env.js";
-import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
-import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
-import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
-import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
-import { buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS } from "./simple-options.js";
-const OPENAI_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
-const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
-const OPENAI_WEB_SEARCH_SOURCES_INCLUDE = "web_search_call.action.sources";
-const SESSION_WEBSOCKET_CACHE_TTL_MS = 5 * 60 * 1000;
-const websocketSessionCache = new Map();
-/**
- * Resolve cache retention preference.
- * Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
- */
-function resolveCacheRetention(cacheRetention, env) {
-    if (cacheRetention) {
-        return cacheRetention;
-    }
-    if (getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") {
-        return "long";
-    }
-    return "short";
-}
-function getCompat(model) {
-    const isNativeEndpoint = isOpenAIResponsesNativeEndpoint(model);
-    return {
-        supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
-        sendSessionIdHeader: model.compat?.sendSessionIdHeader ?? true,
-        supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
-        supportsWebSocket: model.compat?.supportsWebSocket ?? isNativeEndpoint,
-        supportsWebSearchPreview: model.compat?.supportsWebSearchPreview ?? isNativeEndpoint,
-    };
-}
-function isOpenAIResponsesNativeEndpoint(model) {
-    const baseUrl = isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl;
-    try {
-        return new URL(baseUrl || "https://api.openai.com/v1").hostname === "api.openai.com";
-    }
-    catch {
-        return false;
-    }
-}
-function getPromptCacheRetention(compat, cacheRetention) {
-    return cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : undefined;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function isOpenAiWebSearchPreviewTool(value) {
-    return isRecord(value) && (value.type === "web_search_preview" || value.type === "web_search_preview_2025_03_11");
-}
-function sanitizeUnsupportedNativeTools(params, compat) {
-    if (compat.supportsWebSearchPreview) {
-        return params;
-    }
-    const payload = params;
-    let sanitized;
-    const nextPayload = () => {
-        sanitized ??= { ...payload };
-        return sanitized;
-    };
-    if (Array.isArray(payload.tools)) {
-        const tools = payload.tools.filter((tool) => !isOpenAiWebSearchPreviewTool(tool));
-        if (tools.length !== payload.tools.length) {
-            const next = nextPayload();
-            if (tools.length > 0) {
-                next.tools = tools;
-            }
-            else {
-                delete next.tools;
-            }
-        }
-    }
-    if (Array.isArray(payload.include)) {
-        const include = payload.include.filter((value) => value !== OPENAI_WEB_SEARCH_SOURCES_INCLUDE);
-        if (include.length !== payload.include.length) {
-            const next = nextPayload();
-            if (include.length > 0) {
-                next.include = include;
-            }
-            else {
-                delete next.include;
-            }
-        }
-    }
-    if (isOpenAiWebSearchPreviewTool(payload.tool_choice)) {
-        delete nextPayload().tool_choice;
-    }
-    return sanitized ? sanitized : params;
-}
-function formatOpenAIResponsesError(error) {
-    if (error instanceof Error) {
-        const status = error.status;
-        const statusCode = typeof status === "number" ? status : undefined;
-        if (statusCode !== undefined) {
-            return `OpenAI API error (${statusCode}): ${error.message}`;
-        }
-        return error.message;
-    }
-    try {
-        return JSON.stringify(error);
-    }
-    catch {
-        return String(error);
-    }
-}
-/**
- * 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;
-            if (!apiKey) {
-                throw new Error(`No API key for provider: ${model.provider}`);
-            }
-            const cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env);
-            const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-            const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, options?.env);
-            let params = buildParams(model, context, options);
-            const nextParams = await options?.onPayload?.(params, model);
-            if (nextParams !== undefined) {
-                params = nextParams;
-            }
-            const compat = getCompat(model);
-            params = sanitizeUnsupportedNativeTools(params, compat);
-            const transport = options?.transport ?? "sse";
-            if (transport !== "sse" && compat.supportsWebSocket) {
-                let websocketStarted = false;
-                try {
-                    await processWebSocketStream(resolveOpenAIResponsesWebSocketUrl(model), params, buildWebSocketHeaders(model, context, apiKey, options?.headers, cacheSessionId), output, stream, model, () => {
-                        websocketStarted = true;
-                    }, options);
-                    if (options?.signal?.aborted) {
-                        throw new Error("Request was aborted");
-                    }
-                    stream.push({ type: "done", reason: getDoneReason(output.stopReason), message: output });
-                    stream.end();
-                    return;
-                }
-                catch (error) {
-                    if (transport === "websocket" || websocketStarted) {
-                        throw error;
-                    }
-                }
-            }
-            const requestOptions = {
-                ...(options?.signal ? { signal: options.signal } : {}),
-                ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                maxRetries: options?.maxRetries ?? 0,
-            };
-            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 = formatOpenAIResponsesError(error);
-            stream.push({ type: "error", reason: output.stopReason, error: output });
-            stream.end();
-        }
-    })();
-    return stream;
-};
-export const streamSimpleOpenAIResponses = (model, context, options) => {
-    const apiKey = options?.apiKey;
-    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 : clampMaxForOpenAI(clampedReasoning, supportsXhigh(model));
-    return streamOpenAIResponses(model, context, {
-        ...base,
-        reasoningEffort,
-    });
-};
-export function register() {
-    registerApiProvider({
-        api: "openai-responses",
-        stream: streamOpenAIResponses,
-        streamSimple: streamSimpleOpenAIResponses,
-    });
-}
-function createClient(model, context, apiKey, optionsHeaders, sessionId, env) {
-    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, env) : model.baseUrl,
-        dangerouslyAllowBrowser: true,
-        defaultHeaders,
-    });
-}
-function buildParams(model, context, options) {
-    const reasoningRequested = options?.reasoningEffort !== undefined || !!options?.reasoningSummary;
-    const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
-        preserveThinking: reasoningRequested,
-    });
-    const cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env);
-    const compat = getCompat(model);
-    const params = {
-        model: model.id,
-        input: messages,
-        stream: true,
-        prompt_cache_key: cacheRetention === "none" ? undefined : clampOpenAIPromptCacheKey(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 (reasoningRequested) {
-            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"),
-            };
-        }
-    }
-    applyExtraBodyToResponsesParams(params, options?.extraBody);
-    return params;
-}
-function applyExtraBodyToResponsesParams(params, extraBody) {
-    if (!extraBody)
-        return;
-    for (const [key, value] of Object.entries(extraBody)) {
-        if (OPENAI_RESPONSES_RESERVED_BODY_KEYS.has(key))
-            continue;
-        Object.defineProperty(params, key, { value, writable: true, enumerable: true, configurable: true });
-    }
-}
-function getDoneReason(stopReason) {
-    if (stopReason === "length" || stopReason === "toolUse")
-        return stopReason;
-    return "stop";
-}
-function getWebSocketConstructor() {
-    const wsConstructor = globalThis.WebSocket;
-    return typeof wsConstructor === "function" ? wsConstructor : null;
-}
-function getWebSocketReadyState(socket) {
-    const readyState = socket.readyState;
-    return typeof readyState === "number" ? readyState : undefined;
-}
-function isWebSocketReusable(socket) {
-    const readyState = getWebSocketReadyState(socket);
-    return readyState === undefined || readyState === 1;
-}
-function closeWebSocketSilently(socket, code = 1000, reason = "done") {
-    try {
-        socket.close(code, reason);
-    }
-    catch { }
-}
-function scheduleSessionWebSocketExpiry(sessionId, entry) {
-    if (entry.idleTimer) {
-        clearTimeout(entry.idleTimer);
-    }
-    entry.idleTimer = setTimeout(() => {
-        if (entry.busy)
-            return;
-        closeWebSocketSilently(entry.socket, 1000, "idle_timeout");
-        websocketSessionCache.delete(sessionId);
-    }, SESSION_WEBSOCKET_CACHE_TTL_MS);
-    const unref = entry.idleTimer.unref;
-    if (unref)
-        unref.call(entry.idleTimer);
-}
-async function connectWebSocket(url, headers, signal) {
-    const WebSocketConstructorValue = getWebSocketConstructor();
-    if (!WebSocketConstructorValue) {
-        throw new Error("WebSocket transport is not available in this runtime");
-    }
-    const websocketHeaders = headersToRecord(headers);
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        let socket;
-        const cleanup = () => {
-            socket.removeEventListener("open", onOpen);
-            socket.removeEventListener("error", onError);
-            socket.removeEventListener("close", onClose);
-            signal?.removeEventListener("abort", onAbort);
-        };
-        const settleReject = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(error);
-        };
-        const onOpen = () => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(socket);
-        };
-        const onError = (event) => {
-            settleReject(extractWebSocketError(event));
-        };
-        const onClose = (event) => {
-            settleReject(extractWebSocketCloseError(event));
-        };
-        const onAbort = () => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            closeWebSocketSilently(socket, 1000, "aborted");
-            reject(new Error("Request was aborted"));
-        };
-        try {
-            socket = new WebSocketConstructorValue(url, { headers: websocketHeaders });
-        }
-        catch (error) {
-            reject(error instanceof Error ? error : new Error(String(error)));
-            return;
-        }
-        socket.addEventListener("open", onOpen);
-        socket.addEventListener("error", onError);
-        socket.addEventListener("close", onClose);
-        signal?.addEventListener("abort", onAbort);
-    });
-}
-async function acquireWebSocket(url, headers, sessionId, signal) {
-    if (!sessionId) {
-        const socket = await connectWebSocket(url, headers, signal);
-        return { socket, release: () => closeWebSocketSilently(socket) };
-    }
-    const cached = websocketSessionCache.get(sessionId);
-    if (cached) {
-        if (cached.idleTimer) {
-            clearTimeout(cached.idleTimer);
-            cached.idleTimer = undefined;
-        }
-        if (!cached.busy && isWebSocketReusable(cached.socket)) {
-            cached.busy = true;
-            return {
-                socket: cached.socket,
-                release: ({ keep } = {}) => {
-                    if (!keep || !isWebSocketReusable(cached.socket)) {
-                        closeWebSocketSilently(cached.socket);
-                        websocketSessionCache.delete(sessionId);
-                        return;
-                    }
-                    cached.busy = false;
-                    scheduleSessionWebSocketExpiry(sessionId, cached);
-                },
-            };
-        }
-        if (!cached.busy) {
-            closeWebSocketSilently(cached.socket);
-            websocketSessionCache.delete(sessionId);
-        }
-    }
-    const socket = await connectWebSocket(url, headers, signal);
-    const entry = { socket, busy: true };
-    websocketSessionCache.set(sessionId, entry);
-    return {
-        socket,
-        release: ({ keep } = {}) => {
-            if (!keep || !isWebSocketReusable(entry.socket)) {
-                closeWebSocketSilently(entry.socket);
-                if (entry.idleTimer)
-                    clearTimeout(entry.idleTimer);
-                if (websocketSessionCache.get(sessionId) === entry) {
-                    websocketSessionCache.delete(sessionId);
-                }
-                return;
-            }
-            entry.busy = false;
-            scheduleSessionWebSocketExpiry(sessionId, entry);
-        },
-    };
-}
-function extractWebSocketError(event) {
-    if (event && typeof event === "object" && "message" in event) {
-        const message = event.message;
-        if (typeof message === "string" && message.length > 0) {
-            return new Error(message);
-        }
-    }
-    return new Error("WebSocket error");
-}
-function extractWebSocketCloseError(event) {
-    if (event && typeof event === "object") {
-        const code = "code" in event ? event.code : undefined;
-        const reason = "reason" in event ? event.reason : undefined;
-        const codeText = typeof code === "number" ? ` ${code}` : "";
-        const reasonText = typeof reason === "string" && reason.length > 0 ? ` ${reason}` : "";
-        return new Error(`WebSocket closed${codeText}${reasonText}`.trim());
-    }
-    return new Error("WebSocket closed");
-}
-async function decodeWebSocketData(data) {
-    if (typeof data === "string")
-        return data;
-    if (data instanceof ArrayBuffer) {
-        return new TextDecoder().decode(new Uint8Array(data));
-    }
-    if (ArrayBuffer.isView(data)) {
-        return new TextDecoder().decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
-    }
-    if (data && typeof data === "object" && "arrayBuffer" in data) {
-        const arrayBuffer = await data.arrayBuffer();
-        return new TextDecoder().decode(new Uint8Array(arrayBuffer));
-    }
-    return null;
-}
-async function* parseWebSocket(socket, signal) {
-    const queue = [];
-    let pending = null;
-    let done = false;
-    let failed = null;
-    let sawCompletion = false;
-    const wake = () => {
-        if (!pending)
-            return;
-        const resolve = pending;
-        pending = null;
-        resolve();
-    };
-    const onMessage = (event) => {
-        void (async () => {
-            if (!event || typeof event !== "object" || !("data" in event))
-                return;
-            const text = await decodeWebSocketData(event.data);
-            if (!text)
-                return;
-            try {
-                const parsed = JSON.parse(text);
-                if (parsed.type === "response.completed" || parsed.type === "response.incomplete") {
-                    sawCompletion = true;
-                    done = true;
-                }
-                queue.push(parsed);
-                wake();
-            }
-            catch { }
-        })();
-    };
-    const onError = (event) => {
-        failed = extractWebSocketError(event);
-        done = true;
-        wake();
-    };
-    const onClose = (event) => {
-        if (!sawCompletion && !failed) {
-            failed = extractWebSocketCloseError(event);
-        }
-        done = true;
-        wake();
-    };
-    const onAbort = () => {
-        failed = new Error("Request was aborted");
-        done = true;
-        wake();
-    };
-    socket.addEventListener("message", onMessage);
-    socket.addEventListener("error", onError);
-    socket.addEventListener("close", onClose);
-    signal?.addEventListener("abort", onAbort);
-    try {
-        while (true) {
-            if (signal?.aborted)
-                throw new Error("Request was aborted");
-            if (queue.length > 0) {
-                const event = queue.shift();
-                if (event)
-                    yield event;
-                continue;
-            }
-            if (done)
-                break;
-            await new Promise((resolve) => {
-                pending = resolve;
-            });
-        }
-        if (failed)
-            throw failed;
-        if (!sawCompletion)
-            throw new Error("WebSocket stream closed before response.completed");
-    }
-    finally {
-        socket.removeEventListener("message", onMessage);
-        socket.removeEventListener("error", onError);
-        socket.removeEventListener("close", onClose);
-        signal?.removeEventListener("abort", onAbort);
-    }
-}
-async function processWebSocketStream(url, params, headers, output, stream, model, onStart, options) {
-    const { socket, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
-    try {
-        socket.send(JSON.stringify({ type: "response.create", ...params }));
-        onStart();
-        await options?.onResponse?.({ status: 101, headers: {} }, model);
-        stream.push({ type: "start", partial: output });
-        await processResponsesStream(parseWebSocket(socket, options?.signal), output, stream, model, {
-            serviceTier: options?.serviceTier,
-            applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
-        });
-    }
-    finally {
-        release({ keep: false });
-    }
-}
-function resolveOpenAIResponsesWebSocketUrl(model) {
-    const baseUrl = isCloudflareProvider(model.provider)
-        ? resolveCloudflareBaseUrl(model)
-        : model.baseUrl || "https://api.openai.com/v1";
-    const url = new URL(baseUrl);
-    if (!url.pathname.endsWith("/responses")) {
-        url.pathname = `${url.pathname.replace(/\/$/, "")}/responses`;
-    }
-    if (url.protocol === "https:")
-        url.protocol = "wss:";
-    else if (url.protocol === "http:")
-        url.protocol = "ws:";
-    return url.toString();
-}
-function buildWebSocketHeaders(model, context, apiKey, optionsHeaders, sessionId) {
-    const headers = new Headers(model.headers);
-    if (model.provider === "github-copilot") {
-        const hasImages = hasCopilotVisionInput(context.messages);
-        const copilotHeaders = buildCopilotDynamicHeaders({ messages: context.messages, hasImages });
-        for (const [key, value] of Object.entries(copilotHeaders)) {
-            headers.set(key, value);
-        }
-    }
-    for (const [key, value] of Object.entries(optionsHeaders || {})) {
-        headers.set(key, value);
-    }
-    if (!headers.has("Authorization")) {
-        headers.set("Authorization", `Bearer ${apiKey}`);
-    }
-    if (sessionId) {
-        const compat = getCompat(model);
-        if (compat.sendSessionIdHeader) {
-            headers.set("session_id", sessionId);
-        }
-        headers.set("x-client-request-id", sessionId);
-    }
-    headers.delete("accept");
-    headers.delete("content-type");
-    headers.delete("OpenAI-Beta");
-    headers.delete("openai-beta");
-    headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
-    return headers;
-}
-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;
-}
+export { stream as streamOpenAIResponses, streamSimple as streamSimpleOpenAIResponses, } from "../api/openai-responses.js";
 //# sourceMappingURL=openai-responses.js.map