@opencode/ai 2.0.14 → 2.0.16

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,37 @@ 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>;
+        }>, 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 +290,37 @@ 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>;
+        }>, 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 +434,37 @@ 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>;
+            }>, 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 +579,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>>;
@@ -68,12 +70,13 @@ export declare namespace LanguageModelDefaults {
 export declare const ReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export type ReasoningEffort = (typeof ReasoningEfforts)[number] | (string & {});
 export declare const ReasoningEffort: Schema.declare<ReasoningEffort, ReasoningEffort>;
-export declare const LanguageModelToolSchemaCompatibility: Schema.Literals<readonly ["gemini", "moonshot"]>;
-export type LanguageModelToolSchemaCompatibility = Schema.Schema.Type<typeof LanguageModelToolSchemaCompatibility>;
+/** Tool schema sanitizer for a model family. `none` opts out of the protocol and model-name defaults. */
+export declare const LanguageModelSanitizerCompatibility: Schema.Literals<readonly ["gemini", "moonshot", "none"]>;
+export type LanguageModelSanitizerCompatibility = Schema.Schema.Type<typeof LanguageModelSanitizerCompatibility>;
 export declare const LanguageModelMaxTokensFieldCompatibility: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
 export type LanguageModelMaxTokensFieldCompatibility = Schema.Schema.Type<typeof LanguageModelMaxTokensFieldCompatibility>;
 declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompatibility, Schema.Struct<{
-    readonly toolSchema: Schema.optional<Schema.Literals<readonly ["gemini", "moonshot"]>>;
+    readonly sanitizer: Schema.optional<Schema.Literals<readonly ["gemini", "moonshot", "none"]>>;
     readonly reasoningField: Schema.optional<Schema.String>;
     /** Require every assistant message to include its reasoning field, even when empty. */
     readonly requireReasoning: Schema.optional<Schema.Boolean>;

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),
@@ -96,10 +99,11 @@ export class LanguageModelDefaults extends Schema.Class("LLM.LanguageModelDefaul
 })(LanguageModelDefaults || (LanguageModelDefaults = {}));
 export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export const ReasoningEffort = Schema.declare((value) => typeof value === "string", { title: "ReasoningEffort" });
-export const LanguageModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"]);
+/** Tool schema sanitizer for a model family. `none` opts out of the protocol and model-name defaults. */
+export const LanguageModelSanitizerCompatibility = Schema.Literals(["gemini", "moonshot", "none"]);
 export const LanguageModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"]);
 export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelCompatibility")({
-    toolSchema: Schema.optional(LanguageModelToolSchemaCompatibility),
+    sanitizer: Schema.optional(LanguageModelSanitizerCompatibility),
     reasoningField: Schema.optional(Schema.String),
     /** Require every assistant message to include its reasoning field, even when empty. */
     requireReasoning: Schema.optional(Schema.Boolean),

package/dist/speech-client.d.ts

@@ -0,0 +1,21 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { RequestExecutor } from "./route/executor.js";
+import type { AIError } from "./schema/index.js";
+import type { SpeechEvent, SpeechOptions, SpeechRequestFor, SpeechResponse } from "./speech.js";
+export interface Interface {
+    readonly generate: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Effect.Effect<SpeechResponse, AIError>;
+    readonly stream: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Stream.Stream<SpeechEvent, AIError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SpeechClient", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const generate: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Effect.Effect<SpeechResponse, AIError, Service>;
+export declare const stream: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Stream.Stream<SpeechEvent, AIError, Service>;
+export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+export declare const SpeechClient: {
+    readonly Service: typeof Service;
+    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly generate: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Effect.Effect<SpeechResponse, AIError, Service>;
+    readonly stream: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Stream.Stream<SpeechEvent, AIError, Service>;
+};
+export {};

package/dist/speech-client.js

@@ -0,0 +1,25 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { RequestExecutor } from "./route/executor.js";
+export class Service extends Context.Service()("@opencode/SpeechClient") {
+}
+export const generate = (request) => Effect.gen(function* () {
+    const client = yield* Service;
+    return yield* client.generate(request);
+});
+export const stream = (request) => Stream.unwrap(Effect.gen(function* () {
+    const client = yield* Service;
+    return client.stream(request);
+}));
+export const layer = Layer.effect(Service, Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service;
+    return Service.of({
+        generate: (request) => request.model.route.generate(request, executor.execute),
+        stream: (request) => request.model.route.stream(request, executor.execute),
+    });
+}));
+export const SpeechClient = {
+    Service,
+    layer,
+    generate,
+    stream,
+};