@opencode-ai/ai 0.0.0-next-15845 → 0.0.0-next-15848

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

@@ -37,6 +37,7 @@ export declare const bodyFields: {
         readonly reasoning_content: Schema.optional<Schema.String>;
         readonly reasoning: Schema.optional<Schema.String>;
         readonly reasoning_text: Schema.optional<Schema.String>;
+        readonly reasoning_details: Schema.optional<Schema.$Array<Schema.Unknown>>;
     }>, Schema.Struct<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;
@@ -100,6 +101,7 @@ declare const OpenAIChatBody: Schema.Struct<{
         readonly reasoning_content: Schema.optional<Schema.String>;
         readonly reasoning: Schema.optional<Schema.String>;
         readonly reasoning_text: Schema.optional<Schema.String>;
+        readonly reasoning_details: Schema.optional<Schema.$Array<Schema.Unknown>>;
     }>, Schema.Struct<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;
@@ -141,6 +143,7 @@ export declare const OpenAIChatEvent: Schema.Struct<{
             readonly reasoning_content: Schema.optional<Schema.NullOr<Schema.String>>;
             readonly reasoning: Schema.optional<Schema.NullOr<Schema.String>>;
             readonly reasoning_text: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly reasoning_details: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Unknown>>>;
             readonly tool_calls: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
                 readonly index: Schema.Number;
                 readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -178,6 +181,9 @@ export interface ParserState {
     readonly finishReason?: FinishReason;
     readonly lifecycle: Lifecycle.State;
     readonly reasoningField?: "reasoning" | "reasoning_content" | "reasoning_text";
+    readonly reasoningDetails: Array<unknown>;
+    readonly reasoningDetailsObserved: boolean;
+    readonly reasoningEmitted: boolean;
 }
 /**
  * The OpenAI Chat protocol — request body construction, body schema, and the
@@ -214,6 +220,7 @@ export declare const protocol: Protocol<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | Schema.Struct.ReadonlySide<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;
@@ -262,6 +269,7 @@ export declare const protocol: Protocol<{
             }[] | null | undefined;
             readonly reasoning_content?: string | null | undefined;
             readonly reasoning_text?: string | null | undefined;
+            readonly reasoning_details?: readonly unknown[] | null | undefined;
         } | null | undefined;
         readonly finish_reason?: string | null | undefined;
     }[];
@@ -306,6 +314,7 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | Schema.Struct.ReadonlySide<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;
@@ -369,6 +378,7 @@ export declare const route: Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | Schema.Struct.ReadonlySide<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;

package/dist/protocols/openai-chat.js

@@ -57,6 +57,7 @@ const OpenAIChatMessage = Schema.Union([
         reasoning_content: Schema.optional(Schema.String),
         reasoning: Schema.optional(Schema.String),
         reasoning_text: Schema.optional(Schema.String),
+        reasoning_details: optionalArray(Schema.Unknown),
     }),
     Schema.Struct({ role: Schema.Literal("tool"), tool_call_id: Schema.String, content: Schema.String }),
 ]).pipe(Schema.toTaggedUnion("role"));
@@ -116,6 +117,7 @@ const OpenAIChatDelta = Schema.Struct({
     reasoning_content: optionalNull(Schema.String),
     reasoning: optionalNull(Schema.String),
     reasoning_text: optionalNull(Schema.String),
+    reasoning_details: optionalNull(Schema.Array(Schema.Unknown)),
     tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
 });
 const OpenAIChatChoice = Schema.Struct({
@@ -163,7 +165,16 @@ const reasoningField = (part) => {
     const field = part.providerMetadata?.openai?.reasoningField;
     if (field === "reasoning" || field === "reasoning_content" || field === "reasoning_text")
         return field;
-    return "reasoning_content";
+};
+const reasoningDetails = (parts, native) => {
+    const observed = parts.flatMap((part) => {
+        const details = part.providerMetadata?.openai?.reasoningDetails;
+        return Array.isArray(details) ? details : [];
+    });
+    if (parts.some((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails)))
+        return observed;
+    if (isRecord(native) && Array.isArray(native.reasoning_details))
+        return native.reasoning_details;
 };
 const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (message) {
     const content = [];
@@ -203,18 +214,34 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
         }
     }
     const text = reasoning.map((part) => part.text).join("");
-    const field = reasoning[0] ? reasoningField(reasoning[0]) : "reasoning_content";
+    const details = reasoningDetails(reasoning, message.native?.openaiCompatible);
+    const observedField = reasoning.map(reasoningField).find((value) => value !== undefined);
+    const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible);
+    const fullyStructured = reasoning.every((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails));
+    const field = (() => {
+        if (reasoning.length === 0)
+            return;
+        if (observedField !== undefined)
+            return observedField;
+        if (nativeReasoning !== undefined)
+            return "reasoning_content";
+        if (!fullyStructured)
+            return "reasoning_content";
+    })();
+    const reasoningContent = (() => {
+        if (reasoning.length === 0)
+            return nativeReasoning;
+        if (field === "reasoning_content")
+            return text;
+    })();
     return {
         role: "assistant",
         content: content.length === 0 ? null : ProviderShared.joinText(content),
         tool_calls: toolCalls.length === 0 ? undefined : toolCalls,
-        reasoning_content: reasoning.length === 0
-            ? openAICompatibleReasoningContent(message.native?.openaiCompatible)
-            : field === "reasoning_content"
-                ? text
-                : undefined,
+        reasoning_content: reasoningContent,
         reasoning: reasoning.length > 0 && field === "reasoning" ? text : undefined,
         reasoning_text: reasoning.length > 0 && field === "reasoning_text" ? text : undefined,
+        reasoning_details: details,
     };
 });
 const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (message) {
@@ -360,6 +387,51 @@ const reasoningDelta = (delta) => {
     if (delta?.reasoning_text)
         return { field: "reasoning_text", text: delta.reasoning_text };
 };
+const detailText = (details) => {
+    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];
+        return [];
+    });
+    if (text.length > 0)
+        return text.join("");
+};
+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)) {
+            result.push(detail);
+            continue;
+        }
+        result[result.length - 1] = {
+            ...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),
+        };
+    }
+};
+const mergeDetailValue = (previous, current) => previous || current || (previous !== undefined ? previous : current);
+const conflictingReasoningTextDetails = (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);
+const conflictingDetailValue = (previous, current) => previous !== undefined && previous !== null && current !== undefined && current !== null && previous !== current;
+const reasoningMetadata = (field, details) => ({
+    openai: {
+        ...(field ? { reasoningField: field } : {}),
+        ...(details ? { reasoningDetails: details } : {}),
+    },
+});
 const step = (state, event) => Effect.gen(function* () {
     const events = [];
     const usage = mapUsage(event.usage) ?? state.usage;
@@ -371,17 +443,24 @@ const step = (state, event) => Effect.gen(function* () {
     let pendingTools = state.pendingTools;
     let lifecycle = state.lifecycle;
     const reasoning = reasoningDelta(delta);
-    const reasoningField = state.reasoningField ?? reasoning?.field;
-    if (reasoning)
-        lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", reasoning.text, {
-            openai: { reasoningField: reasoningField ?? reasoning.field },
-        });
+    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)
+        appendReasoningDetails(state.reasoningDetails, detailDelta);
+    const reasoningDetailsObserved = state.reasoningDetailsObserved || detailDelta !== undefined;
+    const deltaMetadata = reasoningMetadata(reasoningField);
+    const text = detailDelta?.length ? (detailText(detailDelta) ?? reasoning?.text) : reasoning?.text;
+    if (!state.lifecycle.text.has("text-0") && text !== undefined)
+        lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata);
+    else if (reasoningDetailsObserved &&
+        !lifecycle.reasoning.has("reasoning-0") &&
+        (Boolean(delta?.content) || toolDeltas.length > 0))
+        lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata);
+    const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0");
     if (delta?.content) {
-        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0");
+        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
         lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content);
     }
-    if (toolDeltas.length)
-        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0");
     for (const tool of toolDeltas) {
         const current = tools[tool.index];
         const pending = pendingTools[tool.index];
@@ -420,6 +499,9 @@ const step = (state, event) => Effect.gen(function* () {
             finishReason,
             lifecycle,
             reasoningField,
+            reasoningDetails: state.reasoningDetails,
+            reasoningDetailsObserved,
+            reasoningEmitted,
         },
         events,
     ];
@@ -428,7 +510,12 @@ const finishEvents = (state) => {
     const events = [];
     const hasToolCalls = state.toolCallEvents.length > 0;
     const reason = state.finishReason === "stop" && hasToolCalls ? "tool-calls" : state.finishReason;
-    const lifecycle = state.toolCallEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle;
+    const metadata = reasoningMetadata(state.reasoningField, state.reasoningDetailsObserved ? state.reasoningDetails : undefined);
+    const started = state.reasoningDetailsObserved && !state.reasoningEmitted
+        ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.reasoningField))
+        : state.lifecycle;
+    const ended = Lifecycle.reasoningEnd(started, events, "reasoning-0", metadata);
+    const lifecycle = state.toolCallEvents.length ? Lifecycle.stepStart(ended, events) : ended;
     events.push(...state.toolCallEvents);
     if (reason)
         Lifecycle.finish(lifecycle, events, { reason, usage: state.usage });
@@ -457,6 +544,9 @@ export const protocol = Protocol.make({
             toolCallEvents: [],
             lifecycle: Lifecycle.initial(),
             reasoningField: undefined,
+            reasoningDetails: [],
+            reasoningDetailsObserved: false,
+            reasoningEmitted: false,
         }),
         step,
         onHalt: finishEvents,

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

@@ -36,6 +36,7 @@ export declare const route: Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;

package/dist/protocols/utils/lifecycle.js

@@ -24,7 +24,7 @@ export const reasoningStart = (state, events, id, providerMetadata) => {
 };
 export const reasoningDelta = (state, events, id, text, providerMetadata) => {
     const started = reasoningStart(state, events, id, providerMetadata);
-    events.push(LLMEvent.reasoningDelta({ id, text }));
+    events.push(LLMEvent.reasoningDelta({ id, text, providerMetadata }));
     return started;
 };
 export const reasoningEnd = (state, events, id, providerMetadata) => {

package/dist/provider-error.js

@@ -2,13 +2,17 @@ import { Option, Schema } from "effect";
 import { AuthenticationReason, ContentPolicyReason, InvalidRequestReason, LLMError, ProviderErrorEvent, ProviderInternalReason, QuotaExceededReason, RateLimitReason, UnknownProviderReason, } from "./schema";
 const patterns = [
     /prompt is too long/i,
+    /request_too_large/i,
     /input is too long for requested model/i,
     /exceeds the context window/i,
+    /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
     /input token count.*exceeds the maximum/i,
     /tokens in request more than max tokens allowed/i,
     /maximum prompt length is \d+/i,
     /reduce the length of the messages/i,
     /maximum context length is \d+ tokens/i,
+    /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+    /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
     /exceeds the limit of \d+/i,
     /exceeds the available context size/i,
     /greater than the context length/i,
@@ -20,9 +24,14 @@ const patterns = [
     /input length.*exceeds.*context length/i,
     /prompt too long; exceeded (?:max )?context length/i,
     /too large for model with \d+ maximum context length/i,
+    /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
     /model_context_window_exceeded/i,
+    /too many tokens/i,
+    /token limit exceeded/i,
 ];
-export const isContextOverflow = (message) => patterns.some((pattern) => pattern.test(message)) || /^4(00|13)\s*(status code)?\s*\(no body\)/i.test(message);
+const exclusions = [/^(throttling error|service unavailable):/i, /rate limit/i, /too many requests/i];
+export const isContextOverflow = (message) => !exclusions.some((pattern) => pattern.test(message)) &&
+    (patterns.some((pattern) => pattern.test(message)) || /^4(00|13)\s*(status code)?\s*\(no body\)/i.test(message));
 export const isContextOverflowFailure = (failure) => failure instanceof LLMError
     ? failure.reason._tag === "InvalidRequest" && failure.reason.classification === "context-overflow"
     : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow";

package/dist/providers/azure.d.ts

@@ -50,6 +50,7 @@ export declare const routes: (RouteDef<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;

package/dist/providers/cloudflare.d.ts

@@ -53,6 +53,7 @@ export declare const aiGatewayRoute: import("../route").Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;
@@ -116,6 +117,7 @@ export declare const workersAIRoute: import("../route").Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;
@@ -179,6 +181,7 @@ export declare const routes: import("../route").Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;

package/dist/providers/github-copilot.d.ts

@@ -38,6 +38,7 @@ export declare const routes: (import("../route").Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;

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

@@ -45,6 +45,7 @@ export declare const routes: import("../route").Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;

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

@@ -44,6 +44,7 @@ export declare const routes: import("../route").Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;

package/dist/providers/openai.d.ts

@@ -36,6 +36,7 @@ export declare const routes: (Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;

package/dist/providers/openrouter.d.ts

@@ -52,6 +52,7 @@ declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
         readonly reasoning_content: Schema.optional<Schema.String>;
         readonly reasoning: Schema.optional<Schema.String>;
         readonly reasoning_text: Schema.optional<Schema.String>;
+        readonly reasoning_details: Schema.optional<Schema.$Array<Schema.Unknown>>;
     }>, Schema.Struct<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;
@@ -116,6 +117,7 @@ export declare const protocol: Protocol<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | Schema.Struct.ReadonlySide<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;
@@ -164,6 +166,7 @@ export declare const protocol: Protocol<{
             }[] | null | undefined;
             readonly reasoning_content?: string | null | undefined;
             readonly reasoning_text?: string | null | undefined;
+            readonly reasoning_details?: readonly unknown[] | null | undefined;
         } | null | undefined;
         readonly finish_reason?: string | null | undefined;
     }[];
@@ -209,6 +212,7 @@ export declare const route: Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | Schema.Struct.ReadonlySide<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;
@@ -273,6 +277,7 @@ export declare const routes: Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | Schema.Struct.ReadonlySide<{
         readonly role: Schema.Literal<"tool">;
         readonly tool_call_id: Schema.String;

package/dist/providers/openrouter.js

@@ -18,10 +18,32 @@ export const protocol = Protocol.make({
     id: "openrouter-chat",
     body: {
         schema: OpenRouterBody,
-        from: (request) => OpenAIChat.protocol.body.from(request).pipe(Effect.map((body) => ({
-            ...body,
-            ...bodyOptions(request.providerOptions?.openrouter),
-        }))),
+        from: (request) => OpenAIChat.protocol.body.from(request).pipe(Effect.map((body) => {
+            const sourceAssistants = request.messages.filter((message) => message.role === "assistant");
+            let assistantIndex = 0;
+            const messages = body.messages.map((message) => {
+                if (message.role !== "assistant")
+                    return message;
+                const source = sourceAssistants[assistantIndex++];
+                const reasoning = source?.content
+                    .filter((part) => part.type === "reasoning")
+                    .map((part) => part.text)
+                    .join("");
+                const reasoningDetails = Array.isArray(message.reasoning_details) ? message.reasoning_details : undefined;
+                return {
+                    ...message,
+                    reasoning_content: undefined,
+                    reasoning_text: undefined,
+                    reasoning: reasoning && reasoningDetails && reasoningDetails.length > 0 ? reasoning : undefined,
+                    reasoning_details: reasoningDetails,
+                };
+            });
+            return {
+                ...body,
+                messages,
+                ...bodyOptions(request.providerOptions?.openrouter),
+            };
+        })),
     },
     stream: OpenAIChat.protocol.stream,
 });

package/dist/providers/xai.d.ts

@@ -34,6 +34,7 @@ export declare const routes: (import("../route").Route<{
         }, "Type">[] | undefined;
         readonly reasoning_content?: string | undefined;
         readonly reasoning_text?: string | undefined;
+        readonly reasoning_details?: readonly unknown[] | undefined;
     } | import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"tool">;
         readonly tool_call_id: import("effect/Schema").String;

package/package.json

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