@code-yeongyu/senpi 2026.6.21 → 2026.6.30-2

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

@@ -0,0 +1,645 @@
+import OpenAI from "openai";
+import { clampThinkingLevel, supportsXhigh } from "../models.js";
+import { formatProviderError, normalizeProviderError } from "../utils/error-body.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();
+function hasHeader(headers, name) {
+    if (!headers)
+        return false;
+    const expected = name.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === expected && value !== null && value.trim().length > 0)
+            return true;
+    }
+    return false;
+}
+function getClientApiKey(provider, apiKey, headers) {
+    if (apiKey)
+        return apiKey;
+    if (hasHeader(headers, "authorization") || hasHeader(headers, "cf-aig-authorization"))
+        return "unused";
+    throw new Error(`No API key for provider: ${provider}`);
+}
+/**
+ * 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, env) {
+    const isNativeEndpoint = isOpenAIResponsesNativeEndpoint(model, env);
+    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, env) {
+    const baseUrl = isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model, env) : 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) {
+    return formatProviderError(normalizeProviderError(error), "OpenAI API error");
+}
+/**
+ * Generate function for OpenAI Responses API
+ */
+export const stream = (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 {
+            const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
+            const cacheRetention = resolveCacheRetention(options?.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, options?.env);
+            params = sanitizeUnsupportedNativeTools(params, compat);
+            const transport = options?.transport ?? "sse";
+            if (transport !== "sse" && compat.supportsWebSocket) {
+                let websocketStarted = false;
+                try {
+                    await processWebSocketStream(resolveOpenAIResponsesWebSocketUrl(model, options?.env), 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 streamSimple = (model, context, options) => {
+    getClientApiKey(model.provider, options?.apiKey, options?.headers);
+    const base = buildBaseOptions(model, context, options, options?.apiKey);
+    const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+    const reasoningEffort = clampedReasoning === "off" ? undefined : clampMaxForOpenAI(clampedReasoning, supportsXhigh(model));
+    return stream(model, context, {
+        ...base,
+        reasoningEffort,
+    });
+};
+function createClient(model, context, apiKey, optionsHeaders, sessionId, env) {
+    const compat = getCompat(model, env);
+    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);
+    }
+    return new OpenAI({
+        apiKey,
+        baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model, env) : model.baseUrl,
+        dangerouslyAllowBrowser: true,
+        defaultHeaders: headers,
+    });
+}
+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, options?.env);
+    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, env) {
+    const baseUrl = isCloudflareProvider(model.provider)
+        ? resolveCloudflareBaseUrl(model, env)
+        : 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 || {})) {
+        if (value === null) {
+            headers.delete(key);
+        }
+        else {
+            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;
+}
+//# sourceMappingURL=openai-responses.js.map