@opencode/ai 2.0.14 → 2.0.15

package/dist/protocols/meta-images.js

@@ -1,15 +1,23 @@
-import { Effect, Encoding, Schema } from "effect";
-import { Headers, HttpClientRequest } from "effect/unstable/http";
-import { GeneratedImage, ImageModel, ImageResponse } from "../image.js";
-import { Auth } from "../route/auth.js";
-import { Usage, mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
+import { Effect, Schema } from "effect";
+import { ImageModel, ImageResponse } from "../image.js";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
 import { JsonObject, ProviderShared, optionalNull } from "./shared.js";
-import { ImageInputs } from "./utils/image-input.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "meta-images";
+const NAME = "Meta Images";
+const PROVIDER = ProviderID.make("meta");
+// ---------------------------------------------------------------------------
+// 2. Request body and response schemas
+// ---------------------------------------------------------------------------
 const Body = Schema.StructWithRest(Schema.Struct({
     model: Schema.String,
     prompt: Schema.String,
     images: Schema.optional(Schema.Array(JsonObject)),
     n: Schema.optional(Schema.Number),
+    /** Aspect ratio hint, not an exact output resolution. */
     size: Schema.optional(Schema.String),
     output_format: Schema.optional(Schema.String),
     response_format: Schema.optional(Schema.String),
@@ -25,65 +33,83 @@ const Response = Schema.Struct({
         total_tokens: Schema.optional(Schema.Number),
     })),
 });
-export const model = (input) => {
-    const route = {
-        id: "meta-images",
-        generate: Effect.fn("MetaImages.generate")(function* (request, execute) {
-            const http = mergeHttpOptions(request.model.http, request.http);
-            const images = yield* Effect.forEach(request.images ?? [], (image) => {
-                if (image.type === "bytes")
-                    return Effect.succeed({ image_url: ImageInputs.dataUrl(image) });
-                if (image.type === "url")
-                    return Effect.succeed({ image_url: image.url });
-                return ImageInputs.invalid("Meta Images accepts image bytes and URLs");
-            });
-            const { outputFormat, responseFormat, reasoningStrength, toolEnablement, ...native } = request.options ?? {};
-            const payload = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(mergeJsonRecords({
-                model: request.model.id,
-                prompt: request.prompt,
-                images: images.length === 0 ? undefined : images,
-                output_format: outputFormat,
-                response_format: responseFormat,
-                reasoning_strength: reasoningStrength,
-                tool_enablement: toolEnablement,
-            }, native, http?.body));
-            const body = ProviderShared.encodeJson(payload);
-            const url = new URL(`${input.baseURL.replace(/\/$/, "")}/images/${images.length === 0 ? "generations" : "edits"}`);
-            Object.entries(http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value));
-            const headers = yield* Auth.toEffect(input.auth)({
-                request,
-                method: "POST",
-                url: url.toString(),
-                body,
-                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-            });
-            const response = yield* execute(HttpClientRequest.post(url.toString()).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(body, "application/json")));
-            const output = yield* ProviderShared.imageResponse("meta-images", "Meta Images", response);
-            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(output.body).pipe(Effect.mapError((cause) => output.invalid("Meta Images returned an invalid response", cause)));
-            const format = decoded.output_format ?? payload.output_format ?? "webp";
-            const generated = yield* Effect.forEach(decoded.data, (item, index) => {
-                if (item.b64_json)
-                    return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError((cause) => output.invalid(`Meta Images result ${index} contains invalid base64`, cause)), Effect.map((data) => new GeneratedImage({ mediaType: `image/${format}`, data })));
-                if (item.url)
-                    return Effect.succeed(new GeneratedImage({ mediaType: `image/${format}`, data: item.url }));
-                return output.invalid(`Meta Images result ${index} has neither image data nor a URL`);
-            });
-            if (generated.length === 0)
-                return yield* output.invalid("Meta Images returned no images");
-            return new ImageResponse({
-                images: generated,
-                usage: decoded.usage === undefined
-                    ? undefined
-                    : new Usage({
-                        inputTokens: decoded.usage.input_tokens,
-                        outputTokens: decoded.usage.output_tokens,
-                        totalTokens: decoded.usage.total_tokens,
-                        providerMetadata: { meta: decoded.usage },
-                    }),
-                providerMetadata: { meta: { outputFormat: format } },
-            });
-        }),
-    };
-    return ImageModel.make({ id: input.id, provider: "meta", route, http: input.http });
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const isEdit = (request) => (request.images?.length ?? 0) > 0;
+const reference = (asset) => {
+    const inline = asset.inline();
+    if (inline)
+        return Effect.succeed({ image_url: inline.dataUrl });
+    const url = ProviderShared.mediaUrl(asset);
+    if (url)
+        return Effect.succeed({ image_url: url });
+    return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts image bytes and URLs`));
 };
+const fromRequest = Effect.fn("MetaImages.fromRequest")(function* (request) {
+    const images = yield* Effect.forEach(request.images ?? [], reference);
+    const { responseFormat, reasoningStrength, toolEnablement, ...native } = request.providerOptions ?? {};
+    const payload = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(mergeJsonRecords({
+        model: request.model.id,
+        prompt: request.prompt,
+        images: images.length === 0 ? undefined : images,
+        n: request.n,
+        size: request.size,
+        output_format: request.format,
+        response_format: responseFormat,
+        reasoning_strength: reasoningStrength,
+        tool_enablement: toolEnablement,
+    }, native, request.http?.body));
+    return MediaProtocol.json(payload);
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeResponse = Effect.fn("MetaImages.decodeResponse")(function* (response, context) {
+    const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, Response)(response);
+    const decoded = output.value;
+    const requested = context.body.type === "json" ? context.body.value.output_format : undefined;
+    const format = decoded.output_format ?? (typeof requested === "string" ? requested : "webp");
+    const mediaType = `image/${format}`;
+    const images = yield* Effect.forEach(decoded.data, (item, index) => {
+        if (item.b64_json)
+            return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
+                info: { format },
+            });
+        if (item.url)
+            return Effect.succeed(Media.url(item.url, { mediaType, info: { format } }));
+        return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`));
+    });
+    if (images.length === 0)
+        return yield* output.invalid(`${NAME} returned no images`);
+    return new ImageResponse({
+        images,
+        usage: decoded.usage === undefined
+            ? undefined
+            : {
+                type: "tokens",
+                input: decoded.usage.input_tokens,
+                output: decoded.usage.output_tokens,
+                total: decoded.usage.total_tokens,
+                details: { meta: decoded.usage },
+            },
+        providerMetadata: { meta: { outputFormat: format } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["mask", "aspectRatio", "seed"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+export const model = (input) => ImageModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    path: ({ request }) => `/images/${isEdit(request) ? "edits" : "generations"}`,
+}, input);
 export * as MetaImages from "./meta-images.js";

package/dist/protocols/mistral-chat.js

@@ -141,13 +141,14 @@ const MistralEvent = Schema.StructWithRest(Schema.Struct({
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const MistralStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(MistralEvent)]);
 const lowerMedia = Effect.fn("MistralChat.lowerMedia")(function* (part) {
-    const media = ProviderShared.normalizeMedia(part);
-    const url = typeof part.data === "string" && /^(?:https?:|data:)/.test(part.data) ? part.data : media.dataUrl;
-    if (media.mime.startsWith("image/"))
+    const mime = part.media.mediaType.toLowerCase();
+    const url = ProviderShared.mediaUrl(part.media) ??
+        (yield* ProviderShared.requireInlineMedia("Mistral Chat", part.media)).dataUrl;
+    if (mime.startsWith("image/"))
         return { type: "image_url", image_url: url };
-    if (media.mime === "application/pdf")
+    if (mime === "application/pdf")
         return { type: "document_url", document_url: url };
-    return yield* ProviderShared.invalidRequest(`Mistral Chat does not support media type ${part.mediaType}`);
+    return yield* ProviderShared.invalidRequest(`Mistral Chat does not support media type ${part.media.mediaType}`);
 });
 const lowerUser = Effect.fn("MistralChat.lowerUser")(function* (message) {
     const content = [];
@@ -227,7 +228,7 @@ const lowerToolResults = Effect.fn("MistralChat.lowerToolResults")(function* (me
                 content.push({ type: "text", text: item.text });
                 continue;
             }
-            content.push(yield* lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name }));
+            content.push(yield* lowerMedia(ProviderShared.toolFileMedia(item)));
         }
         output.push({
             role: "tool",

package/dist/protocols/open-responses.d.ts

@@ -2,7 +2,7 @@ import { Effect, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
 import { AIError, LLMEvent, Usage, type LLMRequest, type MediaPart, type ProviderMetadata, type ToolDefinition } from "../schema/index.js";
-import { ProviderShared } from "./shared.js";
+import type { Media } from "../media.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
@@ -689,7 +689,7 @@ export interface ProviderAdapter {
     }, AIError>;
     readonly lowerMedia?: (input: {
         readonly part: MediaPart;
-        readonly media: ProviderShared.NormalizedMedia;
+        readonly media: Media.Inline | undefined;
         readonly request: LLMRequest;
     }) => MediaInput | undefined;
     readonly restoreHostedToolItem?: (item: unknown) => HostedToolReplayItem | undefined;
@@ -1177,6 +1177,14 @@ export declare const step: (state: ParserState, event: NormalizedEvent) => AIErr
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: Media.Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -1205,12 +1213,12 @@ export declare const step: (state: ParserState, event: NormalizedEvent) => AIErr
 } | {
     readonly type: "provider-error";
     readonly message: string;
+    readonly classification?: "context-overflow" | "payload-too-large" | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly classification?: "context-overflow" | "payload-too-large" | undefined;
 })[]], AIError, never> | Effect.Effect<StepResult, never, never>;
 /**
  * The provider-neutral Open Responses protocol. Provider-specific Responses

package/dist/protocols/open-responses.js

@@ -335,27 +335,27 @@ const lowerReasoning = (part, providerMetadataKey) => {
     };
 };
 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (part, request, adapter, target) {
-    const media = ProviderShared.normalizeMedia(part);
+    const media = part.media.inline();
     const providerMedia = adapter.lowerMedia?.({ part, media, request });
     if (providerMedia)
         return providerMedia;
     const detail = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesInputImage.fields.detail))(part.providerMetadata?.[metadataKey(request.model)]?.detail);
-    const url = typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
-        ? part.data
-        : undefined;
-    if (!media.mime.startsWith("image/")) {
-        if (target === "tool-result" && media.mime.startsWith("video/"))
-            return { type: "input_video", video_url: url ?? media.dataUrl };
+    const mime = part.media.mediaType.toLowerCase();
+    const url = ProviderShared.mediaUrl(part.media);
+    const location = url ?? (yield* ProviderShared.requireInlineMedia(adapter.name, part.media)).dataUrl;
+    if (part.media.kind !== "image") {
+        if (target === "tool-result" && part.media.kind === "video")
+            return { type: "input_video", video_url: location };
         return {
             type: "input_file",
-            filename: part.filename ?? (media.mime === "application/pdf" ? "document.pdf" : "file"),
+            filename: part.filename ?? (mime === "application/pdf" ? "document.pdf" : "file"),
             detail,
-            ...(url ? { file_url: url } : { file_data: media.dataUrl }),
+            ...(url ? { file_url: url } : { file_data: location }),
         };
     }
     return {
         type: "input_image",
-        image_url: url ?? media.dataUrl,
+        image_url: location,
         detail,
     };
 });
@@ -377,12 +377,12 @@ const lowerMessageMedia = Effect.fnUntraced(function* (part, request, adapter) {
 const lowerToolResultContentItem = Effect.fnUntraced(function* (item, request, adapter) {
     if (item.type === "text")
         return { type: "input_text", text: item.text };
-    return yield* lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name }, request, adapter, "tool-result");
+    return yield* lowerMedia(ProviderShared.toolFileMedia(item), request, adapter, "tool-result");
 });
 const lowerHostedToolResultContentItem = Effect.fnUntraced(function* (item, request, adapter) {
     if (item.type === "text")
         return { type: "input_text", text: item.text };
-    return yield* lowerMessageMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name }, request, adapter);
+    return yield* lowerMessageMedia(ProviderShared.toolFileMedia(item), request, adapter);
 });
 const lowerToolResultOutput = Effect.fnUntraced(function* (part, request, adapter) {
     // Text/json/error results are encoded as a plain string for backward
@@ -513,11 +513,22 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                     });
                     continue;
                 }
+                if (part.type === "media") {
+                    flushText();
+                    // Responses has no assistant-authored image item; replay generated media (e.g. from Gemini) as user input.
+                    input.push({
+                        type: "message",
+                        role: "user",
+                        content: [yield* lowerMessageMedia(part, request, adapter)],
+                    });
+                    continue;
+                }
                 return yield* ProviderShared.unsupportedContent(adapter.name, "assistant", [
                     "text",
                     "reasoning",
                     "tool-call",
                     "tool-result",
+                    "media",
                 ]);
             }
             flushText();

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
@@ -204,12 +230,9 @@ 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;
+    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 +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) {
@@ -285,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)
@@ -330,7 +367,7 @@ 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 }))));
+        images.push(...(yield* Effect.forEach(files, (item) => lowerMedia(ProviderShared.toolFileMedia(item)))));
     }
     return { messages, images };
 });
@@ -708,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)
@@ -724,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);
@@ -798,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 &&
@@ -881,6 +948,7 @@ const step = (state, event) => Effect.gen(function* () {
             finishReason,
             lifecycle,
             reasoningField,
+            reasoningTextObserved,
             reasoningDetails: state.reasoningDetails,
             reasoningDetailsObserved,
             reasoningEmitted,
@@ -947,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/dist/protocols/openai-images.d.ts

@@ -1,32 +1,21 @@
-import { ImageModel, type ImageInput } from "../image.js";
-import { type Definition as AuthDefinition } from "../route/auth.js";
-import { type HttpOptions } from "../schema/index.js";
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
 export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export declare const PATH = "/images/generations";
 export declare const EDIT_PATH = "/images/edits";
 export type OpenAIImageString<Known extends string> = Known | (string & {});
+/** Provider-native options. Common fields (`n`, `size`, `format`, `images`, `mask`) live on the request. */
 export type OpenAIImageOptions = {
-    readonly mask?: ImageInput;
-    readonly n?: number;
-    readonly size?: OpenAIImageString<"auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792">;
     readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
     readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">;
     readonly moderation?: OpenAIImageString<"auto" | "low">;
-    readonly outputFormat?: OpenAIImageString<"png" | "jpeg" | "webp">;
     readonly outputCompression?: number;
 } & Record<string, unknown>;
-export type OpenAIImageBody = Record<string, unknown> & {
-    readonly model: string;
-    readonly prompt: string;
-};
-export interface ModelInput {
-    readonly id: string;
-    readonly auth: AuthDefinition;
-    readonly baseURL?: string;
-    readonly headers?: Record<string, string>;
-    readonly http?: HttpOptions;
-}
-export declare const model: (input: ModelInput) => ImageModel<OpenAIImageOptions>;
+export type Request = ImageRequestFor<OpenAIImageOptions>;
+export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<OpenAIImageOptions>;
 export declare const OpenAIImages: {
-    readonly model: (input: ModelInput) => ImageModel<OpenAIImageOptions>;
+    readonly protocol: MediaProtocol.Inline<Request, ImageResponse>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<OpenAIImageOptions>;
 };