@vib-rato/ai 0.16.0

package/src/providers/openai-anthropic-shim.ts

@@ -0,0 +1,156 @@
+/**
+ * Shared implementation for providers that expose BOTH an OpenAI-compatible
+ * and an Anthropic-compatible API surface against the same model catalog
+ * (currently Kimi Code and Synthetic).
+ *
+ * Each call site supplies the provider-specific bits (base URLs, default
+ * format, optional extra headers); the streaming/forwarding plumbing lives
+ * here once.
+ */
+
+import { copyProviderSafetyStopAdapterInvocation } from "../adapter-internals/provider-safety-stop";
+import { ANTHROPIC_THINKING } from "../stream";
+import type { Context, Model, SimpleStreamOptions } from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+import { createProviderErrorMessage } from "./error-message";
+import { streamAnthropic, streamOpenAICompletions } from "./register-builtins";
+
+export type OpenAIAnthropicApiFormat = "openai" | "anthropic";
+
+export interface OpenAIAnthropicShimOptions extends SimpleStreamOptions {
+	/** API format: "openai" or "anthropic". */
+	format?: OpenAIAnthropicApiFormat;
+}
+
+export interface OpenAIAnthropicShimConfig {
+	/** Base URL for the Anthropic-compatible endpoint (without trailing /v1/messages). */
+	anthropicBaseUrl: string;
+	/** Optional override for the OpenAI-compatible base URL. If omitted, `model.baseUrl` is used as-is. */
+	openaiBaseUrl?: string;
+	/** Default API format when caller does not specify one. */
+	defaultFormat: OpenAIAnthropicApiFormat;
+	/** Provider-specific headers (e.g. auth/session) merged ahead of user-supplied headers. */
+	extraHeaders?: () => Record<string, string>;
+}
+
+/**
+ * Stream from an OpenAI-or-Anthropic compatible provider. Returns synchronously;
+ * async header fetching and stream piping happen internally.
+ */
+export function streamOpenAIAnthropicShim(
+	model: Model<"openai-completions">,
+	context: Context,
+	options: OpenAIAnthropicShimOptions | undefined,
+	config: OpenAIAnthropicShimConfig,
+): AssistantMessageEventStream {
+	const stream = new AssistantMessageEventStream();
+	const format = options?.format ?? config.defaultFormat;
+
+	(async () => {
+		try {
+			const mergedHeaders = {
+				...(config.extraHeaders?.() ?? {}),
+				...options?.headers,
+			};
+
+			if (format === "anthropic") {
+				const anthropicModel: Model<"anthropic-messages"> = {
+					id: model.id,
+					name: model.name,
+					api: "anthropic-messages",
+					provider: model.provider,
+					baseUrl: config.anthropicBaseUrl,
+					headers: mergedHeaders,
+					contextWindow: model.contextWindow,
+					maxTokens: model.maxTokens,
+					reasoning: model.reasoning,
+					thinking: model.thinking,
+					input: model.input,
+					cost: model.cost,
+				};
+
+				const reasoningEffort = options?.reasoning;
+				const thinkingEnabled = !!reasoningEffort && model.reasoning;
+				const thinkingBudget = reasoningEffort
+					? (options?.thinkingBudgets?.[reasoningEffort] ?? ANTHROPIC_THINKING[reasoningEffort])
+					: undefined;
+
+				const innerStream = streamAnthropic(
+					anthropicModel,
+					context,
+					copyProviderSafetyStopAdapterInvocation(options, {
+						...options,
+						apiKey: options?.apiKey,
+						temperature: options?.temperature,
+						topP: options?.topP,
+						topK: options?.topK,
+						minP: options?.minP,
+						presencePenalty: options?.presencePenalty,
+						repetitionPenalty: options?.repetitionPenalty,
+						maxTokens: options?.maxTokens ?? Math.min(model.maxTokens, 32000),
+						signal: options?.signal,
+						headers: mergedHeaders,
+						sessionId: options?.sessionId,
+						onPayload: options?.onPayload,
+						attemptScope: options?.attemptScope,
+						onResponse: options?.onResponse,
+						onSseEvent: options?.onSseEvent,
+						fetch: options?.fetch,
+						streamIdleTimeoutMs: options?.streamIdleTimeoutMs,
+						streamFirstEventTimeoutMs: options?.streamFirstEventTimeoutMs,
+						thinkingEnabled,
+						thinkingBudgetTokens: thinkingBudget,
+					}),
+				);
+
+				for await (const event of innerStream) {
+					stream.push(event);
+				}
+			} else {
+				const openaiModel: Model<"openai-completions"> = config.openaiBaseUrl
+					? { ...model, baseUrl: config.openaiBaseUrl, headers: mergedHeaders }
+					: model;
+
+				const reasoningEffort = options?.reasoning;
+				const innerStream = streamOpenAICompletions(
+					openaiModel,
+					context,
+					copyProviderSafetyStopAdapterInvocation(options, {
+						...options,
+						apiKey: options?.apiKey,
+						temperature: options?.temperature,
+						topP: options?.topP,
+						topK: options?.topK,
+						minP: options?.minP,
+						presencePenalty: options?.presencePenalty,
+						repetitionPenalty: options?.repetitionPenalty,
+						maxTokens: options?.maxTokens ?? model.maxTokens,
+						signal: options?.signal,
+						headers: mergedHeaders,
+						sessionId: options?.sessionId,
+						onPayload: options?.onPayload,
+						attemptScope: options?.attemptScope,
+						onResponse: options?.onResponse,
+						onSseEvent: options?.onSseEvent,
+						fetch: options?.fetch,
+						streamIdleTimeoutMs: options?.streamIdleTimeoutMs,
+						streamFirstEventTimeoutMs: options?.streamFirstEventTimeoutMs,
+						reasoning: reasoningEffort,
+					}),
+				);
+
+				for await (const event of innerStream) {
+					stream.push(event);
+				}
+			}
+		} catch (err) {
+			stream.push({
+				type: "error",
+				reason: "error",
+				error: createProviderErrorMessage(model, err),
+			});
+		}
+	})();
+
+	return stream;
+}

