UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

393 lines (381 loc) • 18.8 kB
import { debugProviderDiagnostic } from "../../lib/debug"; import { isDebugEnabled } from "../../lib/debug-settings"; import { releaseTranslatedEvent, retainTranslatedEvent, type TranslatorBudget, } from "../../lib/translator-budget"; import { resolveKiroApiRegion, resolveKiroRequestProfile } from "../../oauth/kiro"; import { withMissingCreditReading } from "../../usage/credit-billing"; import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig, } from "../../types"; import type { ProviderAdapter } from "../base"; import type { AdapterFetchContext, AdapterRequest } from "../base"; import type { RequestExecutionBudget } from "../../lib/request-execution-budget"; import { safeKiroHttpErrorMessage } from "../kiro-errors"; import { calibrateKiroEstimate } from "../kiro-calibration"; import { normalizeKiroImages } from "../kiro-images"; import type { KiroCompletionMode } from "../kiro-constants"; import { fetchKiroWithRetry, KIRO_FETCH_SEND_LIMIT } from "../kiro-retry"; import { fingerprint, invocationId, osTag } from "../kiro-wire"; import { hasTrailingDeliveredFinalAnswer } from "./conversation"; import { buildKiroPayload } from "./payload"; import type { KiroStructuredOutputSpec } from "./structured-output"; import { jsonStringSerializedUtf8Bytes, parseKiroStream, type KiroFallbackFactory, } from "./stream"; import { estimateKiroInputTokens, estimateKiroLogInputTokens, estimateKiroPayloadInputTokens, kiroPayloadMessages, kiroUpstreamContextWindow, } from "./usage"; import { AMZ_TARGET, KIRO_FALLBACK_SERIALIZATION_ENVELOPE_BYTES, KIRO_IDE_VERSION, kiroCliUserAgent, kiroRuntimeEndpoint, NODE_VERSION, SDK_VERSION, type KiroWireClient, } from "./wire"; /** The physical-send observer an `AdapterFetchContext` may carry, and the record it receives. */ type KiroPhysicalSendObserver = NonNullable<AdapterFetchContext["onPhysicalSend"]>; type KiroPhysicalSend = Parameters<KiroPhysicalSendObserver>[0]; // Adapter export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter { // Per-request closure (resolveAdapter builds a fresh adapter per request — server.ts:440 — so this // is race-free) carrying the heuristic input-token estimate from buildRequest into the stream. let inputTokens = 0; let contextInputEstimate = 0; let modelId: string | undefined; let contextWindow: number | undefined; let toolNameMap: Map<string, string> | undefined; let conversationId: string | undefined; let completionMode: KiroCompletionMode = "disabled"; let structuredOutput: KiroStructuredOutputSpec | undefined; let requestSnapshot: OcxParsedRequest | undefined; let firstRequestBodyBytes = 0; let requestAbortSignal: AbortSignal | undefined; let requestExecutor: typeof globalThis.fetch | undefined; let requestTimeoutMs: number | undefined; // Captured the same way as the abort signal, because the text-fallback rebuild below runs // outside the fetchResponse frame and used to construct a context without either (#4546). let requestSendBudget: RequestExecutionBudget | undefined; // Captured for the same reason, and needed for the same leg to be COUNTABLE rather than merely // bounded: the rebuild's sends were paid for out of the request budget but reported by nobody, // so no regression could pin how many requests one Kiro turn actually makes. let requestOnPhysicalSend: KiroPhysicalSendObserver | undefined; // One ordinal sequence across the whole turn. `fetchKiroWithRetry` numbers from 1 inside each // call, and the caller reads ordinal 1 as the send it already recorded itself; forwarding the // rebuild's raw ordinals would therefore drop its first send — the very send that makes the // fallback a second request rather than a continuation of the first. let physicalSendsObserved = 0; const forwardPhysicalSend = ( send: KiroPhysicalSend, ordinalBase: number, defaultRecovery?: KiroPhysicalSend["recovery"], ): void => { const ordinal = ordinalBase + send.ordinal; if (ordinal > physicalSendsObserved) physicalSendsObserved = ordinal; const recovery = send.recovery ?? defaultRecovery; requestOnPhysicalSend?.({ ordinal, ...(recovery ? { recovery } : {}) }); }; /** * Build the Kiro request for a parsed turn, optionally forcing the completion mode (the bounded * retry passes `text_fallback`), and capture the state the stream parser needs. */ const build = async ( parsed: OcxParsedRequest, forcedCompletionMode?: KiroCompletionMode, ): Promise<{ request: AdapterRequest; nameMap: Map<string, string>; conversationId: string; completionMode: KiroCompletionMode; structuredOutput?: KiroStructuredOutputSpec; inputTokens: number; contextInputEstimate: number; }> => { if (typeof provider.apiKey !== "string" || provider.apiKey.trim() === "") { throw new Error("kiro token missing — run ocx login kiro"); } const region = resolveKiroApiRegion(parsed._kiroAuthContext); // Request-scoped: an AWS Builder ID account has no profile of its own and resolves to Kiro's // fixed service profile here, without that value ever becoming the account's stored identity. const requestProfile = resolveKiroRequestProfile(parsed._kiroAuthContext); const resolvedProfileArn = requestProfile.profileArn; const isApiKey = provider.apiKey.trim().startsWith("ksk_"); const profileArn = isApiKey ? undefined : resolvedProfileArn; // Builder ID and Kiro API keys are accepted only on Kiro's CLI request path; enterprise // profiles retain the IDE-shaped request. Builder ID now carries a profile ARN, so a truthy // `profileArn` no longer implies "enterprise". The wire path reads the resolver's own verdict // rather than re-deriving it, so the accountless path — where the auth type comes from the // local import, not the request context — cannot send the fallback inside an IDE-shaped call. const isBuilderId = requestProfile.builderIdFallback; const wireClient: KiroWireClient = isApiKey || isBuilderId || !profileArn ? "cli" : "ide"; const fp = fingerprint().slice(0, 64); const headers: Record<string, string> = wireClient === "cli" ? { authorization: `Bearer ${provider.apiKey}`, "content-type": "application/x-amz-json-1.0", accept: "*/*", "x-amz-target": AMZ_TARGET, "user-agent": kiroCliUserAgent(true), "x-amz-user-agent": kiroCliUserAgent(false), "x-amzn-codewhisperer-optout": "true", "amz-sdk-request": "attempt=1; max=3", "amz-sdk-invocation-id": invocationId(), ...(isApiKey ? { tokentype: "API_KEY" } : {}), } : { authorization: `Bearer ${provider.apiKey}`, "content-type": "application/x-amz-json-1.0", accept: "application/vnd.amazon.eventstream", "x-amz-target": AMZ_TARGET, "user-agent": `aws-sdk-js/${SDK_VERSION} ua/2.1 os/${osTag()} lang/js md/nodejs#${NODE_VERSION} api/codewhispererstreaming#${SDK_VERSION} m/E KiroIDE-${KIRO_IDE_VERSION}-${fp}`, "x-amz-user-agent": `aws-sdk-js/${SDK_VERSION} KiroIDE-${KIRO_IDE_VERSION}-${fp}`, "x-amzn-codewhisperer-optout": "true", "x-amzn-kiro-agent-mode": "vibe", "amz-sdk-invocation-id": invocationId(), }; if (profileArn) headers["x-amzn-kiro-profile-arn"] = profileArn; const built = buildKiroPayload(parsed, profileArn, forcedCompletionMode, wireClient); await normalizeKiroImages(built.payload); // Apply what earlier turns of THIS conversation measured. An unseen conversation is // unchanged, so a first turn behaves exactly as it would without calibration. const rawContextInputEstimate = estimateKiroPayloadInputTokens(built.payload, parsed.modelId); const contextInputEstimate = calibrateKiroEstimate(built.conversationId, rawContextInputEstimate); const body = JSON.stringify(built.payload); // Every field below is evaluated before the call, so an unguarded call re-encodes the // whole request body on each request even when provider debug is off. Gate the details. if (isDebugEnabled()) { debugProviderDiagnostic("kiro", "request", { region, requestedModel: parsed.modelId, completionMode: built.completionMode, structuredOutput: built.structuredOutput !== undefined, bodyBytes: new TextEncoder().encode(body).length, messageCount: kiroPayloadMessages(parsed).length, toolCount: parsed.context.tools?.length ?? 0, hasProfileArn: Boolean(profileArn), wireClient, hasPreviousResponseId: Boolean(parsed.previousResponseId), }); } return { request: { url: kiroRuntimeEndpoint(provider, region), method: "POST", headers, body, usageLog: { inputTokens: estimateKiroLogInputTokens(parsed), estimated: true }, }, nameMap: built.nameMap, conversationId: built.conversationId, completionMode: built.completionMode, ...(built.structuredOutput ? { structuredOutput: built.structuredOutput } : {}), inputTokens: estimateKiroInputTokens(parsed), contextInputEstimate, }; }; const fallbackFactory: KiroFallbackFactory = async ( returnedConversationId, assistantText, _sawReasoning, budget, onDispatch, ) => { if (!requestSnapshot) throw new Error("Kiro completion retry lost its request state"); if (requestAbortSignal?.aborted) { throw requestAbortSignal.reason instanceof Error ? requestAbortSignal.reason : new DOMException("Kiro request was cancelled", "AbortError"); } const retryParsed = structuredClone(requestSnapshot); retryParsed._providerContinuation = { ...(retryParsed._providerContinuation ?? {}), ...(returnedConversationId ? { kiro: { conversationId: returnedConversationId } } : {}), }; // Reasoning is not replayable on the Kiro wire. Adding an empty assistant turn merely to mark // that reasoning existed creates REQUEST_BODY_INVALID; only visible text earns a replay turn. if (assistantText.trim()) { retryParsed.context.messages.push({ role: "assistant", content: [{ type: "text" as const, text: assistantText }], phase: "commentary", model: retryParsed.modelId, timestamp: Date.now(), }); } // The retry starts from the already measured first wire body, adds one JSON-escaped replay // string, and only changes bounded Kiro-owned fields (completion prompt/tool, history wrapper, // and <=256-byte conversation id). 64 KiB is a conservative envelope for those fixed fields. // Reserve that complete upper bound while the first-attempt collectors are still charged so a // near-cap turn fails before build() can materialize the retry payload or serialized body. const retryBodyUpperBound = firstRequestBodyBytes + jsonStringSerializedUtf8Bytes(assistantText) + KIRO_FALLBACK_SERIALIZATION_ENVELOPE_BYTES; const retryBodyReservation = budget.reserveTransient(retryBodyUpperBound, { kind: "request_copies" }); let retryBodyBytes = 0; let retryBodyRetained = false; let requestBodyReleased = false; const releaseRequestBody = () => { if (requestBodyReleased) return; requestBodyReleased = true; if (retryBodyRetained) budget.releaseRetained(retryBodyBytes, { kind: "request_copies" }); else retryBodyReservation.release(); }; try { const retry = await build(retryParsed, "text_fallback"); retryBodyBytes = Buffer.byteLength(retry.request.body); if (retryBodyBytes > retryBodyUpperBound) { throw new Error("Kiro retry serialization exceeded its pre-admitted upper bound"); } retryBodyReservation.commitRetained(); retryBodyRetained = true; budget.releaseRetained(retryBodyUpperBound - retryBodyBytes, { kind: "request_copies" }); // Fixed before the rebuild dispatches, so the leg's ordinals continue the first attempt's // sequence even though this call's own counter restarts at 1. const fallbackOrdinalBase = physicalSendsObserved; const response = await fetchKiroWithRetry(retry.request, { abortSignal: requestAbortSignal, timeoutMs: requestTimeoutMs, ...(requestExecutor ? { executor: requestExecutor } : {}), allowGatewayRotation: !_sawReasoning && !assistantText.trim(), returnRawErrors: true, stream: true, // The text-fallback rebuild used to construct a fresh context and drop the budget, // so everything after the first send escaped the per-request cap. ...(requestSendBudget ? { sendBudget: requestSendBudget } : {}), // And reported nothing, so the sends it paid for were invisible. Its own first send is // the completion retry itself: the first attempt produced progress without a final // answer, which is the same recovery class the generic empty-completion guard records. onPhysicalSend: (send: KiroPhysicalSend) => { onDispatch?.(); if (requestOnPhysicalSend) forwardPhysicalSend(send, fallbackOrdinalBase, "empty-completion"); }, }); return { response, abortSignal: requestAbortSignal, inputTokens: retry.inputTokens, contextInputEstimate: retry.contextInputEstimate, nameMap: retry.nameMap, conversationId: retry.conversationId, releaseRequestBody, }; } catch (error) { releaseRequestBody(); throw error; } }; async function* parseResponseStream(response: Response, budget: TranslatorBudget): AsyncGenerator<AdapterEvent> { // Only the successful header-time response can provide metering. Capture this before the // parser starts its own fallback, which separately tracks its missing readings. const missingHeaderReading = physicalSendsObserved > 1; for await (const event of parseKiroStream( response, budget, modelId, inputTokens, contextWindow, toolNameMap, conversationId, completionMode, completionMode === "required" ? fallbackFactory : undefined, contextInputEstimate, structuredOutput, )) { if (missingHeaderReading && (event.type === "done" || event.type === "incomplete" || event.type === "error")) { yield { ...event, usage: withMissingCreditReading(event.usage) }; } else { yield event; } } } return { name: "kiro", hostedIterationSendLimit: 2 * KIRO_FETCH_SEND_LIMIT, // Initial fetch and one bounded completion retry. // A replayed history that already ENDS with a delivered final answer has nothing to ask Kiro. // Before this hook the adapter still appended a trailing user turn — a neutral acknowledgement, // but structurally still a prompt — and performed a real inference, so the model answered the // closed task again and the finished turn behaved like a still-open goal. // // Suppressing the completion contract (above) removed the instruction to complete; it could not // remove the inference. This is the boundary: no request is built, nothing is sent, and no token // estimate is recorded. // // The forced-fallback build is deliberately NOT consulted here: this hook runs on the inbound // turn only, and the adapter-owned bounded retry passes "text_fallback" through `build` // directly, never through this path. localTerminal(parsed: OcxParsedRequest) { return hasTrailingDeliveredFinalAnswer(kiroPayloadMessages(parsed), parsed) ? { reason: "kiro_final_answer_already_delivered" } : undefined; }, async buildRequest(parsed: OcxParsedRequest, incoming) { const built = await build(parsed); modelId = parsed.modelId; contextWindow = kiroUpstreamContextWindow(parsed.modelId); inputTokens = built.inputTokens; contextInputEstimate = built.contextInputEstimate; toolNameMap = built.nameMap; conversationId = built.conversationId; completionMode = built.completionMode; structuredOutput = built.structuredOutput; // Runtime callbacks belong to the original request, not the retry payload. requestSnapshot = structuredClone(Object.fromEntries( Object.entries(parsed).filter(([, value]) => typeof value !== "function"), )) as OcxParsedRequest; firstRequestBodyBytes = Buffer.byteLength(built.request.body); requestAbortSignal = incoming?.abortSignal; return built.request; }, /** Parse a streaming Kiro response, with the bounded retry wired to this request. */ parseStream: parseResponseStream, fetchResponse(request: AdapterRequest, ctx?: AdapterFetchContext): Promise<Response> { // The normal Responses path supplies cancellation at fetch time rather than build time. // Keep it for the adapter-owned bounded continuation so cancelling the client turn aborts // both the first Kiro request and its one allowed completion retry. if (ctx?.abortSignal) requestAbortSignal = ctx.abortSignal; requestExecutor = ctx?.executor; requestTimeoutMs = ctx?.timeoutMs; if (ctx?.sendBudget) requestSendBudget = ctx.sendBudget; requestOnPhysicalSend = ctx?.onPhysicalSend; // Reset per fetch call, because `ordinal` is defined within one call and the caller records // ordinal 1 of each new attempt itself. The text fallback that follows this attempt then // continues THIS attempt's sequence rather than an earlier one's. physicalSendsObserved = 0; return fetchKiroWithRetry(request, { ...ctx, returnRawErrors: true, onPhysicalSend: send => forwardPhysicalSend(send, 0), }); }, formatErrorBody(status: number, headers: Headers, payloadText: string): string { return safeKiroHttpErrorMessage(status, headers, payloadText); }, /** * Kiro always returns an event stream, including for non-streaming Responses requests. Drain * the decoder into a budget-owned batch so an upstream stream cannot grow this array without * bound while the caller waits for the complete JSON response. */ async parseResponse(response: Response, budget: TranslatorBudget): Promise<AdapterEvent[]> { const events: AdapterEvent[] = []; try { for await (const e of parseResponseStream(response, budget)) { retainTranslatedEvent(e, budget, events.at(-1)); events.push(e); } return events; } catch (error) { for (const event of events) releaseTranslatedEvent(event, budget); throw error; } }, }; }