@aryee337/aery-ai 0.1.148 → 0.2.10

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

@@ -0,0 +1,138 @@
+/**
+ * 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 { 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,
+					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, {
+					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,
+					onResponse: options?.onResponse,
+					onSseEvent: options?.onSseEvent,
+					fetch: options?.fetch,
+					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, {
+					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,
+					onResponse: options?.onResponse,
+					onSseEvent: options?.onSseEvent,
+					fetch: options?.fetch,
+					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-chat-server-schema.ts

@@ -0,0 +1,252 @@
+/**
+ * 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 (aery-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)]);
+
+export const systemMessageSchema = z.object({
+	role: z.literal("system"),
+	content: baseContent,
+});
+
+export const developerMessageSchema = z.object({
+	role: z.literal("developer"),
+	content: baseContent,
+});
+
+export const userMessageSchema = z.object({
+	role: z.literal("user"),
+	content: baseContent,
+});
+
+export const assistantMessageSchema = z.object({
+	role: z.literal("assistant"),
+	content: baseContent.optional(),
+	tool_calls: z.array(toolCallSchema).optional(),
+});
+
+export const toolMessageSchema = z.object({
+	role: z.literal("tool"),
+	content: baseContent.optional(),
+	tool_call_id: z.string().optional(),
+	// OpenAI's wire spec omits `name` on `role:"tool"`, but in practice the
+	// official Python SDK and several wrappers do send it. Accept it so we can
+	// honour it downstream (Google's `functionResponse.name` is required and
+	// non-empty); empty strings are coerced to undefined so the back-resolve
+	// path runs.
+	name: z
+		.string()
+		.optional()
+		.transform(v => (v && v.length > 0 ? v : undefined)),
+});
+
+/**
+ * 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: z.array(toolSchema).optional(),
+	tool_choice: toolChoiceSchema.optional(),
+	max_tokens: z.number().optional(),
+	max_completion_tokens: z.number().optional(),
+	temperature: z.number().optional(),
+	top_p: z.number().optional(),
+	stop: stopSchema.optional(),
+	stream: z.boolean().optional(),
+	stream_options: streamOptionsSchema.optional(),
+
+	// ── Typed first-class passthroughs (now consumed by the walker) ────────
+	response_format: z.unknown().optional(),
+	seed: z.number().optional(),
+	presence_penalty: z.number().optional(),
+	frequency_penalty: z.number().optional(),
+	logit_bias: z.record(z.string(), z.number()).optional(),
+	user: z.string().optional(),
+	reasoning_effort: z.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),
+	parallel_tool_calls: z.boolean().optional(),
+	service_tier: z.enum(["auto", "default", "flex", "scale", "priority"]).optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+
+	// ── 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;