@code-yeongyu/senpi 2026.5.14 → 2026.5.15-3

package/dist/core/extensions/builtin/compaction/openai-remote.js

@@ -0,0 +1,690 @@
+import { streamSimple, } from "@earendil-works/pi-ai";
+export const OPENAI_REMOTE_COMPACTION_SCHEMA = "senpi.compaction.openai-remote.v1";
+export const SENPI_COMPACTION_EVENT = "senpi:compaction";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonRecord(value) {
+    if (!value?.startsWith("{"))
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseTextSignature(signature) {
+    if (!signature)
+        return undefined;
+    const parsed = parseJsonRecord(signature);
+    if (parsed?.v === 1 && typeof parsed.id === "string") {
+        if (parsed.phase === "commentary" || parsed.phase === "final_answer") {
+            return { id: parsed.id, phase: parsed.phase };
+        }
+        return { id: parsed.id };
+    }
+    return { id: signature };
+}
+function isOpenAiResponsesModel(model) {
+    return model?.provider === "openai" && model.api === "openai-responses";
+}
+function supportsOpenAiResponsesWebSocket(model) {
+    if (model.compat?.supportsWebSocket !== undefined)
+        return model.compat.supportsWebSocket;
+    try {
+        return new URL(model.baseUrl || "https://api.openai.com/v1").hostname === "api.openai.com";
+    }
+    catch {
+        return false;
+    }
+}
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    const parts = [];
+    for (const block of content) {
+        if (block.type !== "text")
+            return undefined;
+        parts.push(block.text);
+    }
+    return parts.join("\n");
+}
+function convertUserContent(content) {
+    if (typeof content === "string")
+        return [{ type: "input_text", text: content }];
+    return content.map((block) => {
+        if (block.type === "text")
+            return { type: "input_text", text: block.text };
+        return {
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${block.mimeType};base64,${block.data}`,
+        };
+    });
+}
+function providerNativeItem(raw) {
+    if (!isRecord(raw) || typeof raw.type !== "string")
+        return undefined;
+    return { ...raw, type: raw.type };
+}
+function convertThinking(block) {
+    const parsed = parseJsonRecord(block.thinkingSignature);
+    if (parsed?.type !== "reasoning")
+        return undefined;
+    return { ...parsed, type: "reasoning" };
+}
+function convertTextBlock(block, messageIndex) {
+    const signature = parseTextSignature(block.textSignature);
+    const item = {
+        type: "message",
+        role: "assistant",
+        status: "completed",
+        id: signature?.id ?? `msg_${messageIndex}`,
+        content: [{ type: "output_text", text: block.text, annotations: [] }],
+        ...(signature?.phase ? { phase: signature.phase } : {}),
+    };
+    return item;
+}
+function convertToolCall(block) {
+    const [callId = block.id, itemId] = block.id.split("|");
+    return {
+        type: "function_call",
+        ...(itemId ? { id: itemId } : {}),
+        call_id: callId,
+        name: block.name,
+        arguments: JSON.stringify(block.arguments ?? {}),
+    };
+}
+function isSameOpenAiResponsesAssistant(message) {
+    return message.provider === "openai" && message.api === "openai-responses";
+}
+function convertAssistantMessage(message, messageIndex) {
+    if (!isSameOpenAiResponsesAssistant(message))
+        return undefined;
+    const items = [];
+    for (const block of message.content) {
+        switch (block.type) {
+            case "text":
+                items.push(convertTextBlock(block, messageIndex));
+                break;
+            case "thinking": {
+                const reasoning = convertThinking(block);
+                if (!reasoning)
+                    return undefined;
+                items.push(reasoning);
+                break;
+            }
+            case "toolCall":
+                items.push(convertToolCall(block));
+                break;
+            case "providerNative": {
+                const item = providerNativeItem(block.raw);
+                if (!item)
+                    return undefined;
+                items.push(item);
+                break;
+            }
+        }
+    }
+    return items.length > 0 ? items : undefined;
+}
+function convertAgentMessage(message, messageIndex) {
+    switch (message.role) {
+        case "user":
+            return [{ role: "user", content: convertUserContent(message.content) }];
+        case "assistant":
+            return convertAssistantMessage(message, messageIndex);
+        case "toolResult": {
+            const [callId = message.toolCallId] = message.toolCallId.split("|");
+            const output = toolResultText(message.content);
+            if (output === undefined)
+                return undefined;
+            return [{ type: "function_call_output", call_id: callId, output }];
+        }
+        case "bashExecution":
+        case "branchSummary":
+        case "compactionSummary":
+        case "custom":
+            return undefined;
+        default: {
+            const exhaustive = message;
+            return exhaustive;
+        }
+    }
+}
+function detailsFromEntry(entry) {
+    if (entry.type !== "compaction")
+        return undefined;
+    return getOpenAiRemoteCompactionDetails(entry.details);
+}
+export function getOpenAiRemoteCompactionDetails(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (value.schema !== OPENAI_REMOTE_COMPACTION_SCHEMA || value.mode !== "openai-remote")
+        return undefined;
+    if (value.provider !== "openai" || value.api !== "openai-responses")
+        return undefined;
+    if (typeof value.modelId !== "string" || typeof value.responseId !== "string")
+        return undefined;
+    if (typeof value.createdAt !== "number")
+        return undefined;
+    if (typeof value.requestInputItemCount !== "number" || typeof value.retainedInputItemCount !== "number") {
+        return undefined;
+    }
+    if (!Array.isArray(value.replacementInput))
+        return undefined;
+    return {
+        schema: OPENAI_REMOTE_COMPACTION_SCHEMA,
+        mode: "openai-remote",
+        provider: "openai",
+        api: "openai-responses",
+        transport: value.transport === "websocket" ? "websocket" : "compact-endpoint",
+        modelId: value.modelId,
+        responseId: value.responseId,
+        createdAt: value.createdAt,
+        requestInputItemCount: value.requestInputItemCount,
+        retainedInputItemCount: value.retainedInputItemCount,
+        replacementInput: value.replacementInput.filter((item) => isRecord(item)),
+        ...(isRecord(value.usage) ? { usage: value.usage } : {}),
+    };
+}
+function convertBranchEntries(entries) {
+    const items = [];
+    let messageIndex = 0;
+    for (const entry of entries) {
+        switch (entry.type) {
+            case "message": {
+                const converted = convertAgentMessage(entry.message, messageIndex);
+                if (!converted)
+                    return undefined;
+                items.push(...converted);
+                messageIndex++;
+                break;
+            }
+            case "compaction": {
+                const details = detailsFromEntry(entry);
+                if (!details)
+                    return undefined;
+                items.push(...details.replacementInput);
+                break;
+            }
+            case "branch_summary":
+            case "custom_message":
+                return undefined;
+            case "thinking_level_change":
+            case "model_change":
+            case "custom":
+            case "label":
+            case "session_info":
+                break;
+        }
+    }
+    return items;
+}
+export function createOpenAiRemoteCompactionRequest(options) {
+    if (!isOpenAiResponsesModel(options.model))
+        return undefined;
+    const input = convertBranchEntries(options.branchEntries);
+    if (!input || input.length === 0)
+        return undefined;
+    return {
+        body: {
+            model: options.model.id,
+            input,
+            ...(options.systemPrompt ? { instructions: options.systemPrompt } : {}),
+            ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
+            ...(options.serviceTier ? { service_tier: options.serviceTier } : {}),
+        },
+        inputItemCount: input.length,
+        tokensBefore: options.tokensBefore,
+    };
+}
+function isOpenAiCompactionItem(item) {
+    return item.type === "compaction" && typeof item.encrypted_content === "string";
+}
+function isOpenAiContextCompactionItem(item) {
+    return item.type === "context_compaction" && typeof item.encrypted_content === "string";
+}
+function isOpenAiRemoteCompactionOutputItem(item) {
+    return isOpenAiCompactionItem(item) || isOpenAiContextCompactionItem(item);
+}
+function isRetainedRemoteOutputItem(item) {
+    if (isOpenAiRemoteCompactionOutputItem(item))
+        return true;
+    return item.type === "message" && (item.role === "user" || item.role === "system" || item.role === "developer");
+}
+function isRetainedResponsesStreamInputItem(item) {
+    if (item.type === "message")
+        return item.role === "user";
+    return "role" in item && item.role === "user";
+}
+function isOpenAiCompactedResponse(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.object !== "response.compaction" || typeof value.id !== "string" || typeof value.created_at !== "number") {
+        return false;
+    }
+    return Array.isArray(value.output);
+}
+export function buildOpenAiRemoteCompactionResult(options) {
+    const replacementInput = options.response.output.filter(isRetainedRemoteOutputItem);
+    const compactionItem = replacementInput.find(isOpenAiRemoteCompactionOutputItem);
+    if (!compactionItem) {
+        throw new Error("OpenAI remote compaction did not return a compaction item");
+    }
+    const details = {
+        schema: OPENAI_REMOTE_COMPACTION_SCHEMA,
+        mode: "openai-remote",
+        provider: "openai",
+        api: "openai-responses",
+        transport: "compact-endpoint",
+        modelId: options.model.id,
+        responseId: options.response.id,
+        createdAt: options.response.created_at,
+        requestInputItemCount: options.requestInputItemCount,
+        retainedInputItemCount: replacementInput.length,
+        replacementInput,
+        ...(options.response.usage ? { usage: options.response.usage } : {}),
+    };
+    return {
+        summary: [
+            "OpenAI remote compaction checkpoint.",
+            `Native /v1/responses/compact replay is active for ${replacementInput.length.toLocaleString()} retained item(s).`,
+            `Original OpenAI input items compacted: ${options.requestInputItemCount.toLocaleString()}.`,
+        ].join("\n"),
+        firstKeptEntryId: options.firstKeptEntryId,
+        tokensBefore: options.tokensBefore,
+        details,
+    };
+}
+function compactEndpointUrl(model) {
+    const baseUrl = model.baseUrl || "https://api.openai.com/v1";
+    return new URL("responses/compact", baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).toString();
+}
+function createHeaders(auth) {
+    const headers = new Headers(auth.headers);
+    headers.set("content-type", "application/json");
+    if (!headers.has("authorization") && auth.apiKey) {
+        headers.set("authorization", `Bearer ${auth.apiKey}`);
+    }
+    return headers.has("authorization") ? headers : undefined;
+}
+function createOpenAiResponsesStreamCompactionInput(request) {
+    return [...request.body.input, { type: "context_compaction" }];
+}
+export function createOpenAiResponsesStreamCompactionPayload(payload, request) {
+    if (!isRecord(payload))
+        return undefined;
+    return {
+        ...payload,
+        model: request.body.model,
+        input: [...leadingPromptMessages(payload.input), ...createOpenAiResponsesStreamCompactionInput(request)],
+        ...(request.body.prompt_cache_key ? { prompt_cache_key: request.body.prompt_cache_key } : {}),
+        ...(request.body.service_tier ? { service_tier: request.body.service_tier } : {}),
+    };
+}
+function findResponsesStreamCompactionOutput(message) {
+    for (const block of message.content) {
+        if (block.type !== "providerNative")
+            continue;
+        const item = providerNativeItem(block.raw);
+        if (item && isOpenAiContextCompactionItem(item))
+            return item;
+    }
+    return undefined;
+}
+function usageRecordFromAssistant(message) {
+    return {
+        input: message.usage.input,
+        output: message.usage.output,
+        cacheRead: message.usage.cacheRead,
+        cacheWrite: message.usage.cacheWrite,
+        totalTokens: message.usage.totalTokens,
+    };
+}
+export function buildOpenAiResponsesStreamCompactionResult(options) {
+    const compactionItem = findResponsesStreamCompactionOutput(options.response);
+    if (!compactionItem) {
+        throw new Error("OpenAI Responses stream compaction did not return a context_compaction item");
+    }
+    const retainedInput = options.requestInput.filter(isRetainedResponsesStreamInputItem);
+    const replacementInput = [...retainedInput, compactionItem];
+    const details = {
+        schema: OPENAI_REMOTE_COMPACTION_SCHEMA,
+        mode: "openai-remote",
+        provider: "openai",
+        api: "openai-responses",
+        transport: "websocket",
+        modelId: options.model.id,
+        responseId: options.response.responseId ?? `response-${options.now()}`,
+        createdAt: Math.floor(options.response.timestamp / 1000),
+        requestInputItemCount: options.requestInput.length,
+        retainedInputItemCount: replacementInput.length,
+        replacementInput,
+        usage: usageRecordFromAssistant(options.response),
+    };
+    return {
+        summary: [
+            "OpenAI remote compaction checkpoint.",
+            `Native Responses WebSocket replay is active for ${replacementInput.length.toLocaleString()} retained item(s).`,
+            `Original OpenAI input items compacted: ${options.requestInput.length.toLocaleString()}.`,
+        ].join("\n"),
+        firstKeptEntryId: options.firstKeptEntryId,
+        tokensBefore: options.tokensBefore,
+        details,
+    };
+}
+async function runOpenAiResponsesStreamCompaction(options) {
+    const stream = options.streamRunner(options.model, { systemPrompt: options.systemPrompt, messages: [] }, {
+        apiKey: options.auth.apiKey,
+        cacheRetention: "short",
+        extraBody: options.auth.extraBody,
+        headers: options.auth.headers,
+        onPayload: (payload) => {
+            const rewritten = createOpenAiResponsesStreamCompactionPayload(payload, options.request);
+            if (!isRecord(rewritten) || !Array.isArray(rewritten.input)) {
+                throw new Error("Unable to build OpenAI Responses stream compaction payload");
+            }
+            return rewritten;
+        },
+        sessionId: options.request.body.prompt_cache_key,
+        signal: options.signal,
+        transport: "websocket",
+    });
+    const response = await stream.result();
+    if (response.stopReason === "error" || response.stopReason === "aborted") {
+        return undefined;
+    }
+    return buildOpenAiResponsesStreamCompactionResult({
+        model: options.model,
+        firstKeptEntryId: options.firstKeptEntryId,
+        tokensBefore: options.request.tokensBefore,
+        requestInput: options.request.body.input,
+        response,
+        now: options.now,
+    });
+}
+async function runOpenAiCompactEndpointCompaction(options) {
+    options.emit?.({
+        version: 1,
+        action: "remote_started",
+        route: "builtin.compaction.openai_remote",
+        requestId: options.requestId,
+        modelId: options.model.id,
+        inputItemCount: options.request.inputItemCount,
+        transport: "compact-endpoint",
+    });
+    let response;
+    try {
+        response = await options.fetchImpl(compactEndpointUrl(options.model), {
+            method: "POST",
+            headers: options.headers,
+            body: JSON.stringify(options.request.body),
+            signal: options.signal,
+        });
+    }
+    catch (error) {
+        if (options.signal.aborted)
+            throw error;
+        options.emit?.({
+            version: 1,
+            action: "remote_fallback",
+            route: "builtin.compaction.openai_remote",
+            requestId: options.requestId,
+            modelId: options.model.id,
+            reason: error instanceof Error ? error.message : String(error),
+            transport: "compact-endpoint",
+        });
+        return undefined;
+    }
+    if (!response.ok) {
+        options.emit?.({
+            version: 1,
+            action: "remote_fallback",
+            route: "builtin.compaction.openai_remote",
+            requestId: options.requestId,
+            modelId: options.model.id,
+            reason: `HTTP ${response.status}`,
+            transport: "compact-endpoint",
+        });
+        return undefined;
+    }
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch (error) {
+        options.emit?.({
+            version: 1,
+            action: "remote_fallback",
+            route: "builtin.compaction.openai_remote",
+            requestId: options.requestId,
+            modelId: options.model.id,
+            reason: error instanceof Error ? error.message : String(error),
+            transport: "compact-endpoint",
+        });
+        return undefined;
+    }
+    if (!isOpenAiCompactedResponse(payload)) {
+        options.emit?.({
+            version: 1,
+            action: "remote_fallback",
+            route: "builtin.compaction.openai_remote",
+            requestId: options.requestId,
+            modelId: options.model.id,
+            reason: "invalid-compact-response",
+            transport: "compact-endpoint",
+        });
+        return undefined;
+    }
+    let result;
+    try {
+        result = buildOpenAiRemoteCompactionResult({
+            model: options.model,
+            firstKeptEntryId: options.firstKeptEntryId,
+            tokensBefore: options.request.tokensBefore,
+            requestInputItemCount: options.request.inputItemCount,
+            response: payload,
+        });
+    }
+    catch (error) {
+        options.emit?.({
+            version: 1,
+            action: "remote_fallback",
+            route: "builtin.compaction.openai_remote",
+            requestId: options.requestId,
+            modelId: options.model.id,
+            reason: error instanceof Error ? error.message : String(error),
+            transport: "compact-endpoint",
+        });
+        return undefined;
+    }
+    options.emit?.({
+        version: 1,
+        action: "remote_completed",
+        route: "builtin.compaction.openai_remote",
+        requestId: options.requestId,
+        modelId: options.model.id,
+        responseId: payload.id,
+        retainedInputItemCount: result.details.retainedInputItemCount,
+        transport: "compact-endpoint",
+    });
+    return result;
+}
+export async function runOpenAiRemoteCompaction(ctx, event, emit, dependencies = {}) {
+    const model = ctx.model;
+    if (!isOpenAiResponsesModel(model) || event.reason === "branch") {
+        emit?.({
+            version: 1,
+            action: "remote_fallback",
+            route: "builtin.compaction.openai_remote",
+            requestId: event.requestId,
+            modelId: model?.id,
+            reason: event.reason === "branch" ? "branch-compaction" : "not-openai-responses",
+        });
+        return undefined;
+    }
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok) {
+        emit?.({
+            version: 1,
+            action: "remote_fallback",
+            route: "builtin.compaction.openai_remote",
+            requestId: event.requestId,
+            modelId: model.id,
+            reason: auth.error,
+        });
+        return undefined;
+    }
+    const requestModel = auth.upstreamModelId ? { ...model, id: auth.upstreamModelId } : model;
+    const serviceTier = ctx.serviceTier ?? auth.serviceTier;
+    const request = createOpenAiRemoteCompactionRequest({
+        model: requestModel,
+        systemPrompt: ctx.getSystemPrompt(),
+        branchEntries: event.branchEntries,
+        tokensBefore: event.preparation.tokensBefore,
+        promptCacheKey: ctx.sessionManager.getSessionId(),
+        serviceTier,
+    });
+    if (!request) {
+        emit?.({
+            version: 1,
+            action: "remote_fallback",
+            route: "builtin.compaction.openai_remote",
+            requestId: event.requestId,
+            modelId: model.id,
+            reason: "session-not-openai-native",
+        });
+        return undefined;
+    }
+    if (supportsOpenAiResponsesWebSocket(requestModel)) {
+        emit?.({
+            version: 1,
+            action: "remote_started",
+            route: "builtin.compaction.openai_remote",
+            requestId: event.requestId,
+            modelId: requestModel.id,
+            inputItemCount: request.inputItemCount,
+            transport: "websocket",
+        });
+        try {
+            const result = await runOpenAiResponsesStreamCompaction({
+                model: requestModel,
+                auth,
+                firstKeptEntryId: event.preparation.firstKeptEntryId,
+                now: dependencies.now ?? Date.now,
+                request,
+                signal: event.signal,
+                streamRunner: dependencies.streamRunner ??
+                    ((streamModel, context, options) => streamSimple(streamModel, context, options)),
+                systemPrompt: ctx.getSystemPrompt(),
+            });
+            if (result) {
+                emit?.({
+                    version: 1,
+                    action: "remote_completed",
+                    route: "builtin.compaction.openai_remote",
+                    requestId: event.requestId,
+                    modelId: requestModel.id,
+                    responseId: result.details.responseId,
+                    retainedInputItemCount: result.details.retainedInputItemCount,
+                    transport: "websocket",
+                });
+                return result;
+            }
+            emit?.({
+                version: 1,
+                action: "remote_fallback",
+                route: "builtin.compaction.openai_remote",
+                requestId: event.requestId,
+                modelId: requestModel.id,
+                reason: "websocket-compaction-no-result",
+                transport: "websocket",
+            });
+        }
+        catch (error) {
+            if (event.signal.aborted)
+                throw error;
+            emit?.({
+                version: 1,
+                action: "remote_fallback",
+                route: "builtin.compaction.openai_remote",
+                requestId: event.requestId,
+                modelId: requestModel.id,
+                reason: error instanceof Error ? error.message : String(error),
+                transport: "websocket",
+            });
+        }
+    }
+    const headers = createHeaders(auth);
+    if (!headers) {
+        emit?.({
+            version: 1,
+            action: "remote_fallback",
+            route: "builtin.compaction.openai_remote",
+            requestId: event.requestId,
+            modelId: model.id,
+            reason: "missing-openai-auth",
+        });
+        return undefined;
+    }
+    return runOpenAiCompactEndpointCompaction({
+        fetchImpl: dependencies.fetch ?? fetch,
+        headers,
+        model: requestModel,
+        request,
+        requestId: event.requestId,
+        signal: event.signal,
+        firstKeptEntryId: event.preparation.firstKeptEntryId,
+        emit,
+    });
+}
+function latestRemoteCompaction(entries) {
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const entry = entries[index];
+        if (entry?.type !== "compaction")
+            continue;
+        const details = getOpenAiRemoteCompactionDetails(entry.details);
+        if (details)
+            return { entryId: entry.id, index, details };
+        return undefined;
+    }
+    return undefined;
+}
+function leadingPromptMessages(input) {
+    if (!Array.isArray(input))
+        return [];
+    const result = [];
+    for (const item of input) {
+        if (!isRecord(item))
+            break;
+        const role = item.role;
+        if (role !== "system" && role !== "developer")
+            break;
+        result.push(providerNativeItem(item) ?? { role, content: typeof item.content === "string" ? item.content : [] });
+    }
+    return result;
+}
+export function rewriteOpenAiPayloadWithRemoteCompaction(payload, options, emit) {
+    if (!isOpenAiResponsesModel(options.model) || !isRecord(payload))
+        return undefined;
+    const remote = latestRemoteCompaction(options.branchEntries);
+    if (!remote)
+        return undefined;
+    const postCompactionItems = convertBranchEntries(options.branchEntries.slice(remote.index + 1));
+    if (!postCompactionItems)
+        return undefined;
+    const input = [...leadingPromptMessages(payload.input), ...remote.details.replacementInput, ...postCompactionItems];
+    emit?.({
+        version: 1,
+        action: "remote_payload_rewritten",
+        route: "builtin.compaction.openai_remote",
+        modelId: options.model.id,
+        compactionEntryId: remote.entryId,
+        inputItemCount: input.length,
+    });
+    return { ...payload, input };
+}
+//# sourceMappingURL=openai-remote.js.map