From c8e654410da82baf5aae5cb74f2e78831c60b722 Mon Sep 17 00:00:00 2001 From: Shoubhit Dash Date: Fri, 18 Sep 2026 18:14:20 +0530 Subject: [PATCH] refactor(ai): decode Anthropic and Gemini provider options with one schema (#49760) --- .../ai/src/protocols/anthropic-messages.ts | 246 ++++++------------ packages/ai/src/protocols/gemini.ts | 113 ++++---- packages/ai/src/protocols/shared.ts | 12 +- .../test/provider/anthropic-messages.test.ts | 66 ++++- 4 files changed, 200 insertions(+), 237 deletions(-) diff --git a/packages/ai/src/protocols/anthropic-messages.ts b/packages/ai/src/protocols/anthropic-messages.ts index 4213dc06eef..e93168db8f3 100644 --- a/packages/ai/src/protocols/anthropic-messages.ts +++ b/packages/ai/src/protocols/anthropic-messages.ts @@ -1,5 +1,5 @@ import { Buffer } from "node:buffer" -import { Effect, Option, Schema } from "effect" +import { Effect, Option, Schema, SchemaGetter } from "effect" import { Tool } from "@opencode/schema/tool" import { Route } from "../route/client.js" import { Auth } from "../route/auth.js" @@ -21,11 +21,12 @@ import { type JsonSchema, type MediaPart, type ProviderMetadata, + type ProviderOptions, type ToolCallPart, type ToolDefinition, type ToolResultPart, } from "../schema/index.js" -import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js" +import { JsonObject, knownString, optionalArray, optionalNull, ProviderShared } from "./shared.js" import { classifyProviderFailure } from "../provider-error.js" import { effortUpdate, resolveEffortUpdates } from "../effort-updates.js" import * as Cache from "./utils/cache.js" @@ -52,57 +53,10 @@ const SSE_EVENTS = new Set([ ]) export const framing = Framing.sseEvents(SSE_EVENTS) -export type ThinkingBlockBinding = { - readonly prefix_mismatch_behavior?: "error" | "drop_block" | (string & {}) -} - -export type ThinkingInput = - | { - readonly type: "adaptive" - readonly display?: "summarized" | "omitted" - readonly block_binding?: ThinkingBlockBinding - } - | { - readonly type: "disabled" - } - | ({ - readonly type: "enabled" - readonly display?: "summarized" | "omitted" - readonly block_binding?: ThinkingBlockBinding - } & ( - | { readonly budgetTokens: number; readonly budget_tokens?: number } - | { readonly budgetTokens?: number; readonly budget_tokens: number } - )) - -export interface OptionsInput { - /** Advanced in-band compaction. The caller owns checkpoint persistence and recovery. */ - readonly contextManagement?: ContextManagement - readonly [key: string]: unknown - readonly thinking?: ThinkingInput - readonly effort?: string - readonly service_tier?: "auto" | "standard_only" - readonly serviceTier?: "auto" | "standard_only" - // SDK Metadata:2649 {user_id?: string | null} - readonly metadata?: { readonly user_id?: string | null } - // SDK MessageCreateParamsContainer:2596 ContainerParams|string - readonly container?: - | string - | { readonly id?: string | null; readonly skills?: ReadonlyArray> | null } - readonly inference_geo?: string | null - readonly inferenceGeo?: string | null - readonly cache_control?: { readonly type: "ephemeral"; readonly ttl?: "5m" | "1h" } - readonly cacheControl?: { readonly type: "ephemeral"; readonly ttl?: "5m" | "1h" } - // SDK OutputConfig:2684 {effort, format: JSONOutputFormat} - readonly output_config?: { - readonly effort?: string | null - readonly format?: { readonly type: "json_schema"; readonly schema: Record } | null - } - readonly outputConfig?: { - readonly effort?: string | null - readonly format?: { readonly type: "json_schema"; readonly schema: Record } | null - } -} - +export type ThinkingBlockBinding = typeof AnthropicThinkingBlockBinding.Type +export type ThinkingInput = typeof Thinking.Encoded +/** Caller-facing provider options; unknown keys are accepted and ignored. `Options.Type` is the wire-ready form. */ +export type OptionsInput = ProviderOptions & typeof Options.Encoded export type ProviderOptionsInput = OptionsInput export const ContextManagement = Schema.Struct({ @@ -129,6 +83,7 @@ const AnthropicCacheControl = Schema.Struct({ type: Schema.tag("ephemeral"), ttl: Schema.optional(Schema.Literals(["5m", "1h"])), }) +const AnthropicServiceTier = Schema.Literals(["auto", "standard_only"]) const AnthropicTextBlock = Schema.Struct({ type: Schema.tag("text"), @@ -317,25 +272,21 @@ const AnthropicToolChoice = Schema.Union([ ]) const AnthropicThinkingBlockBinding = Schema.Struct({ - prefix_mismatch_behavior: Schema.optional(Schema.String), + prefix_mismatch_behavior: Schema.optional(knownString<"error" | "drop_block">()), }) -const AnthropicThinking = Schema.Union([ - Schema.Struct({ - type: Schema.tag("enabled"), - budget_tokens: Schema.Number, - display: Schema.optional(Schema.Literals(["summarized", "omitted"])), - block_binding: Schema.optional(AnthropicThinkingBlockBinding), - }), - Schema.Struct({ - type: Schema.tag("adaptive"), - display: Schema.optional(Schema.Literals(["summarized", "omitted"])), - block_binding: Schema.optional(AnthropicThinkingBlockBinding), - }), - Schema.Struct({ - type: Schema.tag("disabled"), - }), -]) +const AnthropicThinkingFields = { + display: Schema.optional(Schema.Literals(["summarized", "omitted"])), + block_binding: Schema.optional(AnthropicThinkingBlockBinding), +} +const AnthropicThinkingEnabled = Schema.Struct({ + type: Schema.tag("enabled"), + budget_tokens: Schema.Number, + ...AnthropicThinkingFields, +}) +const AnthropicThinkingAdaptive = Schema.Struct({ type: Schema.tag("adaptive"), ...AnthropicThinkingFields }) +const AnthropicThinkingDisabled = Schema.Struct({ type: Schema.tag("disabled") }) +const AnthropicThinking = Schema.Union([AnthropicThinkingEnabled, AnthropicThinkingAdaptive, AnthropicThinkingDisabled]) type AnthropicThinking = typeof AnthropicThinking.Type // SDK OutputConfig:2684 {effort?: "low"|"medium"|"high"|"xhigh"|"max"|null, format?: JSONOutputFormat:2399} @@ -360,6 +311,53 @@ const AnthropicContainer = Schema.Union([ }), ]) +// ============================================================================= +// Provider Options +// ============================================================================= +// Callers spell the budget as `budgetTokens` or the wire `budget_tokens`; the +// keys are disjoint per variant so the input type requires exactly one and the +// transform can narrow on it. Decoding straight to the wire block keeps the +// alias out of the rest of the file. +const ThinkingEnabledInput = Schema.Union([ + Schema.Struct({ type: Schema.tag("enabled"), budgetTokens: Schema.Number, ...AnthropicThinkingFields }), + Schema.Struct({ type: Schema.tag("enabled"), budget_tokens: Schema.Number, ...AnthropicThinkingFields }), +]).pipe( + Schema.decodeTo(AnthropicThinkingEnabled, { + decode: SchemaGetter.transform((input) => ({ + type: "enabled" as const, + budget_tokens: "budgetTokens" in input ? input.budgetTokens : input.budget_tokens, + display: input.display, + block_binding: input.block_binding, + })), + encode: SchemaGetter.passthrough({ strict: false }), + }), +) +const Thinking = Schema.Union([ThinkingEnabledInput, AnthropicThinkingAdaptive, AnthropicThinkingDisabled]) + +const OutputConfigInput = Schema.Struct({ + effort: optionalNull(Schema.String), + format: optionalNull(AnthropicJsonOutputFormat), +}) + +// Both key spellings are accepted; `fromRequest` prefers the snake_case one. +const Options = Schema.Struct({ + /** Advanced in-band compaction. The caller owns checkpoint persistence and recovery. */ + contextManagement: Schema.optional(ContextManagement), + thinking: Schema.optional(Thinking), + effort: Schema.optional(Schema.String), + service_tier: Schema.optional(AnthropicServiceTier), + serviceTier: Schema.optional(AnthropicServiceTier), + metadata: Schema.optional(AnthropicMetadata), + container: Schema.optional(AnthropicContainer), + inference_geo: optionalNull(Schema.String), + inferenceGeo: optionalNull(Schema.String), + cache_control: Schema.optional(AnthropicCacheControl), + cacheControl: Schema.optional(AnthropicCacheControl), + output_config: Schema.optional(OutputConfigInput), + outputConfig: Schema.optional(OutputConfigInput), +}) +const decodeOptions = ProviderShared.validateWith(Schema.decodeUnknownEffect(Options)) + const AnthropicBodyFields = { context_management: Schema.optional( Schema.Struct({ @@ -391,7 +389,7 @@ const AnthropicBodyFields = { container: Schema.optional(Schema.NullOr(AnthropicContainer)), inference_geo: Schema.optional(Schema.NullOr(Schema.String)), metadata: Schema.optional(AnthropicMetadata), - service_tier: Schema.optional(Schema.Literals(["auto", "standard_only"])), + service_tier: Schema.optional(AnthropicServiceTier), } export const AnthropicMessagesBody = Schema.Struct(AnthropicBodyFields) export type AnthropicMessagesBody = Schema.Schema.Type @@ -1001,64 +999,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* ( return messages }) -const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (request: LLMRequest) { - const input = request.providerOptions as Record | undefined - const rawServiceTier = - (input as Record | undefined)?.service_tier ?? - (input as Record | undefined)?.serviceTier - const service_tier = - rawServiceTier === "auto" || rawServiceTier === "standard_only" - ? (rawServiceTier as "auto" | "standard_only") - : undefined - const rawMetadata = (input as Record | undefined)?.metadata - const metadata = - ProviderShared.isRecord(rawMetadata) && (typeof rawMetadata.user_id === "string" || rawMetadata.user_id === null) - ? { user_id: rawMetadata.user_id as string | null } - : undefined - const container = - typeof (input as Record | undefined)?.container === "string" || - ProviderShared.isRecord((input as Record | undefined)?.container) - ? ((input as Record).container as - | string - | { id?: string | null; skills?: ReadonlyArray> | null }) - : undefined - const rawInferenceGeo = - (input as Record | undefined)?.inference_geo ?? - (input as Record | undefined)?.inferenceGeo - const inference_geo = typeof rawInferenceGeo === "string" ? rawInferenceGeo : undefined - const rawCacheControl = - (input as Record | undefined)?.cache_control ?? - (input as Record | undefined)?.cacheControl - const cache_control = - ProviderShared.isRecord(rawCacheControl) && rawCacheControl.type === "ephemeral" - ? (rawCacheControl as { type: "ephemeral"; ttl?: "5m" | "1h" }) - : undefined - const rawOutputConfig = - (input as Record | undefined)?.output_config ?? - (input as Record | undefined)?.outputConfig - const outputConfigEffort = - typeof (input as Record | undefined)?.effort === "string" - ? ((input as Record).effort as string) - : ProviderShared.isRecord(rawOutputConfig) && typeof rawOutputConfig.effort === "string" - ? (rawOutputConfig.effort as string) - : undefined - const outputConfigFormat = - ProviderShared.isRecord(rawOutputConfig) && ProviderShared.isRecord(rawOutputConfig.format) - ? (rawOutputConfig.format as { type: "json_schema"; schema: Record }) - : undefined - const thinking = yield* resolveThinking(input?.thinking) - return { - thinking: applyThinkingBindingDefault(request.model, thinking), - effort: outputConfigEffort, - format: outputConfigFormat, - service_tier, - metadata, - container, - inference_geo, - cache_control, - } -}) - // Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version. const claudeVersion = (id: string) => { const match = /(?:^|[./])claude-(?[a-z]+)-(?\d+)(?:[.-](?\d{1,2}))?(?:$|[-:@])/.exec( @@ -1097,35 +1037,12 @@ const applyThinkingBindingDefault = (model: LLMRequest["model"], thinking: Anthr } } -const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input: unknown) { - if (!ProviderShared.isRecord(input)) return undefined - if (input.type === "disabled") return { type: "disabled" as const } - if (input.type !== "adaptive" && input.type !== "enabled") return undefined - const block_binding = yield* ProviderShared.validateWith( - Schema.decodeUnknownEffect(Schema.UndefinedOr(AnthropicThinkingBlockBinding)), - )(input.block_binding) - const display = - input.display === "summarized" || input.display === "omitted" - ? (input.display as "summarized" | "omitted") - : undefined - if (input.type === "adaptive") return { type: "adaptive" as const, display, block_binding } - const budget = - typeof input.budgetTokens === "number" - ? input.budgetTokens - : typeof input.budget_tokens === "number" - ? input.budget_tokens - : undefined - if (budget === undefined) - return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens") - return { type: "enabled" as const, budget_tokens: budget, display, block_binding } -}) - const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) { - const management = yield* ProviderShared.validateWith( - Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)), - )(request.providerOptions?.contextManagement) - const options = yield* resolveOptions(request) - const updates = resolveEffortUpdates(request, options.effort) + const options = yield* decodeOptions(request.providerOptions ?? {}) + const management = options.contextManagement + const outputConfig = options.output_config ?? options.outputConfig + const format = outputConfig?.format ?? undefined + const updates = resolveEffortUpdates(request, options.effort ?? outputConfig?.effort ?? undefined) const generation = request.generation const toolSchemaCompatibility = request.model.compatibility?.toolSchema // Allocate the 4-breakpoint budget in invalidation order: tools → system → @@ -1161,12 +1078,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques ) } const output_config = - updates.effort === undefined && options.format === undefined - ? undefined - : { - ...(updates.effort === undefined ? {} : { effort: updates.effort }), - ...(options.format === undefined ? {} : { format: options.format }), - } + updates.effort === undefined && format === undefined ? undefined : { effort: updates.effort, format } const body = { model: request.model.id, system, @@ -1179,14 +1091,14 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques top_p: generation?.topP, top_k: generation?.topK, stop_sequences: generation?.stop, - thinking: options.thinking, + thinking: applyThinkingBindingDefault(request.model, options.thinking), output_config, // top-level passthrough per SDK MessageCreateParamsBase:4638,4643,4649,4654,4670 - cache_control: options.cache_control, + cache_control: options.cache_control ?? options.cacheControl, container: options.container, - inference_geo: options.inference_geo, + inference_geo: options.inference_geo ?? options.inferenceGeo ?? undefined, metadata: options.metadata, - service_tier: options.service_tier, + service_tier: options.service_tier ?? options.serviceTier, } if (!management) return body return { diff --git a/packages/ai/src/protocols/gemini.ts b/packages/ai/src/protocols/gemini.ts index 0489c5a29d4..e7c59cc5fbb 100644 --- a/packages/ai/src/protocols/gemini.ts +++ b/packages/ai/src/protocols/gemini.ts @@ -14,12 +14,13 @@ import { type LLMRequest, type MediaPart, type ProviderMetadata, + type ProviderOptions, type TextPart, type ToolCallPart, type ToolDefinition, } from "../schema/index.js" import { classifyProviderFailure } from "../provider-error.js" -import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js" +import { JsonObject, knownString, lenient, optionalArray, optionalNull, ProviderShared } from "./shared.js" import { GeminiToolSchema } from "./utils/gemini-tool-schema.js" import { Lifecycle } from "./utils/lifecycle.js" import { ToolSchemaProjection } from "./utils/tool-schema.js" @@ -50,35 +51,8 @@ const omitsFunctionCallIds = (modelID: string) => { return match !== null && Number(match[1]) < 3 } -export interface OptionsInput { - readonly [key: string]: unknown - readonly cachedContent?: string - readonly safetySettings?: ReadonlyArray<{ - readonly category: - | "HARM_CATEGORY_UNSPECIFIED" - | "HARM_CATEGORY_HATE_SPEECH" - | "HARM_CATEGORY_DANGEROUS_CONTENT" - | "HARM_CATEGORY_HARASSMENT" - | "HARM_CATEGORY_SEXUALLY_EXPLICIT" - | "HARM_CATEGORY_CIVIC_INTEGRITY" - | (string & {}) - readonly threshold: - | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" - | "BLOCK_LOW_AND_ABOVE" - | "BLOCK_MEDIUM_AND_ABOVE" - | "BLOCK_ONLY_HIGH" - | "BLOCK_NONE" - | "OFF" - | (string & {}) - }> - readonly serviceTier?: "standard" | "flex" | "priority" | (string & {}) - readonly thinkingConfig?: { - readonly thinkingBudget?: number - readonly includeThoughts?: boolean - readonly thinkingLevel?: "minimal" | "low" | "medium" | "high" | (string & {}) - } -} - +/** Caller-facing provider options; unknown keys are accepted and ignored. */ +export type OptionsInput = ProviderOptions & typeof Options.Encoded export type ProviderOptionsInput = OptionsInput // ============================================================================= @@ -161,17 +135,50 @@ const GeminiToolConfig = Schema.Struct({ }), }) +const GeminiThinkingLevel = knownString<"minimal" | "low" | "medium" | "high">() const GeminiThinkingConfig = Schema.Struct({ thinkingBudget: Schema.optional(Schema.Number), includeThoughts: Schema.optional(Schema.Boolean), - thinkingLevel: Schema.optional(Schema.String), + thinkingLevel: Schema.optional(GeminiThinkingLevel), }) const GeminiSafetySetting = Schema.Struct({ - category: Schema.String, - threshold: Schema.String, + category: knownString< + | "HARM_CATEGORY_UNSPECIFIED" + | "HARM_CATEGORY_HATE_SPEECH" + | "HARM_CATEGORY_DANGEROUS_CONTENT" + | "HARM_CATEGORY_HARASSMENT" + | "HARM_CATEGORY_SEXUALLY_EXPLICIT" + | "HARM_CATEGORY_CIVIC_INTEGRITY" + >(), + threshold: knownString< + | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" + | "BLOCK_LOW_AND_ABOVE" + | "BLOCK_MEDIUM_AND_ABOVE" + | "BLOCK_ONLY_HIGH" + | "BLOCK_NONE" + | "OFF" + >(), }) +// ============================================================================= +// Provider Options +// ============================================================================= +// Malformed fields are dropped rather than failing the request; a `thinkingConfig` +// object that omits `includeThoughts` asks for thoughts. +const GeminiThinkingConfigInput = Schema.Struct({ + thinkingBudget: lenient(Schema.Number), + includeThoughts: lenient(Schema.Boolean), + thinkingLevel: lenient(GeminiThinkingLevel), +}) +const Options = Schema.Struct({ + cachedContent: lenient(Schema.String), + safetySettings: lenient(Schema.Array(GeminiSafetySetting)), + serviceTier: lenient(knownString<"standard" | "flex" | "priority">()), + thinkingConfig: lenient(GeminiThinkingConfigInput), +}) +const decodeOptions = ProviderShared.validateWith(Schema.decodeUnknownEffect(Options)) + const GeminiGenerationConfig = Schema.Struct({ maxOutputTokens: Schema.optional(Schema.Number), temperature: Schema.optional(Schema.Number), @@ -431,44 +438,11 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR return contents }) -const resolveOptions = (request: LLMRequest) => { - const input = request.providerOptions - const value = input?.thinkingConfig - const thinkingConfig = { - thinkingBudget: - ProviderShared.isRecord(value) && typeof value.thinkingBudget === "number" ? value.thinkingBudget : undefined, - includeThoughts: - ProviderShared.isRecord(value) && typeof value.includeThoughts === "boolean" - ? value.includeThoughts - : ProviderShared.isRecord(value) - ? true - : undefined, - thinkingLevel: - ProviderShared.isRecord(value) && typeof value.thinkingLevel === "string" ? value.thinkingLevel : undefined, - } - return { - cachedContent: typeof input?.cachedContent === "string" ? input.cachedContent : undefined, - safetySettings: mapSafetySettings(input?.safetySettings), - serviceTier: typeof input?.serviceTier === "string" ? input.serviceTier : undefined, - thinkingConfig: Object.values(thinkingConfig).some((item) => item !== undefined) ? thinkingConfig : undefined, - } -} - -function mapSafetySettings(value: unknown) { - if (!Array.isArray(value)) return undefined - const settings = value.flatMap((item) => - ProviderShared.isRecord(item) && typeof item.category === "string" && typeof item.threshold === "string" - ? [{ category: item.category, threshold: item.threshold }] - : [], - ) - return settings -} - const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMRequest) { const flattened = ProviderShared.flattenToolRequest(request) const hasTools = flattened.tools.length > 0 const generation = request.generation - const options = resolveOptions(request) + const options = yield* decodeOptions(request.providerOptions ?? {}) const toolSchemaCompatibility = request.model.compatibility?.toolSchema const generationConfig = { maxOutputTokens: generation?.maxTokens, @@ -479,7 +453,10 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque presencePenalty: generation?.presencePenalty, seed: generation?.seed, stopSequences: generation?.stop, - thinkingConfig: options.thinkingConfig, + thinkingConfig: + options.thinkingConfig === undefined + ? undefined + : { ...options.thinkingConfig, includeThoughts: options.thinkingConfig.includeThoughts ?? true }, } return { diff --git a/packages/ai/src/protocols/shared.ts b/packages/ai/src/protocols/shared.ts index e2e35e74b0c..b38fc5f46b8 100644 --- a/packages/ai/src/protocols/shared.ts +++ b/packages/ai/src/protocols/shared.ts @@ -1,6 +1,6 @@ import { Buffer } from "node:buffer" import { Tool } from "@opencode/schema/tool" -import { Effect, Schema, Stream } from "effect" +import { Effect, Option, Schema, Stream } from "effect" import * as Sse from "effect/unstable/encoding/Sse" import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http" import { @@ -29,6 +29,16 @@ const isJson = Schema.is(Schema.Json) export const JsonObject = Schema.Record(Schema.String, Schema.Unknown) export const optionalArray = (schema: S) => Schema.optional(Schema.Array(schema)) export const optionalNull = (schema: S) => Schema.optional(Schema.NullOr(schema)) +/** Optional field whose malformed value decodes to `undefined` instead of failing the enclosing struct. */ +export const lenient = (schema: S) => + Schema.optionalKey( + Schema.UndefinedOr(schema).pipe(Schema.catchDecoding(() => Effect.succeed(Option.some(undefined)))), + ) +/** Provider-defined string enum: known values for autocomplete, any string accepted at runtime. */ +export const knownString = () => + Schema.declare((value): value is Known | (string & {}) => typeof value === "string", { + expected: "string", + }) export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64 diff --git a/packages/ai/test/provider/anthropic-messages.test.ts b/packages/ai/test/provider/anthropic-messages.test.ts index b5696462f81..6e5cd241f1f 100644 --- a/packages/ai/test/provider/anthropic-messages.test.ts +++ b/packages/ai/test/provider/anthropic-messages.test.ts @@ -166,7 +166,71 @@ describe("Anthropic Messages route", () => { }), ).pipe(Effect.flip) - expect(error.message).toContain("Anthropic thinking provider option requires budgetTokens") + expect(error.reason._tag).toBe("InvalidRequest") + expect(error.message).toContain("budgetTokens") + }), + ) + + it.effect("lowers passthrough provider options and accepts either key spelling", () => + Effect.gen(function* () { + const snake = yield* compileRequest( + LLMRequest.update(request, { + providerOptions: { + service_tier: "auto", + metadata: { user_id: "user_1" }, + container: { id: "container_1" }, + inference_geo: "us", + cache_control: { type: "ephemeral", ttl: "1h" }, + output_config: { format: { type: "json_schema", schema: { type: "object" } } }, + }, + }), + ) + const camel = yield* compileRequest( + LLMRequest.update(request, { + providerOptions: { + serviceTier: "standard_only", + container: "container_2", + inferenceGeo: "eu", + cacheControl: { type: "ephemeral" }, + outputConfig: { effort: "low" }, + }, + }), + ) + + expect(snake.body).toMatchObject({ + service_tier: "auto", + metadata: { user_id: "user_1" }, + container: { id: "container_1" }, + inference_geo: "us", + cache_control: { type: "ephemeral", ttl: "1h" }, + output_config: { format: { type: "json_schema", schema: { type: "object" } } }, + }) + expect(camel.body).toMatchObject({ + service_tier: "standard_only", + container: "container_2", + inference_geo: "eu", + cache_control: { type: "ephemeral" }, + output_config: { effort: "low" }, + }) + }), + ) + + it.effect("ignores unknown provider options and rejects malformed known ones", () => + Effect.gen(function* () { + const prepared = yield* compileRequest(LLMRequest.update(request, { providerOptions: { unknownOption: true } })) + const malformed = [ + { service_tier: "fast" }, + { metadata: { user_id: 42 } }, + { cache_control: { type: "ephemeral", ttl: "2h" } }, + { output_config: { format: { type: "text" } } }, + { thinking: { type: "automatic" } }, + ] + const errors = yield* Effect.forEach(malformed, (providerOptions) => + compileRequest(LLMRequest.update(request, { providerOptions })).pipe(Effect.flip), + ) + + expect(prepared.body).not.toHaveProperty("unknownOption") + expect(errors.map((error) => error.reason._tag)).toEqual(malformed.map(() => "InvalidRequest")) }), )