@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
237 lines (221 loc) • 11.2 kB
text/typescript
import { diagnoseInvalidToolCalls, isRecord, type InvalidToolCallDiagnostic } from "./tool-call-validation";
import { TranslatorBudgetExceededError, type TranslatorBudget } from "../../lib/translator-budget";
import type { AdapterEvent, OcxProviderConfig, OcxUsage } from "../../types";
import { createInlineThinkContentSplitter } from "../inline-think-tags";
export function stopReasonFor(finishReason: unknown): "max_tokens" | "content_filter" | undefined {
return finishReason === "length"
? "max_tokens"
: finishReason === "content_filter"
? "content_filter"
: undefined;
}
export function reasoningTextFrom(record: Record<string, unknown>): string | undefined {
return typeof record.reasoning_content === "string" && record.reasoning_content.length > 0
? record.reasoning_content
: typeof record.reasoning === "string" && record.reasoning.length > 0
? record.reasoning
: undefined;
}
type ChatContentEvent = Extract<AdapterEvent, { type: "text_delta" | "reasoning_raw_delta" | "error" }>;
/** Mistral can mix typed blocks and strings in one response. Other destinations keep their parser. */
export function chatContentEvents(content: unknown, baseUrl: string, usage?: OcxUsage, buffered = false): ChatContentEvent[] {
if (typeof content === "string") return content.length > 0 || buffered ? [{ type: "text_delta", text: content }] : [];
if (!Array.isArray(content)) return [];
let host: string;
try { host = new URL(baseUrl).hostname; } catch { return []; }
if (host !== "api.mistral.ai") return [];
const invalid = (): ChatContentEvent[] => [{
type: "error", status: 502, errorType: "upstream_error",
message: "unsupported Mistral content block", ...(usage ? { usage } : {}),
}];
const events: ChatContentEvent[] = [];
for (const block of content) {
if (!isRecord(block)) return invalid();
if (block.type === "text" && typeof block.text === "string") {
if (block.text.length > 0 || buffered) events.push({ type: "text_delta", text: block.text });
} else if (block.type === "thinking" && Array.isArray(block.thinking)) {
for (const inner of block.thinking) {
if (!isRecord(inner) || inner.type !== "text" || typeof inner.text !== "string") return invalid();
if (inner.text.length > 0) events.push({ type: "reasoning_raw_delta", text: inner.text });
}
} else return invalid();
}
return events;
}
/** Keep adjacent text together; typed reasoning flushes and resets inline-tag parsing. */
export function createChatContentSplitter(provider: OcxProviderConfig, modelId: string | undefined, budget: TranslatorBudget) {
let splitter = createInlineThinkContentSplitter(provider.inlineThinkTagModels, modelId, budget);
return {
feed(event: ChatContentEvent): AdapterEvent[] {
if (event.type === "error") return [event];
if (event.type === "text_delta") return splitter.feed(event.text);
const pending = splitter.flush();
splitter.dispose();
splitter = createInlineThinkContentSplitter(provider.inlineThinkTagModels, modelId, budget);
return [...pending, event];
},
flush: () => splitter.flush(),
dispose: () => splitter.dispose(),
};
}
/** Split a buffered answer with the same typed-reasoning boundaries as a stream. */
export function splitChatContentEvents(content: unknown, provider: OcxProviderConfig, modelId: string | undefined, budget: TranslatorBudget, usage?: OcxUsage): AdapterEvent[] {
const events = chatContentEvents(content, provider.baseUrl, usage, true);
if (events.some(event => event.type === "error")) return events;
const splitter = createChatContentSplitter(provider, modelId, budget);
try {
return [...events.flatMap(event => splitter.feed(event)), ...splitter.flush()];
} finally {
splitter.dispose();
}
}
export interface ReasoningDetailSegment {
key: string;
text: string;
}
const MAX_REASONING_DETAIL_KEY_BYTES = 1024;
const MAX_REASONING_DETAIL_SEGMENTS = 1024;
/**
* Structured `reasoning_details` array (MiniMax M-series with `reasoning_split`).
* Each segment's key scopes cumulative-snapshot tracking: upstream repeats the
* full text-so-far under a stable `id`/`index` instead of sending increments.
*/
export function reasoningDetailSegmentsFrom(record: Record<string, unknown>): ReasoningDetailSegment[] {
const raw = record.reasoning_details;
if (!Array.isArray(raw)) return [];
const segments: ReasoningDetailSegment[] = [];
for (let i = 0; i < raw.length; i++) {
const item: unknown = raw[i];
if (!isRecord(item)) continue;
if (typeof item.text !== "string" || item.text.length === 0) continue;
// Parsing retains nothing, so it rejects nothing. The non-streaming
// parseResponse path shares this function and reads only `text`; failing a
// whole valid response there because an opaque upstream id is long would be
// a new rejection unrelated to the retention bound. The key cap lives with
// the map that holds the key; see the tracker below.
const key = typeof item.id === "string" && item.id.length > 0
? `id:${item.id}`
: typeof item.index === "number"
? `i:${item.index}`
: `n:${i}`;
segments.push({ key, text: item.text });
}
return segments;
}
/**
* Per-stream cumulative-snapshot store for structured `reasoning_details`. Each stream chunk
* repeats a detail's full text-so-far, so deltas are derived by prefix-diffing per segment key;
* a piece that does not extend the previous snapshot is appended whole, which keeps incremental
* senders parseable on the same path. Retained key+text bytes are charged to the translator
* budget under the `reasoning` kind, and both the key length and the segment count are capped
* here, where the map actually retains them, so a hostile upstream cannot grow it without bound.
*/
export function createReasoningDetailSnapshotTracker(budget: TranslatorBudget): {
ingest(segment: ReasoningDetailSegment): string | null;
release(): void;
} {
const snapshots = new Map<string, string>();
const encoder = new TextEncoder();
let retainedBytes = 0;
return {
ingest(segment) {
const existing = snapshots.get(segment.key);
if (existing === undefined && encoder.encode(segment.key).byteLength > MAX_REASONING_DETAIL_KEY_BYTES) {
throw new TranslatorBudgetExceededError("reasoning", MAX_REASONING_DETAIL_KEY_BYTES);
}
if (existing === undefined && snapshots.size >= MAX_REASONING_DETAIL_SEGMENTS) {
throw new TranslatorBudgetExceededError("reasoning", MAX_REASONING_DETAIL_SEGMENTS);
}
const prev = existing ?? "";
if (segment.text === prev) return null;
const extendsPrev = segment.text.startsWith(prev);
const next = extendsPrev ? segment.text : prev + segment.text;
const previousBytes = existing === undefined
? 0
: encoder.encode(segment.key).byteLength + encoder.encode(prev).byteLength;
const nextBytes = encoder.encode(segment.key).byteLength + encoder.encode(next).byteLength;
const reservation = budget.reserveTransient(nextBytes, { kind: "reasoning" });
try {
snapshots.set(segment.key, next);
reservation.commitRetained();
budget.releaseRetained(previousBytes, { kind: "reasoning" });
retainedBytes += nextBytes - previousBytes;
} catch (error) {
reservation.release();
throw error;
}
return extendsPrev ? segment.text.slice(prev.length) : segment.text;
},
release() {
budget.releaseRetained(retainedBytes, { kind: "reasoning" });
retainedBytes = 0;
snapshots.clear();
},
};
}
/** Single-segment `reasoning_details` entry for replaying preserved reasoning (MiniMax wire shape). */
export function reasoningDetailSegmentForWire(text: string): Record<string, unknown> {
return { type: "reasoning.text", id: "reasoning-text-1", format: "MiniMax-response-v1", index: 0, text };
}
export function invalidChoicesEvent(usage?: OcxUsage): Extract<AdapterEvent, { type: "error" }> {
return {
type: "error",
message: "upstream response contained invalid choices",
...(usage !== undefined ? { usage } : {}),
};
}
export function invalidToolCallsEvent(
rawToolCalls: unknown,
mode: "stream" | "response",
usage?: OcxUsage,
diagnosticOverride?: InvalidToolCallDiagnostic,
): Extract<AdapterEvent, { type: "error" }> {
// The streamed accumulator knows things a rescan cannot: which field on which pending call
// was actually rejected. Without the override, a stream carrying accepted padding on call 0
// and a real defect on call 1 blames call 0, because the stateless scan stops at the first
// structurally odd value it sees.
const diagnostic = diagnosticOverride ?? diagnoseInvalidToolCalls(rawToolCalls, mode);
const detail = diagnostic
? ` (${diagnostic.reason}${diagnostic.callIndex !== undefined ? `; callIndex=${diagnostic.callIndex}` : ""}; valueType=${diagnostic.valueType})`
: "";
return {
type: "error",
status: 502,
errorType: "upstream_error",
message: `upstream response contained invalid tool calls${detail}`,
...(usage !== undefined ? { usage } : {}),
};
}
/**
* A streamed tool call is only dispatchable once the upstream has named the function.
*
* The OpenAI streaming convention puts `function.name` in the first chunk for a tool-call
* index and leaves later chunks carrying only `arguments` deltas, so a stream that never
* sends a name is non-conforming for every provider rather than quirky for one. The
* reference implementations accumulate such a call with an empty name and let the caller
* fail; we sit at the boundary where it would become a Codex tool-call contract event, so
* the equivalent is to refuse to emit it.
*
* Failing closed rather than dropping is deliberate, and matches #1325: a claimed tool call
* that silently disappears can leave the matching result orphaned on the next turn. Naming
* it ourselves is worse still — the id is synthesizable because it is an opaque correlation
* handle, but a function name is a guess at intent.
*/
export function unnamedToolCallEvent(usage?: OcxUsage): Extract<AdapterEvent, { type: "error" }> {
return {
type: "error",
message: "upstream streamed a tool call without a function name — cannot dispatch",
...(usage !== undefined ? { usage } : {}),
};
}
export function usageFromOpenAIChat(usage: Record<string, unknown> | undefined): OcxUsage | undefined {
if (!usage) return undefined;
const promptDetails = usage.prompt_tokens_details as Record<string, number> | undefined;
const completionDetails = usage.completion_tokens_details as Record<string, number> | undefined;
return {
inputTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
outputTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
...(promptDetails?.cached_tokens !== undefined ? { cachedInputTokens: promptDetails.cached_tokens } : {}),
...(completionDetails?.reasoning_tokens !== undefined ? { reasoningOutputTokens: completionDetails.reasoning_tokens } : {}),
};
}