@opencode/ai 2.0.7 → 2.0.9

package/dist/protocols/alibaba-chat.js

@@ -4,7 +4,7 @@ import { OpenAIChat } from "./openai-chat.js";
 import { JsonObject, ProviderShared } from "./shared.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 const Options = Schema.Struct({
-    reasoningEffort: OpenResponsesOptions.Options.fields.reasoningEffort,
+    reasoningEffort: Schema.optional(OpenResponsesOptions.ReasoningEffort),
     enableThinking: Schema.optional(Schema.Boolean),
     thinkingBudget: Schema.optional(Schema.Int),
     preserveThinking: Schema.optional(Schema.Boolean),
@@ -13,7 +13,7 @@ const Options = Schema.Struct({
         type: Schema.declare(Schema.is(Schema.String)),
     })),
     toolStream: Schema.optional(Schema.Boolean),
-    parallelToolCalls: OpenResponsesOptions.Options.fields.parallelToolCalls,
+    parallelToolCalls: Schema.optional(Schema.Boolean),
     repetitionPenalty: Schema.optional(Schema.Number),
     responseFormat: Schema.optional(Schema.Struct({
         type: Schema.declare(Schema.is(Schema.String)),

package/dist/protocols/alibaba-messages.d.ts

@@ -228,7 +228,7 @@ export declare const protocol: Protocol<{
         readonly type: string;
         readonly budget_tokens?: number | undefined;
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/protocols/alibaba-responses.js

@@ -5,9 +5,9 @@ import { JsonObject, optionalArray, ProviderShared } from "./shared.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
 const Options = Schema.Struct({
-    reasoningEffort: OpenResponsesOptions.Options.fields.reasoningEffort,
+    reasoningEffort: Schema.optional(OpenResponsesOptions.ReasoningEffort),
     enableThinking: Schema.optional(Schema.Boolean),
-    store: OpenResponsesOptions.Options.fields.store,
+    store: Schema.optional(Schema.Boolean),
     previousResponseId: Schema.optional(Schema.String),
     conversation: Schema.optional(Schema.String),
 });

package/dist/protocols/anthropic-messages.d.ts

@@ -3,73 +3,17 @@ import { Route } from "../route/client.js";
 import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 import { HttpTransport } from "../route/transport/index.js";
-import { AIError, LLMRequest } from "../schema/index.js";
+import { AIError, LLMRequest, type ProviderOptions } from "../schema/index.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
 export declare const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 export declare const PATH = "/messages";
 export declare const DEFAULT_MAX_TOKENS = 32000;
 export declare const framing: Framing.Definition<string>;
-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";
-    readonly metadata?: {
-        readonly user_id?: string | null;
-    };
-    readonly container?: string | {
-        readonly id?: string | null;
-        readonly skills?: ReadonlyArray<Record<string, unknown>> | 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";
-    };
-    readonly output_config?: {
-        readonly effort?: string | null;
-        readonly format?: {
-            readonly type: "json_schema";
-            readonly schema: Record<string, unknown>;
-        } | null;
-    };
-    readonly outputConfig?: {
-        readonly effort?: string | null;
-        readonly format?: {
-            readonly type: "json_schema";
-            readonly schema: Record<string, unknown>;
-        } | 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 declare const ContextManagement: Schema.Struct<{
     readonly edits: Schema.$Array<Schema.Struct<{
@@ -83,6 +27,117 @@ export declare const ContextManagement: Schema.Struct<{
     }>>;
 }>;
 export type ContextManagement = typeof ContextManagement.Type;
+declare const AnthropicThinkingBlockBinding: Schema.Struct<{
+    readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+}>;
+declare const Thinking: Schema.Union<readonly [Schema.decodeTo<Schema.Struct<{
+    readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+    readonly block_binding: Schema.optional<Schema.Struct<{
+        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+    }>>;
+    readonly type: Schema.tag<"enabled">;
+    readonly budget_tokens: Schema.Number;
+}>, Schema.Union<readonly [Schema.Struct<{
+    readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+    readonly block_binding: Schema.optional<Schema.Struct<{
+        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+    }>>;
+    readonly type: Schema.tag<"enabled">;
+    readonly budgetTokens: Schema.Number;
+}>, Schema.Struct<{
+    readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+    readonly block_binding: Schema.optional<Schema.Struct<{
+        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+    }>>;
+    readonly type: Schema.tag<"enabled">;
+    readonly budget_tokens: Schema.Number;
+}>]>, never, never>, Schema.Struct<{
+    readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+    readonly block_binding: Schema.optional<Schema.Struct<{
+        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+    }>>;
+    readonly type: Schema.tag<"adaptive">;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"disabled">;
+}>]>;
+declare const Options: Schema.Struct<{
+    /** Advanced in-band compaction. The caller owns checkpoint persistence and recovery. */
+    readonly contextManagement: Schema.optional<Schema.Struct<{
+        readonly edits: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literal<"compact_20260112">;
+            readonly trigger: Schema.optional<Schema.Struct<{
+                readonly type: Schema.Literal<"input_tokens">;
+                readonly value: Schema.Int;
+            }>>;
+            readonly pauseAfterCompaction: Schema.optional<Schema.Boolean>;
+            readonly instructions: Schema.optional<Schema.String>;
+        }>>;
+    }>>;
+    readonly thinking: Schema.optional<Schema.Union<readonly [Schema.decodeTo<Schema.Struct<{
+        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly block_binding: Schema.optional<Schema.Struct<{
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+        }>>;
+        readonly type: Schema.tag<"enabled">;
+        readonly budget_tokens: Schema.Number;
+    }>, Schema.Union<readonly [Schema.Struct<{
+        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly block_binding: Schema.optional<Schema.Struct<{
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+        }>>;
+        readonly type: Schema.tag<"enabled">;
+        readonly budgetTokens: Schema.Number;
+    }>, Schema.Struct<{
+        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly block_binding: Schema.optional<Schema.Struct<{
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+        }>>;
+        readonly type: Schema.tag<"enabled">;
+        readonly budget_tokens: Schema.Number;
+    }>]>, never, never>, Schema.Struct<{
+        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly block_binding: Schema.optional<Schema.Struct<{
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+        }>>;
+        readonly type: Schema.tag<"adaptive">;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"disabled">;
+    }>]>>;
+    readonly effort: Schema.optional<Schema.String>;
+    readonly service_tier: Schema.optional<Schema.declare<"auto" | (string & {}) | "standard_only", "auto" | (string & {}) | "standard_only">>;
+    readonly serviceTier: Schema.optional<Schema.declare<"auto" | (string & {}) | "standard_only", "auto" | (string & {}) | "standard_only">>;
+    readonly metadata: Schema.optional<Schema.Struct<{
+        readonly user_id: Schema.optional<Schema.NullOr<Schema.String>>;
+    }>>;
+    readonly container: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly skills: Schema.optional<Schema.NullOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>>;
+    }>]>>;
+    readonly inference_geo: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly inferenceGeo: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly cache_control: Schema.optional<Schema.Struct<{
+        readonly type: Schema.tag<"ephemeral">;
+        readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
+    }>>;
+    readonly cacheControl: Schema.optional<Schema.Struct<{
+        readonly type: Schema.tag<"ephemeral">;
+        readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
+    }>>;
+    readonly output_config: Schema.optional<Schema.Struct<{
+        readonly effort: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly format: Schema.optional<Schema.NullOr<Schema.Struct<{
+            readonly type: Schema.Literal<"json_schema">;
+            readonly schema: Schema.$Record<Schema.String, Schema.Unknown>;
+        }>>>;
+    }>>;
+    readonly outputConfig: Schema.optional<Schema.Struct<{
+        readonly effort: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly format: Schema.optional<Schema.NullOr<Schema.Struct<{
+            readonly type: Schema.Literal<"json_schema">;
+            readonly schema: Schema.$Record<Schema.String, Schema.Unknown>;
+        }>>>;
+    }>>;
+}>;
 export declare const AnthropicMessagesBody: Schema.Struct<{
     context_management: Schema.optional<Schema.Struct<{
         readonly edits: Schema.$Array<Schema.Struct<{
@@ -314,18 +369,18 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
     top_k: Schema.optional<Schema.Number>;
     stop_sequences: Schema.optional<Schema.$Array<Schema.String>>;
     thinking: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.tag<"enabled">;
-        readonly budget_tokens: Schema.Number;
-        readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
+        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
         readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.String>;
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
         }>>;
+        readonly type: Schema.tag<"enabled">;
+        readonly budget_tokens: Schema.Number;
     }>, Schema.Struct<{
-        readonly type: Schema.tag<"adaptive">;
-        readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
+        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
         readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.String>;
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
         }>>;
+        readonly type: Schema.tag<"adaptive">;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"disabled">;
     }>]>>;
@@ -348,7 +403,7 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
     metadata: Schema.optional<Schema.Struct<{
         readonly user_id: Schema.optional<Schema.NullOr<Schema.String>>;
     }>>;
-    service_tier: Schema.optional<Schema.Literals<readonly ["auto", "standard_only"]>>;
+    service_tier: Schema.optional<Schema.declare<"auto" | (string & {}) | "standard_only", "auto" | (string & {}) | "standard_only">>;
 }>;
 export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesBody>;
 /**
@@ -572,20 +627,20 @@ export declare const protocol: Protocol<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {
@@ -929,20 +984,20 @@ export declare const route: Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/protocols/anthropic-messages.js

@@ -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";
@@ -9,7 +9,7 @@ import { Protocol } from "../route/protocol.js";
 import { Headers } from "effect/unstable/http";
 import { HttpTransport } from "../route/transport/index.js";
 import { AIError, HttpOptions, LLMRequest, LLMEvent, mergeJsonRecords, Usage, } 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";
@@ -51,6 +51,7 @@ const AnthropicCacheControl = Schema.Struct({
     type: Schema.tag("ephemeral"),
     ttl: Schema.optional(Schema.Literals(["5m", "1h"])),
 });
+const AnthropicServiceTier = knownString();
 const AnthropicTextBlock = Schema.Struct({
     type: Schema.tag("text"),
     text: Schema.String,
@@ -209,24 +210,20 @@ const AnthropicToolChoice = Schema.Union([
     }),
 ]);
 const AnthropicThinkingBlockBinding = Schema.Struct({
-    prefix_mismatch_behavior: Schema.optional(Schema.String),
+    prefix_mismatch_behavior: Schema.optional(knownString()),
 });
-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(knownString()),
+    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]);
 // SDK OutputConfig:2684 {effort?: "low"|"medium"|"high"|"xhigh"|"max"|null, format?: JSONOutputFormat:2399}
 const AnthropicJsonOutputFormat = Schema.Struct({
     type: Schema.Literal("json_schema"),
@@ -246,6 +243,48 @@ const AnthropicContainer = Schema.Union([
         skills: optionalNull(Schema.Array(JsonObject)),
     }),
 ]);
+// =============================================================================
+// 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",
+        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({
         edits: Schema.Array(Schema.Struct({
@@ -273,7 +312,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);
 const AnthropicIterationUsage = Schema.StructWithRest(Schema.Struct({
@@ -821,51 +860,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
     }
     return messages;
 });
-const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (request) {
-    const input = request.providerOptions;
-    const rawServiceTier = input?.service_tier ??
-        input?.serviceTier;
-    const service_tier = rawServiceTier === "auto" || rawServiceTier === "standard_only"
-        ? rawServiceTier
-        : undefined;
-    const rawMetadata = input?.metadata;
-    const metadata = ProviderShared.isRecord(rawMetadata) && (typeof rawMetadata.user_id === "string" || rawMetadata.user_id === null)
-        ? { user_id: rawMetadata.user_id }
-        : undefined;
-    const container = typeof input?.container === "string" ||
-        ProviderShared.isRecord(input?.container)
-        ? input.container
-        : undefined;
-    const rawInferenceGeo = input?.inference_geo ??
-        input?.inferenceGeo;
-    const inference_geo = typeof rawInferenceGeo === "string" ? rawInferenceGeo : undefined;
-    const rawCacheControl = input?.cache_control ??
-        input?.cacheControl;
-    const cache_control = ProviderShared.isRecord(rawCacheControl) && rawCacheControl.type === "ephemeral"
-        ? rawCacheControl
-        : undefined;
-    const rawOutputConfig = input?.output_config ??
-        input?.outputConfig;
-    const outputConfigEffort = typeof input?.effort === "string"
-        ? input.effort
-        : ProviderShared.isRecord(rawOutputConfig) && typeof rawOutputConfig.effort === "string"
-            ? rawOutputConfig.effort
-            : undefined;
-    const outputConfigFormat = ProviderShared.isRecord(rawOutputConfig) && ProviderShared.isRecord(rawOutputConfig.format)
-        ? rawOutputConfig.format
-        : 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) => {
     const match = /(?:^|[./])claude-(?<family>[a-z]+)-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/.exec(id.toLowerCase())?.groups;
@@ -906,32 +900,12 @@ const applyThinkingBindingDefault = (model, thinking) => {
         },
     };
 };
-const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input) {
-    if (!ProviderShared.isRecord(input))
-        return undefined;
-    if (input.type === "disabled")
-        return { type: "disabled" };
-    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
-        : undefined;
-    if (input.type === "adaptive")
-        return { type: "adaptive", 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", budget_tokens: budget, display, block_binding };
-});
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
-    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 →
@@ -956,12 +930,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     if (breakpoints.dropped > 0) {
         yield* Effect.logWarning(`Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`);
     }
-    const output_config = updates.effort === undefined && options.format === undefined
-        ? undefined
-        : {
-            ...(updates.effort === undefined ? {} : { effort: updates.effort }),
-            ...(options.format === undefined ? {} : { format: options.format }),
-        };
+    const output_config = updates.effort === undefined && format === undefined ? undefined : { effort: updates.effort, format };
     const body = {
         model: request.model.id,
         system,
@@ -974,14 +943,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;

package/dist/protocols/gemini.d.ts

@@ -1,23 +1,25 @@
 import { Schema } from "effect";
 import { Route } from "../route/client.js";
 import { Protocol } from "../route/protocol.js";
+import { type ProviderOptions } from "../schema/index.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
-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;
+declare const Options: Schema.Struct<{
+    readonly cachedContent: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.String>, never>>;
+    readonly safetySettings: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Array<Schema.Struct<{
+        readonly category: Schema.declare<(string & {}) | "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY", (string & {}) | "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY">;
+        readonly threshold: Schema.declare<(string & {}) | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF", (string & {}) | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF">;
+    }>>>, never>>;
+    readonly serviceTier: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<(string & {}) | "standard" | "flex" | "priority", (string & {}) | "standard" | "flex" | "priority">>, never>>;
+    readonly thinkingConfig: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Struct<{
+        readonly thinkingBudget: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Number>, never>>;
+        readonly includeThoughts: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Boolean>, never>>;
+        readonly thinkingLevel: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<(string & {}) | "minimal" | "low" | "medium" | "high", (string & {}) | "minimal" | "low" | "medium" | "high">>, never>>;
+    }>>, never>>;
+}>;
 declare const GeminiBody: Schema.Struct<{
     cachedContent: Schema.optional<Schema.String>;
     contents: Schema.$Array<Schema.Struct<{
@@ -54,8 +56,8 @@ declare const GeminiBody: Schema.Struct<{
     }>>;
     labels: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     safetySettings: Schema.optional<Schema.$Array<Schema.Struct<{
-        readonly category: Schema.String;
-        readonly threshold: Schema.String;
+        readonly category: Schema.declare<(string & {}) | "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY", (string & {}) | "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY">;
+        readonly threshold: Schema.declare<(string & {}) | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF", (string & {}) | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF">;
     }>>>;
     serviceTier: Schema.optional<Schema.String>;
     systemInstruction: Schema.optional<Schema.Struct<{
@@ -88,7 +90,7 @@ declare const GeminiBody: Schema.Struct<{
         readonly thinkingConfig: Schema.optional<Schema.Struct<{
             readonly thinkingBudget: Schema.optional<Schema.Number>;
             readonly includeThoughts: Schema.optional<Schema.Boolean>;
-            readonly thinkingLevel: Schema.optional<Schema.String>;
+            readonly thinkingLevel: Schema.optional<Schema.declare<(string & {}) | "minimal" | "low" | "medium" | "high", (string & {}) | "minimal" | "low" | "medium" | "high">>;
         }>>;
     }>>;
 }>;
@@ -148,8 +150,8 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly cachedContent?: string | undefined;
     readonly safetySettings?: readonly {
-        readonly category: string;
-        readonly threshold: string;
+        readonly category: (string & {}) | "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY";
+        readonly threshold: (string & {}) | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF";
     }[] | undefined;
     readonly labels?: {
         readonly [x: string]: string;
@@ -170,7 +172,7 @@ export declare const protocol: Protocol<{
         readonly thinkingConfig?: {
             readonly thinkingBudget?: number | undefined;
             readonly includeThoughts?: boolean | undefined;
-            readonly thinkingLevel?: string | undefined;
+            readonly thinkingLevel?: (string & {}) | "minimal" | "low" | "medium" | "high" | undefined;
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;
@@ -255,8 +257,8 @@ export declare const route: Route<{
     } | undefined;
     readonly cachedContent?: string | undefined;
     readonly safetySettings?: readonly {
-        readonly category: string;
-        readonly threshold: string;
+        readonly category: (string & {}) | "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY";
+        readonly threshold: (string & {}) | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF";
     }[] | undefined;
     readonly labels?: {
         readonly [x: string]: string;
@@ -277,7 +279,7 @@ export declare const route: Route<{
         readonly thinkingConfig?: {
             readonly thinkingBudget?: number | undefined;
             readonly includeThoughts?: boolean | undefined;
-            readonly thinkingLevel?: string | undefined;
+            readonly thinkingLevel?: (string & {}) | "minimal" | "low" | "medium" | "high" | undefined;
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;

package/dist/protocols/gemini.js

@@ -7,7 +7,7 @@ import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 import { AIError, LLMEvent, Usage, } 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";
@@ -103,15 +103,33 @@ const GeminiToolConfig = Schema.Struct({
         allowedFunctionNames: optionalArray(Schema.String),
     }),
 });
+const GeminiThinkingLevel = knownString();
 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(),
+    threshold: knownString(),
 });
+// =============================================================================
+// 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()),
+    thinkingConfig: lenient(GeminiThinkingConfigInput),
+});
+const decodeOptions = ProviderShared.validateWith(Schema.decodeUnknownEffect(Options));
 const GeminiGenerationConfig = Schema.Struct({
     maxOutputTokens: Schema.optional(Schema.Number),
     temperature: Schema.optional(Schema.Number),
@@ -334,38 +352,11 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
     flushMedia();
     return contents;
 });
-const resolveOptions = (request) => {
-    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) {
-    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) {
     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,
@@ -376,7 +367,9 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
         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 {
         cachedContent: options.cachedContent,

package/dist/protocols/meta-messages.d.ts

@@ -221,20 +221,20 @@ export declare const protocol: Protocol<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/protocols/shared.d.ts

@@ -10,6 +10,10 @@ export declare const encodeJson: (input: unknown, options?: import("effect/Schem
 export declare const JsonObject: Schema.$Record<Schema.String, Schema.Unknown>;
 export declare const optionalArray: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.$Array<S>>;
 export declare const optionalNull: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.NullOr<S>>;
+/** Optional field whose malformed value decodes to `undefined` instead of failing the enclosing struct. */
+export declare const lenient: <const S extends Schema.Top>(schema: S) => Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<S>, S["DecodingServices"]>>;
+/** Provider-defined string enum: known values for autocomplete, any string accepted at runtime. */
+export declare const knownString: <Known extends string>() => Schema.declare<(string & {}) | Known, (string & {}) | Known>;
 export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
 export declare const promptCacheKey: (request: LLMRequest) => string | undefined;
 /**

package/dist/protocols/shared.js

@@ -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 { InvalidProviderOutputError, InvalidRequestError, UnsupportedOperationError, AIError, HttpContext, LLMRequest, Message, ToolDefinition, } from "../schema/index.js";
@@ -13,6 +13,12 @@ const isJson = Schema.is(Schema.Json);
 export const JsonObject = Schema.Record(Schema.String, Schema.Unknown);
 export const optionalArray = (schema) => Schema.optional(Schema.Array(schema));
 export const optionalNull = (schema) => Schema.optional(Schema.NullOr(schema));
+/** Optional field whose malformed value decodes to `undefined` instead of failing the enclosing struct. */
+export const lenient = (schema) => 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) => typeof value === "string", {
+    expected: "string",
+});
 export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
 // OpenAI limits `prompt_cache_key` to 64 chars; DeepSeek and Zai inherit the same
 // limit via their OpenAI-compatible APIs. Clamp with unicode-aware slicing.

