@opencode/ai 2.0.13 → 2.0.15

package/dist/schema/events.js

@@ -1,10 +1,11 @@
 import { Schema } from "effect";
 import { LLM } from "@opencode/schema/llm";
 import { ContentBlockID, ToolCallID } from "./ids.js";
-import { Message, CompactionPart, ProviderMetadata, ToolCallPart, ToolOutput, ToolResultPart, ToolResultValue, } from "./messages.js";
+import { Message, CompactionPart, ToolCallPart, ToolOutput, ToolResultPart, ToolResultValue, } from "./messages.js";
+import { ProviderMetadata } from "./options.js";
 import { ProviderFailureClassification } from "./errors.js";
+import { Media } from "../media.js";
 export const FinishReason = LLM.FinishReason;
-export { ProviderMetadata } from "./messages.js";
 /**
  * Token usage reported by an LLM provider.
  *
@@ -75,6 +76,25 @@ export class Usage extends Schema.Class("AI.Usage")({
         return input instanceof Usage ? input : new Usage(input);
     }
 }
+/**
+ * Usage reported by media routes. Providers bill images, video, speech, and transcription in different units, so
+ * each response carries the unit it was actually metered in instead of forcing everything into tokens.
+ */
+export const MediaUsage = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("tokens"),
+        input: Schema.optional(Schema.Number),
+        output: Schema.optional(Schema.Number),
+        total: Schema.optional(Schema.Number),
+        details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    }),
+    Schema.Struct({ type: Schema.Literal("seconds"), seconds: Schema.Number }),
+    Schema.Struct({ type: Schema.Literal("characters"), characters: Schema.Number }),
+    Schema.Struct({ type: Schema.Literal("credits"), credits: Schema.Number }),
+    Schema.Struct({ type: Schema.Literal("compute"), seconds: Schema.Number }),
+])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "AI.MediaUsage" });
 /** A replacement context window, not an assistant message to append to prior history. */
 export class CompactionResponse extends Schema.Class("LLM.CompactionResponse")({
     replacement: Schema.Array(Message),
@@ -205,6 +225,12 @@ export const Finish = Schema.Struct({
     usage: Schema.optional(Usage),
     providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.Finish" });
+/** A generated media asset (image, audio, …) emitted by the model as first-class output rather than a tool result. */
+export const MediaEvent = Schema.Struct({
+    type: Schema.tag("media"),
+    media: Media.AssetSchema,
+    providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "LLM.Event.Media" });
 export const ProviderErrorEvent = Schema.Struct({
     type: Schema.tag("provider-error"),
     message: Schema.String,
@@ -227,6 +253,7 @@ const llmEventTagged = Schema.Union([
     ToolCall,
     ToolResult,
     ToolError,
+    MediaEvent,
     StepFinish,
     Finish,
     ProviderErrorEvent,
@@ -258,6 +285,7 @@ export const LLMEvent = Object.assign(llmEventTagged, {
         output: input.output === undefined ? undefined : ToolOutput.make(input.output.structured, input.output.content),
     }),
     toolError: (input) => ToolError.make({ ...input, id: toolCallID(input.id) }),
+    media: MediaEvent.make,
     stepFinish: (input) => StepFinish.make({
         ...input,
         usage: input.usage === undefined ? undefined : Usage.from(input.usage),
@@ -283,6 +311,7 @@ export const LLMEvent = Object.assign(llmEventTagged, {
         toolCall: llmEventTagged.guards["tool-call"],
         toolResult: llmEventTagged.guards["tool-result"],
         toolError: llmEventTagged.guards["tool-error"],
+        media: llmEventTagged.guards.media,
         stepFinish: llmEventTagged.guards["step-finish"],
         finish: llmEventTagged.guards.finish,
         providerError: llmEventTagged.guards["provider-error"],
@@ -500,6 +529,10 @@ const reduceResponseState = (state, event) => {
             return reduceToolCall(next, event);
         case "tool-result":
             return appendContent(next, toolResultContent(event));
+        case "media":
+            return appendContent(next, event.providerMetadata === undefined
+                ? { type: "media", media: event.media }
+                : { type: "media", media: event.media, providerMetadata: event.providerMetadata });
         default:
             return next;
     }

package/dist/schema/messages.d.ts

@@ -1,10 +1,9 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode/schema/tool";
 import { CacheHint, GenerationOptions, HttpOptions, type LanguageModel, ReasoningEffort } from "./options.js";
+import { Media } from "../media.js";
 export declare const MessageRole: Schema.Literals<readonly ["system", "user", "assistant", "tool"]>;
 export type MessageRole = Schema.Schema.Type<typeof MessageRole>;
-export declare const ProviderMetadata: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
-export type ProviderMetadata = Schema.Schema.Type<typeof ProviderMetadata>;
 declare const systemPartSchema: Schema.Struct<{
     readonly type: Schema.Literal<"text">;
     readonly text: Schema.String;
@@ -31,8 +30,38 @@ export declare const TextPart: Schema.Struct<{
 export type TextPart = Schema.Schema.Type<typeof TextPart>;
 export declare const MediaPart: Schema.Struct<{
     readonly type: Schema.Literal<"media">;
-    readonly mediaType: Schema.String;
-    readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array]>;
+    readonly media: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"bytes">;
+            readonly data: Schema.Uint8Array;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"base64">;
+            readonly data: Schema.String;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"url">;
+            readonly url: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+            readonly expiresAt: Schema.optional<Schema.Number>;
+            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"ref">;
+            readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+            readonly id: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+        }>]>;
+        readonly info: Schema.optional<Schema.Struct<{
+            readonly width: Schema.optional<Schema.Number>;
+            readonly height: Schema.optional<Schema.Number>;
+            readonly durationSeconds: Schema.optional<Schema.Number>;
+            readonly sampleRate: Schema.optional<Schema.Number>;
+            readonly channels: Schema.optional<Schema.Number>;
+            readonly encoding: Schema.optional<Schema.String>;
+            readonly format: Schema.optional<Schema.String>;
+        }>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, never, never>;
     readonly filename: Schema.optional<Schema.String>;
     readonly cache: Schema.optional<typeof CacheHint>;
     readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
@@ -262,8 +291,38 @@ export declare const ContentPart: Schema.toTaggedUnion<"type", readonly [Schema.
     readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"media">;
-    readonly mediaType: Schema.String;
-    readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array]>;
+    readonly media: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"bytes">;
+            readonly data: Schema.Uint8Array;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"base64">;
+            readonly data: Schema.String;
+            readonly mediaType: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"url">;
+            readonly url: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+            readonly expiresAt: Schema.optional<Schema.Number>;
+            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"ref">;
+            readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+            readonly id: Schema.String;
+            readonly mediaType: Schema.optional<Schema.String>;
+        }>]>;
+        readonly info: Schema.optional<Schema.Struct<{
+            readonly width: Schema.optional<Schema.Number>;
+            readonly height: Schema.optional<Schema.Number>;
+            readonly durationSeconds: Schema.optional<Schema.Number>;
+            readonly sampleRate: Schema.optional<Schema.Number>;
+            readonly channels: Schema.optional<Schema.Number>;
+            readonly encoding: Schema.optional<Schema.String>;
+            readonly format: Schema.optional<Schema.String>;
+        }>>;
+        readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, never, never>;
     readonly filename: Schema.optional<Schema.String>;
     readonly cache: Schema.optional<typeof CacheHint>;
     readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
@@ -377,8 +436,38 @@ declare const Message_base: Schema.Class<Message, Schema.Struct<{
         readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"media">;
-        readonly mediaType: Schema.String;
-        readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array]>;
+        readonly media: Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
+            readonly source: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"bytes">;
+                readonly data: Schema.Uint8Array;
+                readonly mediaType: Schema.String;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"base64">;
+                readonly data: Schema.String;
+                readonly mediaType: Schema.String;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"url">;
+                readonly url: Schema.String;
+                readonly mediaType: Schema.optional<Schema.String>;
+                readonly expiresAt: Schema.optional<Schema.Number>;
+                readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"ref">;
+                readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
+                readonly id: Schema.String;
+                readonly mediaType: Schema.optional<Schema.String>;
+            }>]>;
+            readonly info: Schema.optional<Schema.Struct<{
+                readonly width: Schema.optional<Schema.Number>;
+                readonly height: Schema.optional<Schema.Number>;
+                readonly durationSeconds: Schema.optional<Schema.Number>;
+                readonly sampleRate: Schema.optional<Schema.Number>;
+                readonly channels: Schema.optional<Schema.Number>;
+                readonly encoding: Schema.optional<Schema.String>;
+                readonly format: Schema.optional<Schema.String>;
+            }>>;
+            readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+        }>, never, never>;
         readonly filename: Schema.optional<Schema.String>;
         readonly cache: Schema.optional<typeof CacheHint>;
         readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
@@ -493,6 +582,7 @@ export declare namespace Message {
         readonly content: ContentInput;
     };
     const text: (value: string) => ContentPart;
+    const media: (asset: Media.Asset, options?: Omit<MediaPart, "type" | "media">) => MediaPart;
     const content: (input: ContentInput) => any[];
     const make: (input: Message | Input) => Message;
     const user: (content: ContentInput) => Message;

package/dist/schema/messages.js

@@ -1,11 +1,9 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode/schema/tool";
-import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, JsonSchema, LanguageModelSchema, ProviderOptions, ReasoningEffort, } from "./options.js";
+import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, JsonSchema, LanguageModelSchema, ProviderMetadata, ProviderOptions, ReasoningEffort, } from "./options.js";
 import { ProviderID } from "./ids.js";
+import { Media } from "../media.js";
 export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"]);
-export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown)).annotate({
-    identifier: "LLM.ProviderMetadata",
-});
 const systemPartSchema = Schema.Struct({
     type: Schema.Literal("text"),
     text: Schema.String,
@@ -30,8 +28,7 @@ export const TextPart = Schema.Struct({
 }).annotate({ identifier: "LLM.Content.Text" });
 export const MediaPart = Schema.Struct({
     type: Schema.Literal("media"),
-    mediaType: Schema.String,
-    data: Schema.Union([Schema.String, Schema.Uint8Array]),
+    media: Media.AssetSchema,
     filename: Schema.optional(Schema.String),
     cache: Schema.optional(CacheHint),
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
@@ -184,6 +181,11 @@ export class Message extends Schema.Class("LLM.Message")({
 }
 (function (Message) {
     Message.text = (value) => ({ type: "text", text: value });
+    Message.media = (asset, options) => ({
+        type: "media",
+        media: asset,
+        ...options,
+    });
     Message.content = (input) => typeof input === "string" ? [Message.text(input)] : Array.isArray(input) ? [...input] : [input];
     Message.make = (input) => {
         if (input instanceof Message)

package/dist/schema/options.d.ts

@@ -6,6 +6,8 @@ export type JsonSchema = Schema.Schema.Type<typeof JsonSchema>;
 export declare const mergeJsonRecords: (...items: ReadonlyArray<Record<string, unknown> | undefined>) => Record<string, unknown> | undefined;
 export declare const ProviderOptions: Schema.$Record<Schema.String, Schema.Unknown>;
 export type ProviderOptions = Schema.Schema.Type<typeof ProviderOptions>;
+export declare const ProviderMetadata: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
+export type ProviderMetadata = Schema.Schema.Type<typeof ProviderMetadata>;
 export declare const mergeProviderOptions: (...items: ReadonlyArray<ProviderOptions | undefined>) => ProviderOptions | undefined;
 declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
     readonly body: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;

package/dist/schema/options.js

@@ -28,6 +28,9 @@ const mergeStringRecords = (...items) => {
     return Object.keys(result).length === 0 ? undefined : result;
 };
 export const ProviderOptions = Schema.Record(Schema.String, Schema.Unknown);
+export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown)).annotate({
+    identifier: "LLM.ProviderMetadata",
+});
 export const mergeProviderOptions = (...items) => mergeJsonRecords(...items);
 export class HttpOptions extends Schema.Class("AI.HttpOptions")({
     body: Schema.optional(JsonSchema),

package/dist/testing.d.ts

@@ -215,6 +215,14 @@ export declare const complete: (options: {
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("./media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -243,12 +251,12 @@ export declare const complete: (options: {
 } | {
     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;
 })[];
 export declare const stop: (...events: readonly LLMEvent[]) => (({
     readonly type: "compaction";
@@ -419,6 +427,14 @@ export declare const stop: (...events: readonly LLMEvent[]) => (({
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("./media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -447,12 +463,12 @@ export declare const stop: (...events: readonly LLMEvent[]) => (({
 } | {
     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;
 })[];
 export declare const toolCalls: (...events: readonly LLMEvent[]) => (({
     readonly type: "compaction";
@@ -623,6 +639,14 @@ export declare const toolCalls: (...events: readonly LLMEvent[]) => (({
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("./media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -651,12 +675,12 @@ export declare const toolCalls: (...events: readonly LLMEvent[]) => (({
 } | {
     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;
 })[];
 export declare const text: (value: string, id: string) => (({
     readonly type: "compaction";
@@ -827,6 +851,14 @@ export declare const text: (value: string, id: string) => (({
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("./media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -855,12 +887,12 @@ export declare const text: (value: string, id: string) => (({
 } | {
     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;
 })[];
 export declare const textWithUsage: (value: string, id: string, inputTokens: number) => (({
     readonly type: "compaction";
@@ -1031,6 +1063,14 @@ export declare const textWithUsage: (value: string, id: string, inputTokens: num
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("./media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -1059,12 +1099,12 @@ export declare const textWithUsage: (value: string, id: string, inputTokens: num
 } | {
     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;
 })[];
 export declare const tool: (id: string, name: string, input: unknown) => (({
     readonly type: "compaction";
@@ -1235,6 +1275,14 @@ export declare const tool: (id: string, name: string, input: unknown) => (({
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("./media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -1263,12 +1311,12 @@ export declare const tool: (id: string, name: string, input: unknown) => (({
 } | {
     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;
 })[];
 export declare const failAfter: (error: AIError, ...events: readonly LLMEvent[]) => Stream.Stream<({
     readonly type: "compaction";
@@ -1439,6 +1487,14 @@ export declare const failAfter: (error: AIError, ...events: readonly LLMEvent[])
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("./media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -1467,12 +1523,12 @@ export declare const failAfter: (error: AIError, ...events: readonly LLMEvent[])
 } | {
     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>;
 export declare const hangAfter: (...events: readonly LLMEvent[]) => Stream.Stream<({
     readonly type: "compaction";
@@ -1643,6 +1699,14 @@ export declare const hangAfter: (...events: readonly LLMEvent[]) => Stream.Strea
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("./media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -1671,12 +1735,12 @@ export declare const hangAfter: (...events: readonly LLMEvent[]) => Stream.Strea
 } | {
     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;
 }, never, never>;
 /** Provides one shared implementation under the normal client and test-control tags. */
 export declare const testLayer: (options?: LayerOptions) => Layer.Layer<import("./route/client.js").Service | Test, never, never>;

package/dist/utils/media-type.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sniff a media type from leading magic bytes. Covers the containers media routes commonly return; anything else is
+ * `undefined` so callers can fall back to a provider-declared type or `application/octet-stream`.
+ */
+export declare const detectMediaType: (bytes: Uint8Array) => string | undefined;
+export declare const extensionMediaType: (path: string) => string | undefined;

package/dist/utils/media-type.js

@@ -0,0 +1,49 @@
+const ascii = (bytes, start, end) => String.fromCharCode(...bytes.subarray(start, end));
+const startsWith = (bytes, prefix) => bytes.length >= prefix.length && prefix.every((value, index) => bytes[index] === value);
+/**
+ * Sniff a media type from leading magic bytes. Covers the containers media routes commonly return; anything else is
+ * `undefined` so callers can fall back to a provider-declared type or `application/octet-stream`.
+ */
+export const detectMediaType = (bytes) => {
+    if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))
+        return "image/png";
+    if (startsWith(bytes, [0xff, 0xd8, 0xff]))
+        return "image/jpeg";
+    if (startsWith(bytes, [0x47, 0x49, 0x46, 0x38]))
+        return "image/gif";
+    if (bytes.length >= 12 && ascii(bytes, 0, 4) === "RIFF") {
+        const riffType = ascii(bytes, 8, 12);
+        if (riffType === "WEBP")
+            return "image/webp";
+        if (riffType === "WAVE")
+            return "audio/wav";
+    }
+    if (startsWith(bytes, [0x25, 0x50, 0x44, 0x46]))
+        return "application/pdf";
+    if (bytes.length >= 12 && ascii(bytes, 4, 8) === "ftyp")
+        return "video/mp4";
+    if (startsWith(bytes, [0x1a, 0x45, 0xdf, 0xa3]))
+        return "video/webm";
+    if (startsWith(bytes, [0x49, 0x44, 0x33]) || startsWith(bytes, [0xff, 0xfb]) || startsWith(bytes, [0xff, 0xf3]))
+        return "audio/mpeg";
+    if (startsWith(bytes, [0x4f, 0x67, 0x67, 0x53]))
+        return "audio/ogg";
+    return undefined;
+};
+const EXTENSIONS = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    pdf: "application/pdf",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    txt: "text/plain",
+    md: "text/markdown",
+    csv: "text/csv",
+};
+export const extensionMediaType = (path) => EXTENSIONS[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];

package/dist/utils/sanitize.js

@@ -1,10 +1,12 @@
+import { Media } from "../media.js";
 import { isRecord } from "./record.js";
 export const sanitizeSurrogates = (value) => {
     if (typeof value === "string")
         return value.toWellFormed();
     if (Array.isArray(value))
         return value.map(sanitizeSurrogates);
-    if (value instanceof Uint8Array || value instanceof Error)
+    // Media assets carry binary or base64 payloads and a lazy byte cache; flattening them into a record would drop both.
+    if (value instanceof Uint8Array || value instanceof Error || value instanceof Media.Asset)
         return value;
     if (isRecord(value))
         return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key.toWellFormed(), sanitizeSurrogates(entry)]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.13",
+  "version": "2.0.15",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -18,6 +18,10 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./promise": {
+      "import": "./dist/promise.js",
+      "types": "./dist/promise.d.ts"
+    },
     "./testing": {
       "import": "./dist/testing.js",
       "types": "./dist/testing.d.ts"
@@ -30,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "2.0.13",
+    "@opencode/http-recorder": "2.0.15",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -40,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "2.0.13",
+    "@opencode/schema": "2.0.15",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"

package/dist/protocols/utils/image-input.d.ts

@@ -1,21 +0,0 @@
-import { Effect } from "effect";
-import type { ImageInput } from "../../image.js";
-import { AIError } from "../../schema/index.js";
-export declare const dataUrl: (input: Extract<ImageInput, {
-    readonly type: "bytes";
-}>) => string;
-export declare const decodeDataUrl: (url: string) => Effect.Effect<{
-    readonly mediaType: string;
-    readonly data: Uint8Array;
-} | undefined, AIError>;
-export declare const invalidImageInput: (message: string, cause?: unknown) => AIError;
-export declare const ImageInputs: {
-    readonly dataUrl: (input: Extract<ImageInput, {
-        readonly type: "bytes";
-    }>) => string;
-    readonly decodeDataUrl: (url: string) => Effect.Effect<{
-        readonly mediaType: string;
-        readonly data: Uint8Array;
-    } | undefined, AIError>;
-    readonly invalid: (message: string, cause?: unknown) => AIError;
-};

package/dist/protocols/utils/image-input.js

@@ -1,20 +0,0 @@
-import { Effect, Encoding } from "effect";
-import { InvalidRequestError, AIError } from "../../schema/index.js";
-const invalid = (message, cause) => new AIError({
-    reason: new InvalidRequestError({ message, cause }),
-});
-export const dataUrl = (input) => `data:${input.mediaType};base64,${Encoding.encodeBase64(input.data)}`;
-export const decodeDataUrl = (url) => {
-    if (!url.startsWith("data:"))
-        return Effect.undefined;
-    const match = /^data:([^;,]+);base64,(.*)$/s.exec(url);
-    if (!match)
-        return Effect.fail(invalid("Image data URLs must contain a MIME type and base64 data"));
-    return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(Effect.mapError((cause) => invalid("Image data URL contains invalid base64 data", cause)), Effect.map((data) => ({ mediaType: match[1], data })));
-};
-export const invalidImageInput = invalid;
-export const ImageInputs = {
-    dataUrl,
-    decodeDataUrl,
-    invalid: invalidImageInput,
-};