@opencode/ai 0.0.0-dev-20017 → 0.0.0-dev-20020

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

@@ -12,6 +12,37 @@ declare const OpenAIChatCacheControl: Schema.Struct<{
     readonly type: Schema.Literal<"ephemeral">;
     readonly ttl: Schema.optional<Schema.String>;
 }>;
+declare const ReasoningDetail: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly format: Schema.optional<Schema.String>;
+    readonly index: Schema.optional<Schema.Number>;
+    readonly signature: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly type: Schema.Literal<"reasoning.text">;
+    readonly text: Schema.optional<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly format: Schema.optional<Schema.String>;
+    readonly index: Schema.optional<Schema.Number>;
+    readonly signature: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly type: Schema.Literal<"reasoning.summary">;
+    readonly summary: Schema.optional<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly format: Schema.optional<Schema.String>;
+    readonly index: Schema.optional<Schema.Number>;
+    readonly signature: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly type: Schema.Literal<"reasoning.encrypted">;
+    readonly data: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.Struct<{
+    readonly type: Schema.Literal<"summary">;
+    readonly summary: Schema.String;
+    readonly index: Schema.optional<Schema.Number>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"encrypted">;
+    readonly encrypted: Schema.String;
+    readonly index: Schema.optional<Schema.Number>;
+}>]>;
+type ReasoningDetail = Schema.Schema.Type<typeof ReasoningDetail>;
 export declare const bodyFields: {
     model: Schema.String;
     messages: Schema.$Array<Schema.toTaggedUnion<"role", readonly [Schema.Struct<{
@@ -278,7 +309,9 @@ export interface ParserState {
     readonly finishReason?: FinishReasonDetails;
     readonly lifecycle: Lifecycle.State;
     readonly reasoningField?: string;
-    readonly reasoningDetails: Array<unknown>;
+    /** A scalar reasoning field (`reasoning_content`, ...) has carried text in this stream. */
+    readonly reasoningTextObserved: boolean;
+    readonly reasoningDetails: Array<ReasoningDetail>;
     readonly reasoningDetailsObserved: boolean;
     readonly reasoningEmitted: boolean;
     readonly latestToolIndex?: number;

package/dist/protocols/openai-chat.js

@@ -1,4 +1,4 @@
-import { Effect, Schema } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { Tool } from "@opencode/schema/tool";
 import { Route } from "../route/client.js";
 import { Auth } from "../route/auth.js";
@@ -50,6 +50,32 @@ const OpenAIChatAssistantToolCall = Schema.Struct({
         arguments: Schema.String,
     }),
 });
+// `reasoning_details` carries two dialects. OpenRouter's `reasoning.*` entries
+// must be replayed unmodified (`index` included), so they keep every field they
+// arrived with. Kimi's OpenAI-compatible surface streams preserved thinking as
+// bare `summary` / `encrypted` entries keyed by a stream-only `index`; Kimi does
+// not document this publicly, so the handling follows Kimi Code (Kimi's own
+// client): merge summary deltas by `index`, replay without `index`, and always
+// send `reasoning_content` alongside. Anything else is dropped at the boundary.
+const OpenRouterDetailFields = {
+    id: Schema.optional(Schema.NullOr(Schema.String)),
+    format: Schema.optional(Schema.String),
+    index: Schema.optional(Schema.Number),
+    signature: Schema.optional(Schema.NullOr(Schema.String)),
+};
+const ReasoningDetail = Schema.Union([
+    Schema.StructWithRest(Schema.Struct({ type: Schema.Literal("reasoning.text"), text: Schema.optional(Schema.String), ...OpenRouterDetailFields }), [Schema.Record(Schema.String, Schema.Unknown)]),
+    Schema.StructWithRest(Schema.Struct({
+        type: Schema.Literal("reasoning.summary"),
+        summary: Schema.optional(Schema.String),
+        ...OpenRouterDetailFields,
+    }), [Schema.Record(Schema.String, Schema.Unknown)]),
+    Schema.StructWithRest(Schema.Struct({ type: Schema.Literal("reasoning.encrypted"), data: Schema.String, ...OpenRouterDetailFields }), [Schema.Record(Schema.String, Schema.Unknown)]),
+    Schema.Struct({ type: Schema.Literal("summary"), summary: Schema.String, index: Schema.optional(Schema.Number) }),
+    Schema.Struct({ type: Schema.Literal("encrypted"), encrypted: Schema.String, index: Schema.optional(Schema.Number) }),
+]);
+const decodeReasoningDetail = Schema.decodeUnknownOption(ReasoningDetail);
+const knownReasoningDetails = (details) => details.flatMap((detail) => Option.toArray(decodeReasoningDetail(detail)));
 // 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
@@ -220,10 +246,20 @@ const reasoningDetails = (parts, native, providerMetadataKey) => {
         return Array.isArray(details) ? details : [];
     });
     if (parts.some((part) => Array.isArray(part.providerMetadata?.[providerMetadataKey]?.reasoningDetails)))
-        return observed;
+        return knownReasoningDetails(observed).map(lowerReasoningDetail);
     if (isRecord(native) && Array.isArray(native.reasoning_details))
-        return native.reasoning_details;
+        return knownReasoningDetails(native.reasoning_details).map(lowerReasoningDetail);
+};
+// Kimi rejects its stream-only `index` on requests
+// ("the reasoning_details ... must not contain streaming index").
+const lowerReasoningDetail = (detail) => {
+    if (detail.type === "summary")
+        return { type: detail.type, summary: detail.summary };
+    if (detail.type === "encrypted")
+        return { type: detail.type, encrypted: detail.encrypted };
+    return detail;
 };