package/dist/protocols/utils/open-responses-options.d.ts

@@ -24,25 +24,25 @@ export declare const StreamOptions: Schema.Struct<{
     readonly includeObfuscation: Schema.optional<Schema.Boolean>;
 }>;
 export declare const Options: Schema.Struct<{
-    readonly store: Schema.optional<Schema.Boolean>;
-    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
-    readonly safetyIdentifier: Schema.optional<Schema.String>;
-    readonly streamOptions: Schema.optional<Schema.Struct<{
+    readonly store: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Boolean>, never>>;
+    readonly metadata: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Record<Schema.String, Schema.String>>, never>>;
+    readonly safetyIdentifier: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.String>, never>>;
+    readonly streamOptions: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Struct<{
         readonly includeObfuscation: Schema.optional<Schema.Boolean>;
-    }>>;
-    readonly topLogprobs: Schema.optional<Schema.Int>;
-    readonly reasoningEffort: Schema.optional<Schema.declare<ReasoningEffort, ReasoningEffort>>;
-    readonly reasoningSummary: Schema.optional<Schema.Literals<readonly ["auto", "concise", "detailed"]>>;
-    readonly include: Schema.optional<Schema.$Array<Schema.declare<ResponseIncludable, ResponseIncludable>>>;
-    readonly textVerbosity: Schema.optional<Schema.declare<TextVerbosity, TextVerbosity>>;
-    readonly serviceTier: Schema.optional<Schema.declare<ServiceTier, ServiceTier>>;
-    readonly truncation: Schema.optional<Schema.Literals<readonly ["auto", "disabled"]>>;
-    readonly allowedTools: Schema.optional<Schema.Struct<{
+    }>>, never>>;
+    readonly topLogprobs: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Int>, never>>;
+    readonly reasoningEffort: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<ReasoningEffort, ReasoningEffort>>, never>>;
+    readonly reasoningSummary: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Literals<readonly ["auto", "concise", "detailed"]>>, never>>;
+    readonly include: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.$Array<Schema.declare<ResponseIncludable, ResponseIncludable>>>, never>>;
+    readonly textVerbosity: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<TextVerbosity, TextVerbosity>>, never>>;
+    readonly serviceTier: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.declare<ServiceTier, ServiceTier>>, never>>;
+    readonly truncation: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Literals<readonly ["auto", "disabled"]>>, never>>;
+    readonly allowedTools: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Struct<{
         readonly toolNames: Schema.$Array<Schema.String>;
         readonly mode: Schema.optional<Schema.Literals<readonly ["auto", "none", "required"]>>;
-    }>>;
-    readonly maxToolCalls: Schema.optional<Schema.Int>;
-    readonly parallelToolCalls: Schema.optional<Schema.Boolean>;
+    }>>, never>>;
+    readonly maxToolCalls: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Int>, never>>;
+    readonly parallelToolCalls: Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.Boolean>, never>>;
 }>;
 export type Options = typeof Options.Type;
 export type Resolved = Omit<Options, "allowedTools"> & {

package/dist/protocols/utils/open-responses-options.js

@@ -1,5 +1,6 @@
-import { Option, Schema } from "effect";
+import { Schema } from "effect";
 import { ReasoningEffort, ReasoningEfforts } from "../../schema/index.js";
+import { lenient } from "../shared.js";
 export { ReasoningEffort, ReasoningEfforts };
 export const TextVerbosities = ["low", "medium", "high"];
 export const TextVerbosity = Schema.declare((value) => typeof value === "string", { title: "TextVerbosity" });
@@ -29,27 +30,26 @@ export const AllowedTools = Schema.Struct({
 export const StreamOptions = Schema.Struct({
     includeObfuscation: Schema.optional(Schema.Boolean),
 });
+// Malformed options are dropped one at a time so a bad `topLogprobs` cannot discard `store` or `reasoningEffort`.
 export const Options = Schema.Struct({
-    store: Schema.optional(Schema.Boolean),
-    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-    safetyIdentifier: Schema.optional(Schema.String),
-    streamOptions: Schema.optional(StreamOptions),
-    topLogprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
-    reasoningEffort: Schema.optional(ReasoningEffort),
-    reasoningSummary: Schema.optional(Schema.Literals(["auto", "concise", "detailed"])),
-    include: Schema.optional(Schema.Array(ResponseIncludableSchema)),
-    textVerbosity: Schema.optional(TextVerbositySchema),
-    serviceTier: Schema.optional(ServiceTierSchema),
-    truncation: Schema.optional(TruncationSchema),
-    allowedTools: Schema.optional(AllowedTools),
-    maxToolCalls: Schema.optional(Schema.Int),
-    parallelToolCalls: Schema.optional(Schema.Boolean),
+    store: lenient(Schema.Boolean),
+    metadata: lenient(Schema.Record(Schema.String, Schema.String)),
+    safetyIdentifier: lenient(Schema.String),
+    streamOptions: lenient(StreamOptions),
+    topLogprobs: lenient(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
+    reasoningEffort: lenient(ReasoningEffort),
+    reasoningSummary: lenient(Schema.Literals(["auto", "concise", "detailed"])),
+    include: lenient(Schema.Array(ResponseIncludableSchema)),
+    textVerbosity: lenient(TextVerbositySchema),
+    serviceTier: lenient(ServiceTierSchema),
+    truncation: lenient(TruncationSchema),
+    allowedTools: lenient(AllowedTools),
+    maxToolCalls: lenient(Schema.Int),
+    parallelToolCalls: lenient(Schema.Boolean),
 });
-const decodeOptions = Schema.decodeUnknownOption(Options);
+const decodeOptions = Schema.decodeUnknownSync(Options);
 export const resolve = (request) => {
-    const input = Option.getOrUndefined(decodeOptions(request.providerOptions));
-    if (!input)
-        return {};
+    const input = decodeOptions(request.providerOptions ?? {});
     return {
         ...input,
         include: input.include?.length ? input.include : undefined,

package/dist/protocols/zai-messages.d.ts

@@ -222,7 +222,7 @@ export declare const protocol: Protocol<{
     readonly thinking?: {
         readonly type: string;
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/alibaba.d.ts

@@ -360,7 +360,7 @@ export declare const routes: (Route<{
         readonly type: string;
         readonly budget_tokens?: number | undefined;
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/anthropic-compatible.d.ts

@@ -238,20 +238,20 @@ export declare const routes: import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/anthropic.d.ts

@@ -223,20 +223,20 @@ export declare const routes: import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/cloudflare-ai-gateway.d.ts

@@ -474,20 +474,20 @@ export declare const messagesRoute: import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {
@@ -846,20 +846,20 @@ export declare const routes: (import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/google-vertex-messages.d.ts

@@ -236,20 +236,20 @@ export declare const routes: Route<{
     thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    service_tier?: "auto" | "standard_only" | undefined;
+    service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/google-vertex.d.ts

@@ -76,8 +76,8 @@ export declare const routes: Route<{
     } | undefined;
     readonly cachedContent?: string | undefined;
     readonly safetySettings?: readonly {
-        readonly category: string;
-        readonly threshold: string;
+        readonly category: (string & {}) | "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY";
+        readonly threshold: (string & {}) | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF";
     }[] | undefined;
     readonly labels?: {
         readonly [x: string]: string;
@@ -98,7 +98,7 @@ export declare const routes: Route<{
         readonly thinkingConfig?: {
             readonly thinkingBudget?: number | undefined;
             readonly includeThoughts?: boolean | undefined;
-            readonly thinkingLevel?: string | undefined;
+            readonly thinkingLevel?: (string & {}) | "minimal" | "low" | "medium" | "high" | undefined;
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;

package/dist/providers/google.d.ts

@@ -58,8 +58,8 @@ export declare const routes: import("../route/client.js").Route<{
     } | undefined;
     readonly cachedContent?: string | undefined;
     readonly safetySettings?: readonly {
-        readonly category: string;
-        readonly threshold: string;
+        readonly category: (string & {}) | "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY";
+        readonly threshold: (string & {}) | "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF";
     }[] | undefined;
     readonly labels?: {
         readonly [x: string]: string;
@@ -80,7 +80,7 @@ export declare const routes: import("../route/client.js").Route<{
         readonly thinkingConfig?: {
             readonly thinkingBudget?: number | undefined;
             readonly includeThoughts?: boolean | undefined;
-            readonly thinkingLevel?: string | undefined;
+            readonly thinkingLevel?: (string & {}) | "minimal" | "low" | "medium" | "high" | undefined;
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;

package/dist/providers/meta.d.ts

@@ -548,20 +548,20 @@ export declare const routes: (Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/minimax.d.ts

@@ -249,20 +249,20 @@ export declare const routes: (Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/moonshot.d.ts

@@ -247,20 +247,20 @@ export declare const routes: (Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: "summarized" | "omitted" | undefined;
+        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
+            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/zai-coding-plan.d.ts

@@ -508,7 +508,7 @@ export declare const routes: (Route<{
     readonly thinking?: {
         readonly type: string;
     } | undefined;
-    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "2.0.7",
+    "@opencode/http-recorder": "2.0.9",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -40,7 +40,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "2.0.7",
+    "@opencode/schema": "2.0.9",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"