@opencode-ai/ai 0.0.0-next-16897 → 0.0.0-next-16899

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

@@ -207,7 +207,7 @@ export declare const OpenAIChatEvent: Schema.Struct<{
             readonly reasoning_text: Schema.optional<Schema.NullOr<Schema.String>>;
             readonly reasoning_details: Schema.optional<Schema.NullOr<Schema.Unknown>>;
             readonly tool_calls: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
-                readonly index: Schema.Number;
+                readonly index: Schema.optional<Schema.NullOr<Schema.Number>>;
                 readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
                 readonly function: Schema.optional<Schema.NullOr<Schema.Struct<{
                     readonly name: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -218,18 +218,20 @@ export declare const OpenAIChatEvent: Schema.Struct<{
         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.Struct<{
-        readonly prompt_tokens: Schema.optional<Schema.Number>;
-        readonly completion_tokens: Schema.optional<Schema.Number>;
-        readonly total_tokens: Schema.optional<Schema.Number>;
-        readonly prompt_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
-            readonly cached_tokens: Schema.optional<Schema.Number>;
-            readonly cache_write_tokens: Schema.optional<Schema.Number>;
-        }>>>;
-        readonly completion_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
-            readonly reasoning_tokens: Schema.optional<Schema.Number>;
-        }>>>;
-    }>>>;
+    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 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 error: Schema.optional<Schema.NullOr<Schema.Struct<{
         readonly code: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.Number]>>>;
         readonly message: Schema.String;
@@ -252,6 +254,8 @@ export interface ParserState {
     readonly reasoningDetails: Array<unknown>;
     readonly reasoningDetailsObserved: boolean;
     readonly reasoningEmitted: boolean;
+    readonly latestToolIndex?: number;
+    readonly nextToolIndex: number;
 }
 interface LoweringOptions {
     readonly cacheControl?: (cache: CacheHint | undefined) => Schema.Schema.Type<typeof OpenAIChatCacheControl> | undefined;
@@ -552,15 +556,20 @@ export declare const protocol: Protocol<{
         readonly code?: string | number | null | undefined;
     } | null | undefined;
     readonly usage?: {
-        readonly prompt_tokens?: number | undefined;
-        readonly completion_tokens?: number | undefined;
-        readonly total_tokens?: number | undefined;
+        readonly [x: string]: unknown;
+        readonly prompt_tokens?: number | null | undefined;
+        readonly completion_tokens?: number | null | undefined;
+        readonly total_tokens?: number | null | undefined;
         readonly prompt_tokens_details?: {
-            readonly cached_tokens?: number | undefined;
-            readonly cache_write_tokens?: number | undefined;
+            readonly [x: string]: unknown;
+            readonly cached_tokens?: number | null | undefined;
+            readonly cache_write_tokens?: number | null | undefined;
         } | null | undefined;
         readonly completion_tokens_details?: {
-            readonly reasoning_tokens?: number | undefined;
+            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 choices?: readonly {
@@ -571,12 +580,12 @@ export declare const protocol: Protocol<{
             readonly reasoning_text?: string | null | undefined;
             readonly content?: string | null | undefined;
             readonly tool_calls?: readonly {
-                readonly index: number;
                 readonly function?: {
                     readonly name?: string | null | undefined;
                     readonly arguments?: string | null | undefined;
                 } | null | undefined;
                 readonly id?: string | null | undefined;
+                readonly index?: number | null | undefined;
             }[] | null | undefined;
             readonly reasoning_details?: unknown;
         } | null | undefined;

package/dist/protocols/openai-chat.js

@@ -45,6 +45,11 @@ const OpenAIChatAssistantToolCall = Schema.Struct({
         arguments: Schema.String,
     }),
 });
+// Intentionally omit Gemini's provider-specific `extra_content.google.thought_signature`
+// extension until direct Google OpenAI-compatible routing is supported here:
+// https://github.com/vercel/ai/issues/11590
+// https://github.com/vercel/ai/pull/11745
+// https://ai.google.dev/gemini-api/docs/thought-signatures#openai
 const OpenAIChatUserContent = Schema.Union([
     Schema.Struct({
         type: Schema.Literal("text"),
@@ -114,24 +119,26 @@ const OpenAIChatBody = Schema.Struct(bodyFields);
 // The event schema is one decoded SSE `data:` payload. `Framing.sse` splits the
 // byte stream into strings, then `Protocol.jsonEvent` decodes each string into
 // this provider-native event shape.
-const OpenAIChatUsage = Schema.Struct({
-    prompt_tokens: Schema.optional(Schema.Number),
-    completion_tokens: Schema.optional(Schema.Number),
-    total_tokens: Schema.optional(Schema.Number),
-    prompt_tokens_details: optionalNull(Schema.Struct({
-        cached_tokens: Schema.optional(Schema.Number),
-        cache_write_tokens: Schema.optional(Schema.Number),
-    })),
-    completion_tokens_details: optionalNull(Schema.Struct({
-        reasoning_tokens: Schema.optional(Schema.Number),
-    })),
-});
+const OpenAIChatUsage = Schema.StructWithRest(Schema.Struct({
+    prompt_tokens: optionalNull(Schema.Number),
+    completion_tokens: optionalNull(Schema.Number),
+    total_tokens: optionalNull(Schema.Number),
+    prompt_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
+        cached_tokens: optionalNull(Schema.Number),
+        cache_write_tokens: optionalNull(Schema.Number),
+    }), [Schema.Record(Schema.String, Schema.Unknown)])),
+    completion_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
+        reasoning_tokens: optionalNull(Schema.Number),
+        accepted_prediction_tokens: optionalNull(Schema.Number),
+        rejected_prediction_tokens: optionalNull(Schema.Number),
+    }), [Schema.Record(Schema.String, Schema.Unknown)])),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
 const OpenAIChatToolCallDeltaFunction = Schema.Struct({
     name: optionalNull(Schema.String),
     arguments: optionalNull(Schema.String),
 });
 const OpenAIChatToolCallDelta = Schema.Struct({
-    index: Schema.Number,
+    index: optionalNull(Schema.Number),
     id: optionalNull(Schema.String),
     function: optionalNull(OpenAIChatToolCallDeltaFunction),
 });
@@ -449,21 +456,29 @@ const mapFinishReason = (reason) => {
 const mapUsage = (usage) => {
     if (!usage)
         return undefined;
-    const cached = usage.prompt_tokens_details?.cached_tokens;
-    const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens;
-    const reasoning = usage.completion_tokens_details?.reasoning_tokens;
-    const nonCached = ProviderShared.subtractTokens(usage.prompt_tokens, ProviderShared.sumTokens(cached, cacheWrite));
+    const input = usage.prompt_tokens ?? undefined;
+    const output = usage.completion_tokens ?? undefined;
+    const cached = usage.prompt_tokens_details?.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));
     return new Usage({
-        inputTokens: usage.prompt_tokens,
-        outputTokens: usage.completion_tokens,
+        inputTokens: input,
+        outputTokens: output,
         nonCachedInputTokens: nonCached,
         cacheReadInputTokens: cached,
         cacheWriteInputTokens: cacheWrite,
         reasoningTokens: reasoning,
-        totalTokens: ProviderShared.totalTokens(usage.prompt_tokens, usage.completion_tokens, usage.total_tokens),
+        totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
         providerMetadata: { openai: usage },
     });
 };
+const toolIndexByID = (tools, pendingTools, id) => {
+    if (!id)
+        return undefined;
+    const entry = Object.entries({ ...pendingTools, ...tools }).find(([, tool]) => tool?.id === id);
+    return entry ? Number(entry[0]) : undefined;
+};
 const reasoningDelta = (delta, configuredField) => {
     if (!delta)
         return undefined;
@@ -536,15 +551,27 @@ const step = (state, event) => Effect.gen(function* () {
     const events = [];
     const usage = mapUsage(event.usage) ?? state.usage;
     const choice = event.choices?.[0];
-    const finishReason = choice?.finish_reason
-        ? { normalized: mapFinishReason(choice.finish_reason), raw: choice.native_finish_reason ?? choice.finish_reason }
+    const rawFinishReason = choice?.finish_reason;
+    const finishReason = rawFinishReason !== undefined && rawFinishReason !== null
+        ? { normalized: mapFinishReason(rawFinishReason), raw: choice?.native_finish_reason ?? rawFinishReason }
         : state.finishReason;
     const delta = choice?.delta;
     const toolDeltas = delta?.tool_calls ?? [];
     let tools = state.tools;
     let pendingTools = state.pendingTools;
+    let latestToolIndex = state.latestToolIndex;
+    let nextToolIndex = state.nextToolIndex;
     let lifecycle = state.lifecycle;
     const reasoning = reasoningDelta(delta, state.reasoningField);
+    const hasLateContent = Boolean(delta?.content) ||
+        reasoning !== undefined ||
+        (Array.isArray(delta?.reasoning_details) && delta.reasoning_details.length > 0) ||
+        toolDeltas.some((tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments));
+    if (state.finishReason !== undefined) {
+        if (hasLateContent)
+            return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat received content after the finish reason");
+        return [{ ...state, usage }, events];
+    }
     const reasoningField = state.reasoningField ?? (!state.lifecycle.text.has("text-0") ? reasoning?.field : undefined);
     const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined;
     if (detailDelta !== undefined)
@@ -563,21 +590,33 @@ const step = (state, event) => Effect.gen(function* () {
         lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
         lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content);
     }
-    for (const tool of toolDeltas) {
-        const current = tools[tool.index];
-        const pending = pendingTools[tool.index];
+    // Compatible providers may omit indexes. Prefer durable identity, then use
+    // batch position for parallel deltas or the latest call for sparse chunks.
+    for (const [position, tool] of toolDeltas.entries()) {
+        const matched = toolIndexByID(tools, pendingTools, tool.id || undefined);
+        const fallback = toolDeltas.length > 1 ? position : (latestToolIndex ?? position);
+        const fallbackTool = tools[fallback] ?? pendingTools[fallback];
+        const index = tool.index ?? matched ??
+            (tool.id && fallbackTool?.id && fallbackTool.id !== tool.id ? nextToolIndex : fallback);
+        const current = tools[index];
+        const pending = pendingTools[index];
         const id = current?.id ?? pending?.id ?? (tool.id || undefined);
         const name = current?.name ?? pending?.name ?? (tool.function?.name || undefined);
         const text = `${pending?.input ?? ""}${tool.function?.arguments ?? ""}`;
+        latestToolIndex = index;
+        nextToolIndex = Math.max(nextToolIndex, index + 1);
         if (!current && (!id || !name)) {
-            pendingTools = { ...pendingTools, [tool.index]: { id: id || undefined, name: name || undefined, input: text } };
+            pendingTools = {
+                ...pendingTools,
+                [index]: { id: id || undefined, name: name || undefined, input: text },
+            };
             continue;
         }
         if (pending) {
             pendingTools = { ...pendingTools };
-            delete pendingTools[tool.index];
+            delete pendingTools[index];
         }
-        const result = ToolStream.appendOrStart(ADAPTER, tools, tool.index, { id: id || undefined, name: name || undefined, text }, "OpenAI Chat tool call delta is missing id or name");
+        const result = ToolStream.appendOrStart(ADAPTER, tools, index, { id: id || undefined, name: name || undefined, text }, "OpenAI Chat tool call delta is missing id or name");
         if (ToolStream.isError(result))
             return yield* result;
         tools = result.tools;
@@ -604,6 +643,8 @@ const step = (state, event) => Effect.gen(function* () {
             reasoningDetails: state.reasoningDetails,
             reasoningDetailsObserved,
             reasoningEmitted,
+            latestToolIndex,
+            nextToolIndex,
         },
         events,
     ];
@@ -654,6 +695,7 @@ export const protocol = Protocol.make({
             reasoningDetails: [],
             reasoningDetailsObserved: false,
             reasoningEmitted: false,
+            nextToolIndex: 0,
         }),
         step,
         onHalt: finishEvents,

package/dist/providers/openrouter.d.ts

@@ -285,15 +285,20 @@ export declare const protocol: Protocol<{
         readonly code?: string | number | null | undefined;
     } | null | undefined;
     readonly usage?: {
-        readonly prompt_tokens?: number | undefined;
-        readonly completion_tokens?: number | undefined;
-        readonly total_tokens?: number | undefined;
+        readonly [x: string]: unknown;
+        readonly prompt_tokens?: number | null | undefined;
+        readonly completion_tokens?: number | null | undefined;
+        readonly total_tokens?: number | null | undefined;
         readonly prompt_tokens_details?: {
-            readonly cached_tokens?: number | undefined;
-            readonly cache_write_tokens?: number | undefined;
+            readonly [x: string]: unknown;
+            readonly cached_tokens?: number | null | undefined;
+            readonly cache_write_tokens?: number | null | undefined;
         } | null | undefined;
         readonly completion_tokens_details?: {
-            readonly reasoning_tokens?: number | undefined;
+            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 choices?: readonly {
@@ -304,12 +309,12 @@ export declare const protocol: Protocol<{
             readonly reasoning_text?: string | null | undefined;
             readonly content?: string | null | undefined;
             readonly tool_calls?: readonly {
-                readonly index: number;
                 readonly function?: {
                     readonly name?: string | null | undefined;
                     readonly arguments?: string | null | undefined;
                 } | null | undefined;
                 readonly id?: string | null | undefined;
+                readonly index?: number | null | undefined;
             }[] | null | undefined;
             readonly reasoning_details?: unknown;
         } | null | undefined;

package/package.json

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