@opencode-ai/ai 0.0.0-dev-18002 → 0.0.0-dev-18035

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

@@ -15,6 +15,7 @@ export type ThinkingInput = {
     readonly type: "disabled";
 } | ({
     readonly type: "enabled";
+    readonly display?: "summarized" | "omitted";
 } & ({
     readonly budgetTokens: number;
     readonly budget_tokens?: number;
@@ -194,6 +195,7 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
     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"]>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"adaptive">;
         readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
@@ -369,6 +371,7 @@ export declare const protocol: Protocol<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
@@ -611,6 +614,7 @@ export declare const route: Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

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);
@@ -145,6 +146,7 @@ const AnthropicThinking = Schema.Union([
     Schema.Struct({
         type: Schema.tag("enabled"),
         budget_tokens: Schema.Number,
+        display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
     }),
     Schema.Struct({
         type: Schema.tag("adaptive"),
@@ -490,14 +492,11 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
 const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input) {
     if (!ProviderShared.isRecord(input))
         return undefined;
-    if (input.type === "adaptive") {
-        const display = input.display === "summarized"
-            ? "summarized"
-            : input.display === "omitted"
-                ? "omitted"
-                : undefined;
+    const display = input.display === "summarized" || input.display === "omitted"
+        ? input.display
+        : undefined;
+    if (input.type === "adaptive")
         return { type: "adaptive", ...(display === undefined ? {} : { display }) };
-    }
     if (input.type === "disabled")
         return { type: "disabled" };
     if (input.type !== "enabled")
@@ -509,7 +508,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
             : undefined;
     if (budget === undefined)
         return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens");
-    return { type: "enabled", budget_tokens: budget };
+    return { type: "enabled", budget_tokens: budget, ...(display === undefined ? {} : { display }) };
 });
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
     const generation = request.generation;
@@ -829,11 +828,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.js

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
-import { AIError, LLMEvent, Usage, } from "../schema/index.js";
+import { AIError, LLMEvent, ProviderInternalReason, Usage, } from "../schema/index.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
@@ -234,7 +234,7 @@ export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protoco
         type: "function",
         name: tool.name,
         description: tool.description,
-        parameters: ToolSchemaProjection.responses(inputSchema),
+        parameters: inputSchema,
         // The common tool definition does not currently express Responses strict-schema policy.
         strict: false,
     };
@@ -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 };
@@ -856,11 +856,18 @@ export const providerFailure = (id, event, fallback) => {
         : typeof event.status_code === "number"
             ? event.status_code
             : undefined;
+    const reason = event.type === "error" &&
+        event.error === undefined &&
+        event.response === undefined &&
+        summary === undefined &&
+        status === undefined
+        ? new ProviderInternalReason({ message })
+        : classifyProviderFailure({ message, code, status, rawBody: body });
     return new AIError({
         module: id,
         method: "stream",
         body,
-        reason: classifyProviderFailure({ message, code, status, rawBody: body }),
+        reason,
     });
 };
 const providerError = (state, event, fallback) => providerFailure(state.id, event, fallback);

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,
@@ -170,7 +175,7 @@ const lowerTool = (tool, inputSchema, options) => ({
     function: {
         name: tool.name,
         description: tool.description,
-        parameters: ToolSchemaProjection.openAI(inputSchema),
+        parameters: inputSchema,
     },
     cache_control: options.cacheControl?.(tool.cache),
 });
@@ -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-responses.js

@@ -115,7 +115,6 @@ const HOSTED_TOOLS = {
         name: "mcp",
         input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
     },
-    local_shell_call: { name: "local_shell", input: (item) => item.action ?? {} },
 };
 const step = (state, event) => {
     if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")

package/dist/protocols/utils/tool-schema.js

@@ -1,20 +1,5 @@
 import { isRecord } from "../../utils/record.js";
 import { GeminiToolSchema } from "./gemini-tool-schema.js";
-const removeNullSchemas = (value) => {
-    if (Array.isArray(value))
-        return value.map(removeNullSchemas);
-    if (!isRecord(value))
-        return value;
-    const fields = Object.fromEntries(Object.entries(value)
-        .filter(([key]) => key !== "anyOf")
-        .map(([key, field]) => [key, removeNullSchemas(field)]));
-    if (!Array.isArray(value.anyOf))
-        return fields;
-    const variants = value.anyOf.filter((variant) => !isRecord(variant) || variant.type !== "null").map(removeNullSchemas);
-    if (variants.length === 1 && isRecord(variants[0]))
-        return { ...fields, ...variants[0] };
-    return { ...fields, anyOf: variants };
-};
 const tupleItemsSchema = (items) => {
     const projected = items.map(moonshotNode);
     if (projected.length === 0)
@@ -47,19 +32,7 @@ const moonshot = (schema) => {
     const projected = moonshotNode(schema);
     return isRecord(projected) ? projected : {};
 };
-const openAI = (schema) => {
-    const variants = Array.isArray(schema.anyOf) ? schema.anyOf.filter(isRecord) : [];
-    const flattened = variants.length === 0
-        ? { ...schema, type: "object" }
-        : {
-            ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "anyOf")),
-            type: "object",
-            properties: variants.reduce((properties, variant) => ({ ...(isRecord(variant.properties) ? variant.properties : {}), ...properties }), {}),
-            additionalProperties: false,
-        };
-    const normalized = removeNullSchemas(flattened);
-    return isRecord(normalized) ? normalized : { type: "object" };
-};
+const openAI = (schema) => schema;
 const responses = openAI;
 const gemini = (schema) => GeminiToolSchema.convert(schema) ?? {};
 const modelCompatibility = (schema, compatibility) => {

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

@@ -182,6 +182,7 @@ export declare const routes: import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

package/dist/providers/anthropic.d.ts

@@ -166,6 +166,7 @@ export declare const routes: import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

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

@@ -180,6 +180,7 @@ export declare const routes: Route<{
     thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

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

@@ -28,23 +28,22 @@ export type Settings = ProviderPackage.Settings & ({
 };
 export declare const routes: 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;
@@ -57,7 +56,8 @@ export declare const routes: Route<{
                     };
                 }[] | undefined;
             };
-        })[];
+        })[] | null | undefined;
+        readonly role?: "model" | "user" | null | undefined;
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {

package/dist/providers/google-vertex.js

@@ -14,7 +14,7 @@ const fromRequest = Effect.fn("GoogleVertex.fromRequest")(function* (request) {
     // unlike AI Studio, so history minted there cannot be lowered verbatim.
     const contents = body.contents.map((content) => ({
         ...content,
-        parts: content.parts.map((part) => {
+        parts: (content.parts ?? []).map((part) => {
             if ("functionCall" in part)
                 return { ...part, functionCall: { ...part.functionCall, id: undefined } };
             if ("functionResponse" in part)

package/dist/providers/google.d.ts

@@ -9,23 +9,22 @@ export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export declare const routes: import("../route/client.js").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;
@@ -38,7 +37,8 @@ export declare const routes: import("../route/client.js").Route<{
                     };
                 }[] | undefined;
             };
-        })[];
+        })[] | null | undefined;
+        readonly role?: "model" | "user" | null | undefined;
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {

package/dist/providers/openrouter.d.ts

@@ -288,6 +288,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;
@@ -301,6 +303,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;
@@ -318,6 +321,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/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-18002",
+  "version": "0.0.0-dev-18035",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -29,8 +29,8 @@
   },
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
-    "@effect/platform-node": "4.0.0-rc.110",
-    "@opencode-ai/http-recorder": "0.0.0-dev-18002",
+    "@effect/platform-node": "4.0.0-rc.111",
+    "@opencode-ai/http-recorder": "0.0.0-dev-18035",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,9 +39,9 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-dev-18002",
+    "@opencode-ai/schema": "0.0.0-dev-18035",
     "aws4fetch": "1.0.20",
-    "effect": "4.0.0-rc.110",
+    "effect": "4.0.0-rc.111",
     "google-auth-library": "10.5.0"
   }
 }