@opencode-ai/ai 0.0.0-dev-18001 → 0.0.0-dev-18017

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";
@@ -38,10 +38,15 @@ const omitsFunctionCallIds = (modelID) => {
 // =============================================================================
 // 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({
@@ -51,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({
@@ -72,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 })),
@@ -125,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
@@ -217,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;
@@ -309,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 });
     }
@@ -389,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 },
     });
 };
@@ -434,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 [];
@@ -473,7 +485,7 @@ const step = (state, event) => {
     let textSignature = nextState.textSignature;
     // 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) {
+    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.
@@ -496,7 +508,8 @@ const step = (state, event) => {
             // 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.
             // A repeated supplier id would replay as two identical calls, so only the first occurrence keeps it.
-            const supplied = part.functionCall.id;
+            // 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);
@@ -507,7 +520,7 @@ const step = (state, event) => {
                 id,
                 name: part.functionCall.name,
                 input,
-                providerMetadata: part.thoughtSignature === undefined ? undefined : googleMetadata({ thoughtSignature: part.thoughtSignature }),
+                providerMetadata: part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined,
             }));
             hasToolCalls = true;
         }

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<{
@@ -479,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;
@@ -640,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;
@@ -950,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;
@@ -1121,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;

package/dist/protocols/open-responses.js

@@ -290,7 +290,7 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (part, reques
         return {
             type: "input_file",
             filename: part.filename ?? (media.mime === "application/pdf" ? "document.pdf" : "file"),
-            ...(url ? { file_url: url } : { file_data: media.base64 }),
+            ...(url ? { file_url: url } : { file_data: media.dataUrl }),
         };
     }
     return { type: "input_image", image_url: url ?? media.dataUrl };

package/dist/protocols/openai-chat.d.ts

@@ -201,7 +201,7 @@ declare const OpenAIChatBody: Schema.Struct<{
 }>;
 export type OpenAIChatBody = Schema.Schema.Type<typeof OpenAIChatBody>;
 export declare const OpenAIChatEvent: Schema.Struct<{
-    readonly choices: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
+    readonly choices: Schema.optional<Schema.NullOr<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
         readonly delta: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
             readonly content: Schema.optional<Schema.NullOr<Schema.String>>;
             readonly refusal: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -220,11 +220,29 @@ export declare const OpenAIChatEvent: Schema.Struct<{
         }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
         readonly finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
         readonly native_finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>>>>;
+        readonly usage: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+            readonly prompt_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly completion_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly total_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly prompt_cache_hit_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly prompt_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+                readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+                readonly cache_write_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+            readonly completion_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+                readonly reasoning_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+                readonly accepted_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+                readonly rejected_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>>;
     readonly usage: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
         readonly prompt_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
         readonly completion_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
         readonly total_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly prompt_cache_hit_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
         readonly prompt_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
             readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
             readonly cache_write_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
@@ -566,6 +584,8 @@ export declare const protocol: Protocol<{
         readonly prompt_tokens?: number | null | undefined;
         readonly completion_tokens?: number | null | undefined;
         readonly total_tokens?: number | null | undefined;
+        readonly cached_tokens?: number | null | undefined;
+        readonly prompt_cache_hit_tokens?: number | null | undefined;
         readonly prompt_tokens_details?: {
             readonly [x: string]: unknown;
             readonly cached_tokens?: number | null | undefined;
@@ -579,6 +599,7 @@ export declare const protocol: Protocol<{
         } | null | undefined;
     } | null | undefined;
     readonly choices?: readonly {
+        readonly [x: string]: unknown;
         readonly delta?: {
             readonly [x: string]: unknown;
             readonly reasoning?: string | null | undefined;
@@ -596,6 +617,25 @@ export declare const protocol: Protocol<{
             }[] | null | undefined;
             readonly reasoning_details?: unknown;
         } | null | undefined;
+        readonly usage?: {
+            readonly [x: string]: unknown;
+            readonly prompt_tokens?: number | null | undefined;
+            readonly completion_tokens?: number | null | undefined;
+            readonly total_tokens?: number | null | undefined;
+            readonly cached_tokens?: number | null | undefined;
+            readonly prompt_cache_hit_tokens?: number | null | undefined;
+            readonly prompt_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly cached_tokens?: number | null | undefined;
+                readonly cache_write_tokens?: number | null | undefined;
+            } | null | undefined;
+            readonly completion_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly reasoning_tokens?: number | null | undefined;
+                readonly accepted_prediction_tokens?: number | null | undefined;
+                readonly rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
         readonly finish_reason?: string | null | undefined;
         readonly native_finish_reason?: string | null | undefined;
     }[] | null | undefined;

package/dist/protocols/openai-chat.js

@@ -123,6 +123,9 @@ const OpenAIChatUsage = Schema.StructWithRest(Schema.Struct({
     prompt_tokens: optionalNull(Schema.Number),
     completion_tokens: optionalNull(Schema.Number),
     total_tokens: optionalNull(Schema.Number),
+    // Zai reports cache hits as top-level `cached_tokens`; DeepSeek uses `prompt_cache_hit_tokens`.
+    cached_tokens: optionalNull(Schema.Number),
+    prompt_cache_hit_tokens: optionalNull(Schema.Number),
     prompt_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
         cached_tokens: optionalNull(Schema.Number),
         cache_write_tokens: optionalNull(Schema.Number),
@@ -151,11 +154,13 @@ const OpenAIChatDelta = Schema.StructWithRest(Schema.Struct({
     reasoning_details: optionalNull(Schema.Unknown),
     tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
-const OpenAIChatChoice = Schema.Struct({
+const OpenAIChatChoice = Schema.StructWithRest(Schema.Struct({
     delta: optionalNull(OpenAIChatDelta),
     finish_reason: optionalNull(Schema.String),
     native_finish_reason: optionalNull(Schema.String),
-});
+    // Moonshot streams usage on `choice.usage` instead of top-level `usage`.
+    usage: optionalNull(OpenAIChatUsage),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
 const OpenAIChatError = Schema.Struct({
     code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
     message: Schema.String,
@@ -396,6 +401,18 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
     flushImages();
     return messages;
 });
+// Anthropic via LiteLLM and Amazon Bedrock require `tools` to be present
+// whenever the conversation history contains tool calls/results. Send an
+// explicit empty array when we have history but no active tools.
+const hasToolHistory = (messages) => {
+    for (const message of messages) {
+        if (message.role === "tool")
+            return true;
+        if (message.role === "assistant" && message.content.some((part) => part.type === "tool-call"))
+            return true;
+    }
+    return false;
+};
 const lowerOptions = (request) => {
     const options = OpenAIOptions.resolve(request);
     return {
@@ -413,11 +430,14 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
     const generation = request.generation;
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     const maxTokensField = request.model.compatibility?.maxTokensField ?? "max_tokens";
+    const hasHistory = hasToolHistory(request.messages);
     return {
         model: request.model.id,
         messages: yield* lowerMessages(request, options),
         tools: request.tools.length === 0
-            ? undefined
+            ? hasHistory
+                ? []
+                : undefined
             : request.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility), options)),
         tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
         stream: true,
@@ -458,12 +478,18 @@ const mapFinishReason = (reason) => {
 // total) with a `reasoning_tokens` subset. We pass the inclusive totals
 // through and derive the non-cached breakdown so the `AI.Usage` contract is
 // satisfied on both sides.
+// Providers differ on cache-hit location: OpenAI uses
+// `prompt_tokens_details.cached_tokens`, DeepSeek uses
+// `prompt_cache_hit_tokens`, and Zai uses top-level `cached_tokens`.
 const mapUsage = (usage) => {
     if (!usage)
         return undefined;
     const input = usage.prompt_tokens ?? undefined;
     const output = usage.completion_tokens ?? undefined;
-    const cached = usage.prompt_tokens_details?.cached_tokens ?? undefined;
+    const cached = (usage.prompt_tokens_details?.cached_tokens ??
+        usage.prompt_cache_hit_tokens ??
+        usage.cached_tokens ??
+        undefined);
     const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens ?? undefined;
     const reasoning = usage.completion_tokens_details?.reasoning_tokens ?? undefined;
     const nonCached = ProviderShared.subtractTokens(input, ProviderShared.sumTokens(cached, cacheWrite));
@@ -554,8 +580,11 @@ const step = (state, event) => Effect.gen(function* () {
             }),
         });
     const events = [];
-    const usage = mapUsage(event.usage) ?? state.usage;
     const choice = event.choices?.[0];
+    // Moonshot (and a few other OpenAI-compatible providers) attach usage to
+    // `choice.usage` instead of the top-level `usage` field.
+    const choiceUsage = choice?.usage;
+    const usage = mapUsage(event.usage) ?? (choiceUsage ? mapUsage(choiceUsage) : undefined) ?? state.usage;
     const rawFinishReason = choice?.finish_reason;
     const finishReason = rawFinishReason !== undefined && rawFinishReason !== null
         ? { normalized: mapFinishReason(rawFinishReason), raw: choice?.native_finish_reason ?? rawFinishReason }

package/dist/protocols/openai-compatible-responses.d.ts

@@ -117,7 +117,7 @@ export declare const route: Route<{
     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?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;