UNPKG

@bitkyc08/opencodex

Version:

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

282 lines (268 loc) • 12.6 kB
import type { OcxUsage } from "../types"; import { debugProviderDiagnostic } from "../lib/debug"; import { kiroTruncationReason } from "./kiro-truncation"; export type ParsedKiroEvent = | { type: "content"; data?: string; modelId?: string } | { type: "reasoning"; data?: string; signature?: string; redactedContent?: string } | { type: "context_usage"; contextUsagePercentage: number } | { type: "metering"; unit: string; usage: number; unitPlural?: string } | { type: "tool"; name?: string; toolUseId?: string; input?: string; stop?: boolean } | { type: "truncation"; data: string } | { type: "metadata"; usage?: OcxUsage; contextUsagePercentage?: number; stopReason?: string; refusal?: KiroRefusalDetails } | { type: "message_metadata"; conversationId?: string } | { type: "invalid_state"; message?: string } | { type: "error"; reason?: string; message?: string }; /** The model-side refusal Kiro attaches to a CONTENT_FILTERED stop (`stopDetails.refusal`). */ export interface KiroRefusalDetails { category?: string; explanation?: string; } const KNOWN_EVENT_TYPES = new Set([ "assistantResponseEvent", "reasoningContentEvent", "toolUseEvent", "messageMetadataEvent", "initial-response", "metadataEvent", // Authoritative context pressure. Every capture (kiro-cli 2.14.1 and 2.16.0) put the percentage // HERE and left `metadataEvent` carrying only `stopReason`; metadataEvent's own // contextUsagePercentage stays supported as a fallback rather than being dropped. "meteringEvent", "contextUsageEvent", "invalidStateEvent", "error", ]); function malformed(eventType: string, detail: string): never { throw new Error(`invalid Kiro ${eventType} payload: ${detail}`); } function parseObject(eventType: string, payload: Uint8Array): Record<string, unknown> { let value: unknown; try { value = JSON.parse(new TextDecoder().decode(payload)); } catch { return malformed(eventType, "expected valid JSON"); } if (!value || typeof value !== "object" || Array.isArray(value)) { return malformed(eventType, "expected an object"); } return value as Record<string, unknown>; } function optionalString(eventType: string, obj: Record<string, unknown>, key: string): string | undefined { const value = obj[key]; if (value === undefined || value === null) return undefined; if (typeof value !== "string") return malformed(eventType, `${key} must be a string`); return value; } function optionalBoolean(eventType: string, obj: Record<string, unknown>, key: string): boolean | undefined { const value = obj[key]; if (value === undefined || value === null) return undefined; if (typeof value !== "boolean") return malformed(eventType, `${key} must be a boolean`); return value; } /** * `stopDetails.refusal` is advisory copy for the user. Read it leniently: an unexpected shape drops * the details rather than turning the refusal itself into a protocol error. Upstream-controlled * text, so each field is bounded. */ function refusalDetails(obj: Record<string, unknown>): KiroRefusalDetails | undefined { const stopDetails = obj.stopDetails; if (!stopDetails || typeof stopDetails !== "object" || Array.isArray(stopDetails)) return undefined; const refusal = (stopDetails as Record<string, unknown>).refusal; if (!refusal || typeof refusal !== "object" || Array.isArray(refusal)) return undefined; /** A non-empty trimmed string field of the refusal, cut to `max` characters, or undefined. */ const field = (key: string, max: number): string | undefined => { const value = (refusal as Record<string, unknown>)[key]; return typeof value === "string" && value.trim() ? value.trim().slice(0, max) : undefined; }; const category = field("category", 64); const explanation = field("explanation", 400); return category || explanation ? { ...(category ? { category } : {}), ...(explanation ? { explanation } : {}) } : undefined; } function tokenCount(eventType: string, obj: Record<string, unknown>, key: string, required: boolean): number { const value = obj[key]; if (value === undefined && !required) return 0; if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) { return malformed(eventType, `${key} must be a non-negative safe integer`); } return value; } /** * A cache counter Kiro did not report, kept as unknown rather than zero (#4546). * * `OcxUsage` omits cache fields it has no reading for, and `cacheHitRate` is null when * unobserved -- the convention everywhere except here. Coercing an absent counter to 0 makes * "the provider said nothing" indistinguishable from "nothing was cached", which is the * difference between a routing change that preserved the prompt cache and one that destroyed * it. A malformed value is still a malformed event; only absence is unknown. */ function optionalTokenCount( eventType: string, obj: Record<string, unknown>, key: string, ): number | undefined { if (obj[key] === undefined) return undefined; return tokenCount(eventType, obj, key, true); } function parseTokenUsage(eventType: string, value: unknown): OcxUsage | undefined { if (value === undefined || value === null) return undefined; if (typeof value !== "object" || Array.isArray(value)) { return malformed(eventType, "tokenUsage must be an object"); } const usage = value as Record<string, unknown>; const uncached = tokenCount(eventType, usage, "uncachedInputTokens", true); const cacheRead = optionalTokenCount(eventType, usage, "cacheReadInputTokens"); const cacheWrite = optionalTokenCount(eventType, usage, "cacheWriteInputTokens"); const outputTokens = tokenCount(eventType, usage, "outputTokens", true); const totalTokens = tokenCount(eventType, usage, "totalTokens", true); // An unreported counter contributes nothing to the total, which is a different statement // from claiming it was measured as zero. const inputTokens = uncached + (cacheRead ?? 0) + (cacheWrite ?? 0); if (!Number.isSafeInteger(inputTokens)) return malformed(eventType, "input token usage overflowed"); return { inputTokens, outputTokens, totalTokens, ...(cacheRead !== undefined ? { cachedInputTokens: cacheRead, cacheReadInputTokens: cacheRead } : {}), ...(cacheWrite !== undefined ? { cacheCreationInputTokens: cacheWrite } : {}), upstreamReported: true, }; } /** Decode a known Kiro event using its Smithy `:event-type` header. */ export function parseKiroEvent(eventType: string, payload: Uint8Array): ParsedKiroEvent | null { // Unknown event types are intentionally ignored without parsing or logging their payload. if (!KNOWN_EVENT_TYPES.has(eventType)) { // The Smithy header is upstream-controlled too; a raw value can contain private data. debugProviderDiagnostic("kiro", "unknown_event", { eventTypeLength: eventType.length }); return null; } const parsed = parseObject(eventType, payload); // A metadataEvent's `stopReason` is Kiro's own terminal verdict and must reach the parser // intact. The generic truncation sniffer matches substrings ("max_tokens", "length", // "context_length") across several keys, so it would swallow MAX_TOKENS before the switch // below ever runs. Gate on position rather than on the value: a value allowlist would keep // eating future reasons such as LENGTH_LIMIT, which matches the pattern today. const nativeStopReason = eventType === "metadataEvent" ? optionalString(eventType, parsed, "stopReason") : undefined; if (nativeStopReason === undefined) { const truncationReason = kiroTruncationReason(parsed); if (truncationReason) return { type: "truncation", data: truncationReason }; } switch (eventType) { case "assistantResponseEvent": return { type: "content", ...(optionalString(eventType, parsed, "content") !== undefined ? { data: optionalString(eventType, parsed, "content") } : {}), ...(optionalString(eventType, parsed, "modelId") !== undefined ? { modelId: optionalString(eventType, parsed, "modelId") } : {}), }; case "reasoningContentEvent": // `text` is plaintext reasoning; the GPT-5.6 family (sol/terra/luna) instead returns an // encrypted blob, and the field it arrives on has to be replayed unchanged (see // kiro/reasoning.ts): `signature` carries the `.KTR~~…` value verbatim and is what every // capture of those models sent, while `redactedContent` — the base64 shape a capture has // never shown — stays accepted for any model that sends it. Keyed off the wire field, not the // model id. Any of the three may be absent on a bare event. { const text = optionalString(eventType, parsed, "text"); const signature = optionalString(eventType, parsed, "signature"); const redacted = optionalString(eventType, parsed, "redactedContent"); return { type: "reasoning", ...(text !== undefined ? { data: text } : {}), ...(signature !== undefined ? { signature } : redacted !== undefined ? { redactedContent: redacted } : {}), }; } case "toolUseEvent": return { type: "tool", ...(optionalString(eventType, parsed, "name") !== undefined ? { name: optionalString(eventType, parsed, "name") } : {}), ...(optionalString(eventType, parsed, "toolUseId") !== undefined ? { toolUseId: optionalString(eventType, parsed, "toolUseId") } : {}), ...(optionalString(eventType, parsed, "input") !== undefined ? { input: optionalString(eventType, parsed, "input") } : {}), ...(optionalBoolean(eventType, parsed, "stop") !== undefined ? { stop: optionalBoolean(eventType, parsed, "stop") } : {}), }; case "meteringEvent": { const unit = optionalString(eventType, parsed, "unit"); if (unit === undefined) { return malformed(eventType, "unit must be a string"); } const unitPlural = optionalString(eventType, parsed, "unitPlural"); const rawUsage = parsed.usage !== undefined ? parsed.usage : parsed.amount; if (typeof rawUsage !== "number" || !Number.isFinite(rawUsage) || rawUsage < 0) { return malformed(eventType, "usage must be a finite non-negative number"); } return { type: "metering", unit, usage: rawUsage, ...(unitPlural !== undefined ? { unitPlural } : {}), }; } case "messageMetadataEvent": case "initial-response": return { type: "message_metadata", conversationId: optionalString(eventType, parsed, "conversationId") ?? optionalString(eventType, parsed, "utteranceId"), }; case "metadataEvent": { const contextUsagePercentage = parsed.contextUsagePercentage; if ( contextUsagePercentage !== undefined && (typeof contextUsagePercentage !== "number" || !Number.isFinite(contextUsagePercentage)) ) { return malformed(eventType, "contextUsagePercentage must be a finite number"); } const stopReason = optionalString(eventType, parsed, "stopReason"); const refusal = refusalDetails(parsed); return { type: "metadata", ...(parseTokenUsage(eventType, parsed.tokenUsage) !== undefined ? { usage: parseTokenUsage(eventType, parsed.tokenUsage) } : {}), ...(typeof contextUsagePercentage === "number" ? { contextUsagePercentage } : {}), ...(stopReason !== undefined ? { stopReason } : {}), ...(refusal ? { refusal } : {}), }; } case "contextUsageEvent": { const contextUsagePercentage = parsed.contextUsagePercentage; if (typeof contextUsagePercentage !== "number" || !Number.isFinite(contextUsagePercentage)) { return malformed(eventType, "contextUsagePercentage must be a finite number"); } return { type: "context_usage", contextUsagePercentage }; } case "invalidStateEvent": return { type: "invalid_state", message: optionalString(eventType, parsed, "message") }; case "error": return { type: "error", reason: optionalString(eventType, parsed, "reason") ?? optionalString(eventType, parsed, "type") ?? optionalString(eventType, parsed, "__type"), message: optionalString(eventType, parsed, "message") ?? optionalString(eventType, parsed, "Message"), }; } return null; }