@opencode/ai 2.0.14 → 2.0.16

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<{
@@ -28,6 +59,12 @@ export declare const bodyFields: {
             readonly image_url: Schema.Struct<{
                 readonly url: Schema.String;
             }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly file: Schema.Struct<{
+                readonly filename: Schema.String;
+                readonly file_data: Schema.String;
+            }>;
         }>]>>]>;
     }>, Schema.Struct<{
         readonly role: Schema.Literal<"user">;
@@ -43,6 +80,12 @@ export declare const bodyFields: {
             readonly image_url: Schema.Struct<{
                 readonly url: Schema.String;
             }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly file: Schema.Struct<{
+                readonly filename: Schema.String;
+                readonly file_data: Schema.String;
+            }>;
         }>]>>]>;
     }>, Schema.StructWithRest<Schema.Struct<{
         readonly role: Schema.Literal<"assistant">;
@@ -124,6 +167,12 @@ declare const OpenAIChatBody: Schema.Struct<{
             readonly image_url: Schema.Struct<{
                 readonly url: Schema.String;
             }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly file: Schema.Struct<{
+                readonly filename: Schema.String;
+                readonly file_data: Schema.String;
+            }>;
         }>]>>]>;
     }>, Schema.Struct<{
         readonly role: Schema.Literal<"user">;
@@ -139,6 +188,12 @@ declare const OpenAIChatBody: Schema.Struct<{
             readonly image_url: Schema.Struct<{
                 readonly url: Schema.String;
             }>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly file: Schema.Struct<{
+                readonly filename: Schema.String;
+                readonly file_data: Schema.String;
+            }>;
         }>]>>]>;
     }>, Schema.StructWithRest<Schema.Struct<{
         readonly role: Schema.Literal<"assistant">;
@@ -278,7 +333,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;
@@ -321,6 +378,12 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -336,6 +399,12 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;
@@ -418,6 +487,12 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -433,6 +508,12 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;
@@ -508,6 +589,12 @@ export declare const protocol: Protocol<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -523,6 +610,12 @@ export declare const protocol: Protocol<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;
@@ -675,6 +768,12 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -690,6 +789,12 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;
@@ -774,6 +879,12 @@ export declare const route: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -789,6 +900,12 @@ export declare const route: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;

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
@@ -65,6 +91,10 @@ const OpenAIChatUserContent = Schema.Union([
         type: Schema.Literal("image_url"),
         image_url: Schema.Struct({ url: Schema.String }),
     }),
+    Schema.Struct({
+        type: Schema.Literal("file"),
+        file: Schema.Struct({ filename: Schema.String, file_data: Schema.String }),
+    }),
 ]);
 const OpenAIChatMessage = Schema.Union([
     Schema.Struct({
@@ -204,12 +234,18 @@ const lowerToolCall = (part, options) => ({
     },
 });
 const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part) {
-    const media = ProviderShared.normalizeMedia(part);
-    if (!media.mime.startsWith("image/"))
-        return yield* ProviderShared.invalidRequest(`OpenAI Chat does not support media type ${part.mediaType}`);
-    const url = typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
-        ? part.data
-        : media.dataUrl;
+    // Chat Completions accepts PDFs, and no other documents, as inline `file` parts; file URLs are not supported.
+    if (part.media.mediaType.toLowerCase() === "application/pdf")
+        return {
+            type: "file",
+            file: {
+                filename: part.filename ?? "document.pdf",
+                file_data: (yield* ProviderShared.requireInlineMedia("OpenAI Chat", part.media)).dataUrl,
+            },
+        };
+    if (part.media.kind !== "image")
+        return yield* ProviderShared.invalidRequest(`OpenAI Chat does not support media type ${part.media.mediaType}`);
+    const url = ProviderShared.mediaUrl(part.media) ?? (yield* ProviderShared.requireInlineMedia("OpenAI Chat", part.media)).dataUrl;
     return { type: "image_url", image_url: { url } };
 });
 const openAICompatibleReasoningContent = (native) => isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined;
@@ -223,10 +259,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) {
@@ -285,6 +331,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)
@@ -308,7 +358,7 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
 });
 const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (message, options) {
     const messages = [];
-    const images = [];
+    const attachments = [];
     for (const part of message.content) {
         if (!ProviderShared.supportsContent(part, ["tool-result"]))
             return yield* ProviderShared.unsupportedContent("OpenAI Chat", "tool", ["tool-result"]);
@@ -330,9 +380,9 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (m
             cache_control: options.cacheControl?.(part.cache),
         });
         const files = content.filter((item) => item.type === "file");
-        images.push(...(yield* Effect.forEach(files, (item) => lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name }))));
+        attachments.push(...(yield* Effect.forEach(files, (item) => lowerMedia(ProviderShared.toolFileMedia(item)))));
     }
