@opencode-ai/ai 0.0.0-beta-17941 → 0.0.0-beta-18027

package/dist/protocols/anthropic-messages.js

@@ -24,6 +24,7 @@ const SSE_EVENTS = new Set([
     "content_block_start",
     "content_block_delta",
     "content_block_stop",
+    "ping",
     "error",
 ]);
 export const framing = Framing.sseEvents(SSE_EVENTS);
@@ -829,11 +830,11 @@ const providerErrorMessage = (event) => {
         return `${type}: ${message}`;
     return message || type || "Anthropic Messages stream error";
 };
-const onError = (event) => new AIError({
+const onError = (event) => Effect.fail(new AIError({
     module: ADAPTER,
     method: "stream",
     reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
-});
+}));
 const step = (state, event) => {
     if (event.type === "message_start")
         return Effect.succeed(onMessageStart(state, event));

package/dist/protocols/gemini.d.ts

@@ -21,11 +21,11 @@ export type ProviderOptionsInput = OptionsInput;
 declare const GeminiBody: Schema.Struct<{
     cachedContent: Schema.optional<Schema.String>;
     contents: Schema.$Array<Schema.Struct<{
-        readonly role: Schema.Literals<readonly ["user", "model"]>;
-        readonly parts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly role: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["user", "model"]>>>;
+        readonly parts: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
             readonly text: Schema.String;
-            readonly thought: Schema.optional<Schema.Boolean>;
-            readonly thoughtSignature: Schema.optional<Schema.String>;
+            readonly thought: Schema.optional<Schema.NullOr<Schema.Boolean>>;
+            readonly thoughtSignature: Schema.optional<Schema.NullOr<Schema.String>>;
         }>, Schema.Struct<{
             readonly inlineData: Schema.Struct<{
                 readonly mimeType: Schema.String;
@@ -33,11 +33,11 @@ declare const GeminiBody: Schema.Struct<{
             }>;
         }>, Schema.Struct<{
             readonly functionCall: Schema.Struct<{
-                readonly id: Schema.optional<Schema.String>;
+                readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
                 readonly name: Schema.String;
                 readonly args: Schema.optional<Schema.Unknown>;
             }>;
-            readonly thoughtSignature: Schema.optional<Schema.String>;
+            readonly thoughtSignature: Schema.optional<Schema.NullOr<Schema.String>>;
         }>, Schema.Struct<{
             readonly functionResponse: Schema.Struct<{
                 readonly id: Schema.optional<Schema.String>;
@@ -50,7 +50,7 @@ declare const GeminiBody: Schema.Struct<{
                     }>;
                 }>>>;
             }>;
-        }>]>>;
+        }>]>>>>;
     }>>;
     labels: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     safetySettings: Schema.optional<Schema.$Array<Schema.Struct<{
@@ -99,23 +99,22 @@ export type GeminiBody = Schema.Schema.Type<typeof GeminiBody>;
  */
 export declare const protocol: Protocol<{
     readonly contents: readonly {
-        readonly role: "model" | "user";
-        readonly parts: readonly ({
+        readonly parts?: readonly ({
             readonly inlineData: {
                 readonly mimeType: string;
                 readonly data: string;
             };
         } | {
             readonly text: string;
-            readonly thought?: boolean | undefined;
-            readonly thoughtSignature?: string | undefined;
+            readonly thought?: boolean | null | undefined;
+            readonly thoughtSignature?: string | null | undefined;
         } | {
             readonly functionCall: {
                 readonly name: string;
-                readonly id?: string | undefined;
+                readonly id?: string | null | undefined;
                 readonly args?: unknown;
             };
-            readonly thoughtSignature?: string | undefined;
+            readonly thoughtSignature?: string | null | undefined;
         } | {
             readonly functionResponse: {
                 readonly name: string;
@@ -128,7 +127,8 @@ export declare const protocol: Protocol<{
                     };
                 }[] | undefined;
             };
-        })[];
+        })[] | null | undefined;
+        readonly role?: "model" | "user" | null | undefined;
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {
@@ -177,23 +177,22 @@ export declare const protocol: Protocol<{
 }, string, {
     readonly candidates?: readonly {
         readonly content?: {
-            readonly role: "model" | "user";
-            readonly parts: readonly ({
+            readonly parts?: readonly ({
                 readonly inlineData: {
                     readonly mimeType: string;
                     readonly data: string;
                 };
             } | {
                 readonly text: string;
-                readonly thought?: boolean | undefined;
-                readonly thoughtSignature?: string | undefined;
+                readonly thought?: boolean | null | undefined;
+                readonly thoughtSignature?: string | null | undefined;
             } | {
                 readonly functionCall: {
                     readonly name: string;
-                    readonly id?: string | undefined;
+                    readonly id?: string | null | undefined;
                     readonly args?: unknown;
                 };
-                readonly thoughtSignature?: string | undefined;
+                readonly thoughtSignature?: string | null | undefined;
             } | {
                 readonly functionResponse: {
                     readonly name: string;
@@ -206,46 +205,46 @@ export declare const protocol: Protocol<{
                         };
                     }[] | undefined;
                 };
-            })[];
-        } | undefined;
-        readonly finishReason?: string | undefined;
-    }[] | undefined;
+            })[] | null | undefined;
+            readonly role?: "model" | "user" | null | undefined;
+        } | null | undefined;
+        readonly finishReason?: string | null | undefined;
+    }[] | null | undefined;
     readonly promptFeedback?: {
         readonly [x: string]: unknown;
-        readonly blockReason?: string | undefined;
-        readonly blockReasonMessage?: string | undefined;
+        readonly blockReason?: string | null | undefined;
+        readonly blockReasonMessage?: string | null | undefined;
         readonly safetyRatings?: unknown;
-    } | undefined;
+    } | null | undefined;
     readonly usageMetadata?: {
-        readonly cachedContentTokenCount?: number | undefined;
-        readonly thoughtsTokenCount?: number | undefined;
-        readonly promptTokenCount?: number | undefined;
-        readonly candidatesTokenCount?: number | undefined;
-        readonly totalTokenCount?: number | undefined;
-    } | undefined;
+        readonly cachedContentTokenCount?: number | null | undefined;
+        readonly thoughtsTokenCount?: number | null | undefined;
+        readonly promptTokenCount?: number | null | undefined;
+        readonly candidatesTokenCount?: number | null | undefined;
+        readonly totalTokenCount?: number | null | undefined;
+    } | null | undefined;
 }, {
     hasToolCalls: boolean;
     lifecycle: Lifecycle.State;
 }>;
 export declare const route: Route<{
     readonly contents: readonly {
-        readonly role: "model" | "user";
-        readonly parts: readonly ({
+        readonly parts?: readonly ({
             readonly inlineData: {
                 readonly mimeType: string;
                 readonly data: string;
             };
         } | {
             readonly text: string;
-            readonly thought?: boolean | undefined;
-            readonly thoughtSignature?: string | undefined;
+            readonly thought?: boolean | null | undefined;
+            readonly thoughtSignature?: string | null | undefined;
         } | {
             readonly functionCall: {
                 readonly name: string;
-                readonly id?: string | undefined;
+                readonly id?: string | null | undefined;
                 readonly args?: unknown;
             };
-            readonly thoughtSignature?: string | undefined;
+            readonly thoughtSignature?: string | null | undefined;
         } | {
             readonly functionResponse: {
                 readonly name: string;
@@ -258,7 +257,8 @@ export declare const route: Route<{
                     };
                 }[] | undefined;
             };
-        })[];
+        })[] | null | undefined;
+        readonly role?: "model" | "user" | null | undefined;
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {

package/dist/protocols/gemini.js

@@ -6,7 +6,7 @@ import { Endpoint } from "../route/endpoint.js";
 import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 import { LLMEvent, Usage, } from "../schema/index.js";
-import { JsonObject, optionalArray, ProviderShared } from "./shared.js";
+import { JsonObject, 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";
@@ -29,13 +29,24 @@ const requiresThoughtSignatureFallback = (modelID) => {
 // Gemini 3 accepts media nested inside function responses; matched Gemini 2.5 variants reject it,
 // so their tool-result attachments lower as a separate user turn instead.
 const routesLegacyToolMedia = (modelID) => /gemini-2[.-]5(?:[.-]|$)/i.test(modelID);
+// Blacklist: Gemini 1.x/2.x ignore or reject explicit function call ids.
+// Every other model id (Gemini 3+, gemma, anything unrecognized) gets them.
+const omitsFunctionCallIds = (modelID) => {
+    const match = /^gemini(?:-live)?-(\d+)/i.exec(modelID);
+    return match !== null && Number(match[1]) < 3;
+};
 // =============================================================================
 // Request Body Schema
 // =============================================================================
+// Gemini is known to send explicit `null` for optional streaming fields
+// (usage counts, flags, whole subtrees), so every response-side optional uses
+// `optionalNull` instead of bare `Schema.optional`. The same part/content
+// schemas lower the outbound request body; encoding drops `undefined` keys,
+// so the shared schemas stay safe there.
 const GeminiTextPart = Schema.Struct({
     text: Schema.String,
-    thought: Schema.optional(Schema.Boolean),
-    thoughtSignature: Schema.optional(Schema.String),
+    thought: optionalNull(Schema.Boolean),
+    thoughtSignature: optionalNull(Schema.String),
 });
 const GeminiInlineDataPart = Schema.Struct({
     inlineData: Schema.Struct({
@@ -45,11 +56,11 @@ const GeminiInlineDataPart = Schema.Struct({
 });
 const GeminiFunctionCallPart = Schema.Struct({
     functionCall: Schema.Struct({
-        id: Schema.optional(Schema.String),
+        id: optionalNull(Schema.String),
         name: Schema.String,
         args: Schema.optional(Schema.Unknown),
     }),
-    thoughtSignature: Schema.optional(Schema.String),
+    thoughtSignature: optionalNull(Schema.String),
 });
 const GeminiFunctionResponsePart = Schema.Struct({
     functionResponse: Schema.Struct({
@@ -66,8 +77,8 @@ const GeminiContentPart = Schema.Union([
     GeminiFunctionResponsePart,
 ]);
 const GeminiContent = Schema.Struct({
-    role: Schema.Literals(["user", "model"]),
-    parts: Schema.Array(GeminiContentPart),
+    role: optionalNull(Schema.Literals(["user", "model"])),
+    parts: optionalNull(Schema.Array(GeminiContentPart)),
 });
 const GeminiSystemInstruction = Schema.Struct({
     parts: Schema.Array(Schema.Struct({ text: Schema.String })),
@@ -119,25 +130,25 @@ const GeminiBodyFields = {
 };
 const GeminiBody = Schema.Struct(GeminiBodyFields);
 const GeminiUsage = Schema.Struct({
-    cachedContentTokenCount: Schema.optional(Schema.Number),
-    thoughtsTokenCount: Schema.optional(Schema.Number),
-    promptTokenCount: Schema.optional(Schema.Number),
-    candidatesTokenCount: Schema.optional(Schema.Number),
-    totalTokenCount: Schema.optional(Schema.Number),
+    cachedContentTokenCount: optionalNull(Schema.Number),
+    thoughtsTokenCount: optionalNull(Schema.Number),
+    promptTokenCount: optionalNull(Schema.Number),
+    candidatesTokenCount: optionalNull(Schema.Number),
+    totalTokenCount: optionalNull(Schema.Number),
 });
 const GeminiCandidate = Schema.Struct({
-    content: Schema.optional(GeminiContent),
-    finishReason: Schema.optional(Schema.String),
+    content: optionalNull(GeminiContent),
+    finishReason: optionalNull(Schema.String),
 });
 const GeminiPromptFeedback = Schema.StructWithRest(Schema.Struct({
-    blockReason: Schema.optional(Schema.String),
-    blockReasonMessage: Schema.optional(Schema.String),
-    safetyRatings: Schema.optional(Schema.Unknown),
+    blockReason: optionalNull(Schema.String),
+    blockReasonMessage: optionalNull(Schema.String),
+    safetyRatings: optionalNull(Schema.Unknown),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const GeminiEvent = Schema.Struct({
-    candidates: optionalArray(GeminiCandidate),
-    promptFeedback: Schema.optional(GeminiPromptFeedback),
-    usageMetadata: Schema.optional(GeminiUsage),
+    candidates: optionalNull(Schema.Array(GeminiCandidate)),
+    promptFeedback: optionalNull(GeminiPromptFeedback),
+    usageMetadata: optionalNull(GeminiUsage),
 });
 // =============================================================================
 // Tool Schema Conversion
@@ -188,18 +199,13 @@ const thoughtSignature = (providerMetadata) => {
         ? google.thoughtSignature
         : undefined;
 };
-const functionCallId = (providerMetadata) => {
-    const google = providerMetadata?.google;
-    return ProviderShared.isRecord(google) && typeof google.functionCallId === "string"
-        ? google.functionCallId
-        : undefined;
-};
-const lowerToolCall = (part) => ({
-    functionCall: { id: functionCallId(part.providerMetadata), name: part.name, args: part.input },
+const lowerToolCall = (part, omitIds) => ({
+    functionCall: { ...(omitIds ? {} : { id: part.id }), name: part.name, args: part.input },
     thoughtSignature: thoughtSignature(part.providerMetadata),
 });
 const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
     const contents = [];
+    const omitCallIds = omitsFunctionCallIds(request.model.id);
     const legacyToolMedia = routesLegacyToolMedia(request.model.id);
     let pendingMedia;
     const flushMedia = () => {
@@ -216,8 +222,8 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
             const previous = contents.at(-1);
             // Gemini rejects a continuation whose function-response turn carries extra
             // parts, so an update after a tool result starts its own user turn.
-            if (previous?.role === "user" && !previous.parts.some((item) => "functionResponse" in item))
-                contents[contents.length - 1] = { role: "user", parts: [...previous.parts, { text: part.text }] };
+            if (previous?.role === "user" && !(previous.parts ?? []).some((item) => "functionResponse" in item))
+                contents[contents.length - 1] = { role: "user", parts: [...(previous.parts ?? []), { text: part.text }] };
             else
                 contents.push({ role: "user", parts: [{ text: part.text }] });
             continue;
@@ -248,7 +254,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
                     continue;
                 }
                 if (part.type === "tool-call") {
-                    const lowered = lowerToolCall(part);
+                    const lowered = lowerToolCall(part, omitCallIds);
                     const signature = lowered.thoughtSignature;
                     parts.push({
                         ...lowered,
@@ -272,7 +278,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
             if (part.result.type !== "content") {
                 parts.push({
                     functionResponse: {
-                        id: functionCallId(part.providerMetadata),
+                        ...(omitCallIds ? {} : { id: part.id }),
                         name: part.name,
                         response: {
                             name: part.name,
@@ -295,7 +301,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
                 (pendingMedia ??= []).push(...media);
             parts.push({
                 functionResponse: {
-                    id: functionCallId(part.providerMetadata),
+                    ...(omitCallIds ? {} : { id: part.id }),
                     name: part.name,
                     response: {
                         name: part.name,
@@ -308,8 +314,8 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
         // Gemini requires every response to a parallel call batch in one user turn,
         // so consecutive tool results join the open function-response turn.
         const previous = contents.at(-1);
-        if (previous?.role === "user" && previous.parts.some((item) => "functionResponse" in item))
-            contents[contents.length - 1] = { role: "user", parts: [...previous.parts, ...parts] };
+        if (previous?.role === "user" && (previous.parts ?? []).some((item) => "functionResponse" in item))
+            contents[contents.length - 1] = { role: "user", parts: [...(previous.parts ?? []), ...parts] };
         else
             contents.push({ role: "user", parts });
     }
@@ -388,20 +394,25 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
 const mapUsage = (usage) => {
     if (!usage)
         return undefined;
-    const cached = usage.cachedContentTokenCount;
-    const nonCached = ProviderShared.subtractTokens(usage.promptTokenCount, cached);
+    // Explicit provider nulls decode as `null`; normalize to `undefined` so the
+    // token arithmetic below treats them like absent counts.
+    const promptTokens = usage.promptTokenCount ?? undefined;
+    const cached = usage.cachedContentTokenCount ?? undefined;
+    const thoughts = usage.thoughtsTokenCount ?? undefined;
+    const visible = usage.candidatesTokenCount ?? undefined;
+    const nonCached = ProviderShared.subtractTokens(promptTokens, cached);
     // `candidatesTokenCount` is visible-only; sum with thoughts to produce the
     // inclusive `outputTokens` the contract expects. Only compute the total
     // when the visible component is reported — otherwise we'd fabricate an
     // inclusive number from a partial breakdown.
-    const outputTokens = usage.candidatesTokenCount !== undefined ? usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0) : undefined;
+    const outputTokens = visible !== undefined ? visible + (thoughts ?? 0) : undefined;
     return new Usage({
-        inputTokens: usage.promptTokenCount,
+        inputTokens: promptTokens,
         outputTokens,
         nonCachedInputTokens: nonCached,
         cacheReadInputTokens: cached,
-        reasoningTokens: usage.thoughtsTokenCount,
-        totalTokens: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
+        reasoningTokens: thoughts,
+        totalTokens: ProviderShared.totalTokens(promptTokens, outputTokens, usage.totalTokenCount ?? undefined),
         providerMetadata: { google: usage },
     });
 };
@@ -433,7 +444,9 @@ const mapFinishReason = (finishReason, hasToolCalls) => {
     return "unknown";
 };
 const finish = (state) => {
-    const promptBlockReason = state.finishReason === undefined ? state.promptFeedback?.blockReason : undefined;
+    // `?? undefined` normalizes an explicit `null` blockReason back to absent so
+    // the "nothing to finish" check below keeps its meaning.
+    const promptBlockReason = state.finishReason === undefined ? (state.promptFeedback?.blockReason ?? undefined) : undefined;
     const finishReason = state.finishReason ?? promptBlockReason;
     if (finishReason === undefined && state.usage === undefined)
         return [];
@@ -470,7 +483,9 @@ const step = (state, event) => {
     let lifecycle = nextState.lifecycle;
     let reasoningSignature = nextState.reasoningSignature;
     let textSignature = nextState.textSignature;
-    for (const part of candidate.content.parts) {
+    // Supplier ids must be tracked across chunks of the same response, not just within one event's parts.
+    const seenCallIds = new Set(nextState.seenCallIds);
+    for (const part of candidate.content.parts ?? []) {
         const signature = "thoughtSignature" in part && part.thoughtSignature ? part.thoughtSignature : undefined;
         // Gemini attaches replay signatures to thought parts, visible text, or function calls;
         // each block kind must retain the signature attached to its own parts.
@@ -490,20 +505,22 @@ const step = (state, event) => {
         }
         if ("functionCall" in part) {
             const input = part.functionCall.args === undefined ? {} : part.functionCall.args;
-            // Gemini 2.0+ and Vertex supply a unique function call ID on the part; when omitted (e.g. Gemini 1.5),
+            // Gemini 2.0+ supplies a unique function call ID on the part; when omitted (e.g. Gemini 1.5),
             // generate a globally unique ID rather than a per-request counter to prevent cross-request collisions in downstream registries.
-            const id = part.functionCall.id ?? `tool_${crypto.randomUUID().replaceAll("-", "")}`;
-            const metadata = {
-                ...(part.functionCall.id === undefined ? {} : { functionCallId: part.functionCall.id }),
-                ...(part.thoughtSignature === undefined ? {} : { thoughtSignature: part.thoughtSignature }),
-            };
+            // A repeated supplier id would replay as two identical calls, so only the first occurrence keeps it.
+            // A `null` supplier id normalizes to absent so the generated-id fallback applies.
+            const supplied = part.functionCall.id ?? undefined;
+            const duplicate = supplied !== undefined && seenCallIds.has(supplied);
+            if (supplied !== undefined)
+                seenCallIds.add(supplied);
+            const id = supplied !== undefined && !duplicate ? supplied : `tool_${crypto.randomUUID().replaceAll("-", "")}`;
             lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined);
             lifecycle = Lifecycle.stepStart(lifecycle, events);
             events.push(LLMEvent.toolCall({
                 id,
                 name: part.functionCall.name,
                 input,
-                providerMetadata: Object.keys(metadata).length > 0 ? googleMetadata(metadata) : undefined,
+                providerMetadata: part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined,
             }));
             hasToolCalls = true;
         }
@@ -515,6 +532,7 @@ const step = (state, event) => {
             lifecycle,
             reasoningSignature,
             textSignature,
+            seenCallIds,
             finishReason: candidate.finishReason ?? nextState.finishReason,
         },
         events,

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

@@ -207,7 +207,7 @@ export declare const coreFields: {
     }>>;
     top_logprobs: Schema.optional<Schema.Int>;
     truncation: Schema.optional<Schema.Literals<readonly ["auto", "disabled"]>>;
-    service_tier: Schema.optional<Schema.Literals<readonly ["auto", "default", "flex", "priority"]>>;
+    service_tier: Schema.optional<Schema.declare<OpenResponsesOptions.ServiceTier, OpenResponsesOptions.ServiceTier>>;
     prompt_cache_key: Schema.optional<Schema.String>;
     include: Schema.optional<Schema.$Array<Schema.declare<OpenResponsesOptions.ResponseIncludable, OpenResponsesOptions.ResponseIncludable>>>;
     reasoning: Schema.optional<Schema.Struct<{
@@ -320,7 +320,7 @@ declare const OpenResponsesBody: Schema.Struct<{
     }>>;
     readonly top_logprobs: Schema.optional<Schema.Int>;
     readonly truncation: Schema.optional<Schema.Literals<readonly ["auto", "disabled"]>>;
-    readonly service_tier: Schema.optional<Schema.Literals<readonly ["auto", "default", "flex", "priority"]>>;
+    readonly service_tier: Schema.optional<Schema.declare<OpenResponsesOptions.ServiceTier, OpenResponsesOptions.ServiceTier>>;
     readonly prompt_cache_key: Schema.optional<Schema.String>;
     readonly include: Schema.optional<Schema.$Array<Schema.declare<OpenResponsesOptions.ResponseIncludable, OpenResponsesOptions.ResponseIncludable>>>;
     readonly reasoning: Schema.optional<Schema.Struct<{
@@ -451,7 +451,6 @@ export interface ParserState {
     readonly hasFunctionCall: boolean;
     readonly lifecycle: Lifecycle.State;
     readonly messageItems: ReadonlySet<string>;
-    readonly messagePhase: (value: unknown) => MessagePhase | null | undefined;
     readonly messagePhases: Readonly<Record<string, MessagePhase | null>>;
     readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>;
     readonly store: boolean | undefined;
@@ -480,7 +479,7 @@ export declare const fromRequestWithExtension: (request: LLMRequest, extension:
     truncation?: "auto" | "disabled" | undefined;
     parallel_tool_calls?: boolean | undefined;
     max_tool_calls?: number | undefined;
-    service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    service_tier?: OpenResponsesOptions.ServiceTier | undefined;
     text?: {
         verbosity: OpenResponsesOptions.TextVerbosity;
     } | undefined;
@@ -641,7 +640,7 @@ export declare const fromRequest: (request: LLMRequest) => Effect.Effect<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: OpenResponsesOptions.ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -951,7 +950,7 @@ export declare const protocol: Protocol<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: OpenResponsesOptions.ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -1122,7 +1121,7 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly service_tier?: OpenResponsesOptions.ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;