package/src/providers/openai-bounded-rate-limits.d.ts

@@ -0,0 +1,3 @@
+import type { FetchImpl } from "../types";
+export declare function isOpenAIUsageExhaustionResponse(bodyText: string, retryAfterMs: number | undefined, retryDelayCapMs: number): boolean;
+export declare function wrapOpenAIFetchForBoundedRateLimits(baseFetch: FetchImpl, maxRetryDelayMs: number | undefined): FetchImpl;

package/src/providers/openai-bounded-rate-limits.ts

@@ -0,0 +1,57 @@
+import type { FetchImpl } from "../types";
+import { getRetryAfterMsFromHeaders } from "../utils/retry-after";
+
+const OPENAI_RETRY_DELAY_CAP_MS = 60_000;
+
+// Mirror of `wrapAnthropicFetchForBoundedRateLimits`: OpenAI-compatible providers
+// (e.g. opencode-go) return HTTP 429 for *permanent* usage/quota exhaustion — a
+// monthly-cap reset that can be days away. The OpenAI SDK treats 429 as transient
+// and retries up to `maxRetries`, honoring an out-of-range `Retry-After`; the
+// `create()` call then hangs before the error can surface to the agent loop, so
+// no assistant error is produced and the session-level retry/fallback never runs.
+// Detect exhaustion and set `x-should-retry: false` so the SDK gives up at once
+// and the session retry layer applies its own fail-fast (retry-after > maxDelayMs).
+//
+// Shared by every adapter that drives a raw OpenAI SDK client — openai-completions,
+// openai-responses, and azure-openai-responses. Adapters that route through
+// `fetchWithRetry` (codex, bedrock, ollama, gemini-cli) already bound 429 retries
+// themselves and do not need this wrapper.
+export function isOpenAIUsageExhaustionResponse(
+	bodyText: string,
+	retryAfterMs: number | undefined,
+	retryDelayCapMs: number,
+): boolean {
+	if (retryAfterMs !== undefined && retryAfterMs > retryDelayCapMs) return true;
+	return /monthly usage limit|usage limit reached|usage_limit_reached|out_of_credits|insufficient_quota|quota[ _]?exceeded/i.test(
+		bodyText,
+	);
+}
+
+export function wrapOpenAIFetchForBoundedRateLimits(
+	baseFetch: FetchImpl,
+	maxRetryDelayMs: number | undefined,
+): FetchImpl {
+	const retryDelayCapMs = maxRetryDelayMs ?? OPENAI_RETRY_DELAY_CAP_MS;
+	return Object.assign(
+		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+			const response = await baseFetch(input, init);
+			if (response.status !== 429 || retryDelayCapMs === 0) return response;
+
+			const headers = new Headers(response.headers);
+			const retryAfterMs = getRetryAfterMsFromHeaders(headers);
+			const bodyText = await response
+				.clone()
+				.text()
+				.catch(() => "");
+			if (!isOpenAIUsageExhaustionResponse(bodyText, retryAfterMs, retryDelayCapMs)) return response;
+
+			headers.set("x-should-retry", "false");
+			return new Response(bodyText, {
+				status: response.status,
+				statusText: response.statusText,
+				headers,
+			});
+		},
+		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
+	);
+}

package/src/providers/openai-chat-server-schema.ts