-    return { messages, images };
+    return { messages, attachments };
 });
 const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (message, reasoningField, requireReasoning, options) {
     if (message.role === "user")
@@ -386,23 +436,23 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
         if (requireAssistantAfterTool && messages.at(-1)?.role === "tool")
             messages.push({ role: "assistant", content: "Done." });
     };
-    const pendingImages = [];
-    const flushImages = () => {
-        if (pendingImages.length === 0)
+    const pendingAttachments = [];
+    const flushAttachments = () => {
+        if (pendingAttachments.length === 0)
             return;
         bridgeTools();
-        messages.push({ role: "user", content: pendingImages.splice(0) });
+        messages.push({ role: "user", content: pendingAttachments.splice(0) });
     };
     for (const message of request.messages) {
         if (message.role === "user")
             bridgeTools();
         if (message.role === "system") {
             const part = yield* ProviderShared.wrappedSystemUpdate("OpenAI Chat", message);
-            if (pendingImages.length > 0) {
+            if (pendingAttachments.length > 0) {
                 messages.push({
                     role: "user",
                     content: [
-                        ...pendingImages.splice(0),
+                        ...pendingAttachments.splice(0),
                         { type: "text", text: part.text, cache_control: options.cacheControl?.(part.cache) },
                     ],
                 });
@@ -442,13 +492,13 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
         if (message.role === "tool") {
             const lowered = yield* lowerToolMessages(message, lowering);
             messages.push(...lowered.messages);
-            pendingImages.push(...lowered.images);
+            pendingAttachments.push(...lowered.attachments);
             continue;
         }
-        flushImages();
+        flushAttachments();
         messages.push(...(yield* lowerMessage(message, reasoningField, requireReasoning, lowering)));
     }
-    flushImages();
+    flushAttachments();
     return messages;
 });
 // Anthropic via LiteLLM and Amazon Bedrock require `tools` to be present
@@ -581,7 +631,6 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
     if (reasoningField && RESERVED_REASONING_FIELDS.has(reasoningField))
         return yield* ProviderShared.invalidRequest(`OpenAI Chat reasoning field conflicts with reserved field ${reasoningField}`);
     const generation = request.generation;
-    const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     const flattened = ProviderShared.flattenToolRequest(request);
     const provider = String(request.model.provider);
     const baseURL = request.model.route.endpoint.baseURL;
@@ -600,7 +649,7 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
             ? hasHistory
                 ? []
                 : undefined
-            : flattened.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility), options, supportsStrictMode)),
+            : flattened.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model), options, supportsStrictMode)),
         tool_choice: hasActiveTools && request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
         stream: true,
         ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),
@@ -708,14 +757,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)
@@ -724,25 +775,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);
@@ -798,12 +872,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 &&
@@ -881,6 +960,7 @@ const step = (state, event) => Effect.gen(function* () {
             finishReason,
             lifecycle,
             reasoningField,
+            reasoningTextObserved,
             reasoningDetails: state.reasoningDetails,
             reasoningDetailsObserved,
             reasoningEmitted,
@@ -947,6 +1027,7 @@ export const protocol = Protocol.make({
             toolCallEvents: [],
             lifecycle: Lifecycle.initial(),
             reasoningField: request.model.compatibility?.reasoningField,
+            reasoningTextObserved: false,
             reasoningDetails: [],
             reasoningDetailsObserved: false,
             reasoningEmitted: false,

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

@@ -23,6 +23,12 @@ export declare const route: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -38,6 +44,12 @@ export declare const route: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;

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

@@ -72,8 +72,8 @@ export declare const route: Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -109,8 +109,8 @@ export declare const route: Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";