+const isKimiDetail = (detail) => detail.type === "summary" || detail.type === "encrypted";
 const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (message, options) {
     const content = [];
     for (const part of message.content) {
@@ -282,6 +318,10 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
             return "reasoning_content";
         if (!fullyStructured || requireReasoning)
             return "reasoning_content";
+        // Kimi always expects `reasoning_content` on replayed assistant messages,
+        // even when thinking arrived only through structured details.
+        if (details?.some(isKimiDetail))
+            return "reasoning_content";
     })();
     const reasoningText = (() => {
         if (configuredField !== undefined)
@@ -705,14 +745,16 @@ const reasoningDelta = (delta, configuredField) => {
     }
     return undefined;
 };
-const detailText = (details) => {
+const detailText = (details, hideKimiSummary) => {
     const text = details.flatMap((detail) => {
-        if (!isRecord(detail))
-            return [];
-        if (detail.type === "reasoning.text" && typeof detail.text === "string" && detail.text)
-            return [detail.text];
-        if (detail.type === "reasoning.summary" && typeof detail.summary === "string" && detail.summary)
-            return [detail.summary];
+        if (detail.type === "reasoning.text")
+            return detail.text ? [detail.text] : [];
+        if (detail.type === "reasoning.summary")
+            return detail.summary ? [detail.summary] : [];
+        // Kimi streams the full thinking through `reasoning_content` and a separate
+        // summary through details; show the summary only when nothing else does.
+        if (detail.type === "summary")
+            return detail.summary && !hideKimiSummary ? [detail.summary] : [];
         return [];
     });
     if (text.length > 0)
@@ -721,25 +763,48 @@ const detailText = (details) => {
 const appendReasoningDetails = (result, details) => {
     for (const detail of details) {
         const previous = result.at(-1);
-        if (!isRecord(previous) ||
-            previous.type !== "reasoning.text" ||
-            !isRecord(detail) ||
-            detail.type !== "reasoning.text" ||
-            conflictingReasoningTextDetails(previous, detail)) {
+        const merged = previous === undefined ? undefined : mergeReasoningDetails(previous, detail);
+        if (merged === undefined) {
             result.push(detail);
             continue;
         }
-        result[result.length - 1] = {
+        result[result.length - 1] = merged;
+    }
+};
+// Consecutive text or summary deltas of the same kind accumulate into one
+// entry; encrypted entries are opaque and never merge.
+const mergeReasoningDetails = (previous, detail) => {
+    if (conflictingReasoningDetails(previous, detail))
+        return undefined;
+    if (previous.type === "reasoning.text" && detail.type === "reasoning.text")
+        return {
             ...previous,
-            ...Object.fromEntries(Object.entries(detail).filter((entry) => entry[1] !== undefined)),
-            text: `${typeof previous.text === "string" ? previous.text : ""}${typeof detail.text === "string" ? detail.text : ""}`,
-            signature: mergeDetailValue(previous.signature, detail.signature),
-            format: mergeDetailValue(previous.format, detail.format),
+            ...detail,
+            text: `${previous.text ?? ""}${detail.text ?? ""}`,
+            ...mergeDetailIdentity(previous, detail),
         };
-    }
+    if (previous.type === "reasoning.summary" && detail.type === "reasoning.summary")
+        return {
+            ...previous,
+            ...detail,
+            summary: `${previous.summary ?? ""}${detail.summary ?? ""}`,
+            ...mergeDetailIdentity(previous, detail),
+        };
+    if (previous.type === "summary" && detail.type === "summary")
+        return { ...previous, ...detail, summary: previous.summary + detail.summary };
+};
+// The first non-empty signature and format win; a later delta may carry the
+// signature for text that streamed earlier.
+const mergeDetailIdentity = (previous, current) => {
+    const signature = mergeDetailValue(previous.signature, current.signature);
+    const format = mergeDetailValue(previous.format, current.format);
+    return {
+        ...(signature === undefined ? {} : { signature }),
+        ...(format === undefined ? {} : { format }),
+    };
 };
 const mergeDetailValue = (previous, current) => previous || current || (previous !== undefined ? previous : current);
-const conflictingReasoningTextDetails = (previous, current) => conflictingDetailValue(previous.id, current.id) ||
+const conflictingReasoningDetails = (previous, current) => conflictingDetailValue(previous.id, current.id) ||
     conflictingDetailValue(previous.index, current.index) ||
     conflictingDetailValue(previous.format, current.format) ||
     (Boolean(previous.signature) && Boolean(current.signature) && previous.signature !== current.signature);
@@ -795,12 +860,17 @@ const step = (state, event) => Effect.gen(function* () {
         return [{ ...state, usage }, events];
     }
     const reasoningField = state.reasoningField ?? reasoning?.field;
-    const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined;
+    const reasoningTextObserved = state.reasoningTextObserved || reasoning !== undefined;
+    const detailDelta = Array.isArray(delta?.reasoning_details)
+        ? knownReasoningDetails(delta.reasoning_details)
+        : undefined;
     if (detailDelta !== undefined)
         appendReasoningDetails(state.reasoningDetails, detailDelta);
     const reasoningDetailsObserved = state.reasoningDetailsObserved || detailDelta !== undefined;
     const deltaMetadata = reasoningMetadata(state.providerMetadataKey, reasoningField);
-    const text = detailDelta?.length ? (detailText(detailDelta) ?? reasoning?.text) : reasoning?.text;
+    const text = detailDelta?.length
+        ? (detailText(detailDelta, reasoningTextObserved) ?? reasoning?.text)
+        : reasoning?.text;
     if (text !== undefined)
         lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata);
     else if (reasoningDetailsObserved &&
@@ -878,6 +948,7 @@ const step = (state, event) => Effect.gen(function* () {
             finishReason,
             lifecycle,
             reasoningField,
+            reasoningTextObserved,
             reasoningDetails: state.reasoningDetails,
             reasoningDetailsObserved,
             reasoningEmitted,
@@ -944,6 +1015,7 @@ export const protocol = Protocol.make({
             toolCallEvents: [],
             lifecycle: Lifecycle.initial(),
             reasoningField: request.model.compatibility?.reasoningField,
+            reasoningTextObserved: false,
             reasoningDetails: [],
             reasoningDetailsObserved: false,
             reasoningEmitted: false,

package/package.json

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