@@ -0,0 +1,254 @@
+/**
+ * Zod schemas for the OpenAI chat-completions request shape we accept on the
+ * gateway. Mirrors https://platform.openai.com/docs/api-reference/chat — only
+ * the shapes the gateway translation layer understands. Unknown fields on
+ * permissive objects are accepted-and-stripped (via `z.unknown()` passthroughs
+ * or `.loose()`) so the official OpenAI SDK — which sends a growing pile of
+ * non-strict defaults (e.g. `stream_options.include_obfuscation`) — does not
+ * trip 400s on shapes we simply ignore.
+ */
+import type {
+	ChatCompletionContentPart,
+	ChatCompletionCreateParams,
+	ChatCompletionMessageParam,
+	ChatCompletionMessageToolCall,
+	ChatCompletionTool,
+	ChatCompletionToolChoiceOption,
+} from "openai/resources/chat/completions";
+import * as z from "zod/v4";
+
+// ─── User-message content parts ─────────────────────────────────────────────
+
+export const textPartSchema = z.object({
+	type: z.literal("text"),
+	text: z.string(),
+});
+
+/**
+ * OpenAI documents `image_url` as either `{ url: string, detail?: ... }` or —
+ * older clients — a bare string. Accept both shapes; downstream we extract a
+ * URL. `detail` is accepted for forward-compat but currently dropped (pi-ai's
+ * `ImageContent` has no detail field — TODO: plumb through if/when added).
+ */
+export const imagePartSchema = z.object({
+	type: z.literal("image_url"),
+	image_url: z.union([
+		z.string(),
+		z.object({
+			url: z.string(),
+			detail: z.enum(["auto", "low", "high"]).optional(),
+		}),
+	]),
+});
+
+/** OpenAI audio input block (gpt-4o-audio). Accepted; currently dropped downstream. */
+export const inputAudioPartSchema = z.object({
+	type: z.literal("input_audio"),
+	input_audio: z.object({
+		data: z.string(),
+		format: z.enum(["wav", "mp3"]),
+	}),
+});
+
+/** OpenAI file input block (file_search / vision-document). Accepted; currently dropped downstream. */
+export const filePartSchema = z.object({
+	type: z.literal("file"),
+	file: z.object({
+		file_id: z.string().optional(),
+		filename: z.string().optional(),
+		file_data: z.string().optional(),
+	}),
+});
+
+/** Replayed assistant refusal block. Accepted; currently dropped downstream. */
+export const refusalPartSchema = z.object({
+	type: z.literal("refusal"),
+	refusal: z.string(),
+});
+
+/**
+ * Forward-compat catch-all for unknown content-part types. Matches every other
+ * `{ type: string, ... }` object so a new OpenAI block kind does not 400 the
+ * whole request; the walker ignores parts whose `type` it does not know.
+ */
+export const unknownPartSchema = z.object({ type: z.string() }).loose();
+
+export const userContentPartSchema = z.union([
+	textPartSchema,
+	imagePartSchema,
+	inputAudioPartSchema,
+	filePartSchema,
+	refusalPartSchema,
+	unknownPartSchema,
+]);
+
+// ─── Tool calls / tools ─────────────────────────────────────────────────────
+
+export const toolCallSchema = z.object({
+	id: z.string(),
+	type: z.literal("function").optional(),
+	function: z.object({
+		name: z.string(),
+		arguments: z.string(),
+	}),
+});
+
+export const toolSchema = z.object({
+	type: z.literal("function"),
+	function: z.object({
+		name: z.string().min(1),
+		description: z.string().optional(),
+		parameters: z.record(z.string(), z.unknown()).optional(),
+		/** OpenAI structured-output strict mode. Accepted, not enforced upstream. */
+		strict: z.boolean().optional(),
+	}),
+});
+
+// ─── Tool choice ────────────────────────────────────────────────────────────
+
+export const toolChoiceSchema = z.union([
+	z.literal("auto"),
+	z.literal("none"),
+	z.literal("required"),
+	z.object({
+		type: z.literal("function"),
+		function: z.object({ name: z.string().min(1) }),
+	}),
+	// Anthropic-style `{ type: 'tool', name }` — translated to the OpenAI
+	// function shape in the walker.
+	z.object({
+		type: z.literal("tool"),
+		name: z.string().min(1),
+	}),
+]);
+
+// ─── Messages ───────────────────────────────────────────────────────────────
+
+const baseContent = z.union([z.string(), z.array(userContentPartSchema)]);
+
+/**
+ * Clients (Aside, LangChain, LiteLLM, the Vercel AI SDK, …) routinely
+ * serialize an unset optional field as explicit `null` instead of omitting
+ * it, and OpenAI itself accepts that. Collapse `null` back to `undefined` so
+ * every downstream consumer keeps working against the `T | undefined` shape.
+ */
+const nullableOptional = <T extends z.ZodType>(schema: T) => schema.nullish().transform(value => value ?? undefined);
+
+/** Present-but-`null` content is empty text, not a 400. */
+const requiredContent = baseContent.nullable().transform(value => value ?? "");
+
+export const systemMessageSchema = z.object({
+	role: z.literal("system"),
+	content: requiredContent,
+});
+
+export const developerMessageSchema = z.object({
+	role: z.literal("developer"),
+	content: requiredContent,
+});
+
+export const userMessageSchema = z.object({
+	role: z.literal("user"),
+	content: requiredContent,
+});
+
+export const assistantMessageSchema = z.object({
+	role: z.literal("assistant"),
+	content: nullableOptional(baseContent),
+	tool_calls: nullableOptional(z.array(toolCallSchema)),
+});
+
+export const toolMessageSchema = z.object({
+	role: z.literal("tool"),
+	content: nullableOptional(baseContent),
+	tool_call_id: nullableOptional(z.string()),
+});
+
+/**
+ * Legacy `function` role (pre-tools API). Translated to a `tool` role
+ * canonical message in the walker so downstream providers see one shape.
+ */
+export const functionMessageSchema = z.object({
+	role: z.literal("function"),
+	name: z.string(),
+	content: z.string().nullable(),
+});
+
+export const messageSchema = z.discriminatedUnion("role", [
+	systemMessageSchema,
+	developerMessageSchema,
+	userMessageSchema,
+	assistantMessageSchema,
+	toolMessageSchema,
+	functionMessageSchema,
+]);
+
+// ─── Stream options ─────────────────────────────────────────────────────────
+
+/**
+ * Permissive: the official OpenAI SDK sets `include_obfuscation: false` by
+ * default. We only consume `include_usage`, so unknown keys are silently
+ * stripped rather than 400'd.
+ */
+export const streamOptionsSchema = z.object({
+	include_usage: z.boolean().optional(),
+});
+
+// ─── Stop sequences ─────────────────────────────────────────────────────────
+
+// OpenAI rejects > 4 stop strings; mirror that at the gateway.
+export const stopSchema = z.union([z.string(), z.array(z.string()).max(4)]);
+
+// ─── Top-level request ──────────────────────────────────────────────────────
+
+export const openaiChatRequestSchema = z.object({
+	model: z.string().min(1),
+	messages: z.array(messageSchema),
+	tools: nullableOptional(z.array(toolSchema)),
+	tool_choice: nullableOptional(toolChoiceSchema),
+	max_tokens: nullableOptional(z.number()),
+	max_completion_tokens: nullableOptional(z.number()),
+	temperature: nullableOptional(z.number()),
+	top_p: nullableOptional(z.number()),
+	stop: nullableOptional(stopSchema),
+	stream: nullableOptional(z.boolean()),
+	stream_options: nullableOptional(streamOptionsSchema),
+
+	// ── Typed first-class passthroughs (now consumed by the walker) ────────
+	response_format: z.unknown().optional(),
+	seed: nullableOptional(z.number()),
+	presence_penalty: nullableOptional(z.number()),
+	frequency_penalty: nullableOptional(z.number()),
+	logit_bias: nullableOptional(z.record(z.string(), z.number())),
+	user: nullableOptional(z.string()),
+	reasoning_effort: nullableOptional(z.enum(["minimal", "low", "medium", "high", "xhigh", "max"])),
+	parallel_tool_calls: nullableOptional(z.boolean()),
+	service_tier: nullableOptional(z.enum(["auto", "default", "flex", "scale", "priority"])),
+	metadata: nullableOptional(z.record(z.string(), z.unknown())),
+
+	// ── Accept-and-ignore passthroughs ─────────────────────────────────────
+	// Forward acceptance only: validating these would 400 on shapes the
+	// gateway has no opinion on. The downstream provider does the real check.
+	logprobs: z.unknown().optional(),
+	top_logprobs: z.unknown().optional(),
+	prediction: z.unknown().optional(),
+	modalities: z.unknown().optional(),
+	audio: z.unknown().optional(),
+	store: z.unknown().optional(),
+	prompt_cache_key: z.unknown().optional(),
+	safety_identifier: z.unknown().optional(),
+	n: z.unknown().optional(),
+	web_search_options: z.unknown().optional(),
+});
+
+/**
+ * Public types are sourced from the OpenAI SDK so the gateway stays in
+ * lock-step with the canonical API surface; the schemas above are runtime
+ * validators for the subset we actually accept.
+ */
+export type OpenAIChatRequest = ChatCompletionCreateParams;
+export type OpenAIChatMessage = ChatCompletionMessageParam;
+export type OpenAIChatToolCall = ChatCompletionMessageToolCall;
+export type OpenAIChatTool = ChatCompletionTool;
+export type OpenAIChatToolChoice = ChatCompletionToolChoiceOption;
+export type OpenAIChatContentPart = ChatCompletionContentPart;