@opencode/ai 2.0.14 → 2.0.16

package/dist/image.js

@@ -1,103 +1,133 @@
-import { Effect, Schema } from "effect";
-import { HttpOptions, InvalidRequestError, AIError, ModelID, ProviderID, ProviderMetadata, Usage, } from "./schema/index.js";
+import { Effect, Schema, Stream } from "effect";
+import { Generation, ProgressEvent, QueuedEvent } from "./generation.js";
+import { Media } from "./media.js";
+import { MediaModel, composeAnyRoute, tryRequest } from "./media-model.js";
+import { MediaRoute } from "./route/media.js";
+import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js";
 import { ImageClient, Service } from "./image-client.js";
-export class ImageModel {
-    id;
-    provider;
-    route;
-    http;
-    constructor(input) {
-        this.id = input.id;
-        this.provider = input.provider;
-        this.route = input.route;
-        this.http = input.http;
-    }
+export class ImageModel extends MediaModel {
     static make(input) {
+        return new ImageModel(input);
+    }
+    static fromRoute(route, input) {
         return new ImageModel({
-            id: ModelID.make(input.id),
-            provider: ProviderID.make(input.provider),
-            route: input.route,
+            id: input.id,
+            provider: route.provider,
             http: input.http,
+            route: composeAnyRoute(route, input, collectResponse),
         });
     }
 }
 export const ImageModelSchema = Schema.declare((value) => value instanceof ImageModel, {
     expected: "Image.Model",
 });
-const ImageBytesInput = Schema.Struct({
-    type: Schema.Literal("bytes"),
-    data: Schema.Uint8Array,
-    mediaType: Schema.String,
-});
-const ImageUrlInput = Schema.Struct({
-    type: Schema.Literal("url"),
-    url: Schema.String,
-});
-const ImageFileIDInput = Schema.Struct({
-    type: Schema.Literal("file-id"),
-    id: Schema.String,
-});
-const ImageFileURIInput = Schema.Struct({
-    type: Schema.Literal("file-uri"),
-    uri: Schema.String,
-    mediaType: Schema.String,
-});
-export const ImageInputSchema = Schema.Union([
-    ImageBytesInput,
-    ImageUrlInput,
-    ImageFileIDInput,
-    ImageFileURIInput,
-]).pipe(Schema.toTaggedUnion("type"));
-export const ImageInput = {
-    bytes: (data, mediaType) => ({ type: "bytes", data, mediaType }),
-    url: (url) => ({ type: "url", url }),
-    file: (id) => ({ type: "file-id", id }),
-    fileUri: (uri, mediaType) => ({ type: "file-uri", uri, mediaType }),
-};
+export const ImageSize = Schema.declare((value) => typeof value === "string" && /^\d+x\d+$/.test(value), { title: "ImageSize" });
+export const ImageAspectRatio = Media.AspectRatio;
 export class ImageRequest extends Schema.Class("Image.Request")({
     model: ImageModelSchema,
     prompt: Schema.String,
-    images: Schema.optional(Schema.Array(ImageInputSchema)),
-    options: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    /** Edit sources or style/subject references, in order. */
+    images: Schema.optional(Schema.Array(Media.AssetSchema)),
+    /** Inpainting mask; routes that cannot honor it fail with `UnsupportedOperation`. */
+    mask: Schema.optional(Media.AssetSchema),
+    n: Schema.optional(Schema.Int),
+    size: Schema.optional(ImageSize),
+    aspectRatio: Schema.optional(ImageAspectRatio),
+    seed: Schema.optional(Schema.Number),
+    format: Schema.optional(Schema.String),
+    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
     http: Schema.optional(HttpOptions),
 }) {
 }
-export class GeneratedImage extends Schema.Class("Image.Generated")({
-    mediaType: Schema.String,
-    data: Schema.Union([Schema.String, Schema.Uint8Array]),
-    providerMetadata: Schema.optional(ProviderMetadata),
-}) {
-}
+// ---------------------------------------------------------------------------
+// Response and events
+// ---------------------------------------------------------------------------
 export class ImageResponse extends Schema.Class("Image.Response")({
-    images: Schema.Array(GeneratedImage),
-    usage: Schema.optional(Usage),
+    images: Schema.Array(Media.AssetSchema),
+    usage: Schema.optional(MediaUsage),
+    notices: Schema.optional(Schema.Array(Media.Notice)),
     providerMetadata: Schema.optional(ProviderMetadata),
 }) {
     get image() {
         return this.images[0];
     }
 }
+/** The `index`-th lower-fidelity preview of an image still generating; the `image` event supersedes it. */
+export const ImagePartialEvent = Schema.Struct({
+    type: Schema.tag("image-partial"),
+    index: Schema.Number,
+    image: Media.AssetSchema,
+}).annotate({ identifier: "Image.Event.Partial" });
+export const ImageOutputEvent = Schema.Struct({
+    type: Schema.tag("image"),
+    index: Schema.Number,
+    image: Media.AssetSchema,
+}).annotate({ identifier: "Image.Event.Image" });
+export const ImageFinishEvent = Schema.Struct({
+    type: Schema.tag("finish"),
+    usage: Schema.optional(MediaUsage),
+    notices: Schema.optional(Schema.Array(Media.Notice)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "Image.Event.Finish" });
+const imageEventTagged = Schema.Union([
+    QueuedEvent,
+    ProgressEvent,
+    ImagePartialEvent,
+    ImageOutputEvent,
+    ImageFinishEvent,
+]).pipe(Schema.toTaggedUnion("type"));
+export const ImageEvent = Object.assign(imageEventTagged, {
+    is: {
+        generationQueued: imageEventTagged.guards["generation-queued"],
+        generationProgress: imageEventTagged.guards["generation-progress"],
+        imagePartial: imageEventTagged.guards["image-partial"],
+        image: imageEventTagged.guards.image,
+        finish: imageEventTagged.guards.finish,
+    },
+});
+export const responseEvents = (response) => [
+    ...response.images.map((image, index) => ImageOutputEvent.make({ index, image })),
+    ImageFinishEvent.make({
+        usage: response.usage,
+        notices: response.notices,
+        providerMetadata: response.providerMetadata,
+    }),
+];
+const collectResponse = (events) => {
+    const finish = events.find(ImageEvent.is.finish);
+    // Every image protocol's `finish` emits the terminal event or fails, so a completed stream always has one.
+    if (finish === undefined)
+        return Effect.die(new Error("The image stream completed without a finish event"));
+    return Effect.succeed(new ImageResponse({
+        images: events.filter(ImageEvent.is.image).map((event) => event.image),
+        usage: finish.usage,
+        notices: finish.notices,
+        providerMetadata: finish.providerMetadata,
+    }));
+};
 export function request(input) {
     if (input instanceof ImageRequest)
         return input;
     return new ImageRequest({
         ...input,
-        model: input.model,
         http: input.http === undefined ? undefined : HttpOptions.make(input.http),
     });
 }
-export function generate(input) {
-    return Effect.try({
-        try: () => (input instanceof ImageRequest ? input : request(input)),
-        catch: (error) => new AIError({
-            reason: new InvalidRequestError({
-                message: error instanceof Error ? error.message : String(error),
-                cause: error,
-            }),
-        }),
-    }).pipe(Effect.flatMap((request) => ImageClient.generate(request)));
+const requestEffect = (input) => tryRequest(() => request(input));
+export function generate(input, options) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => ImageClient.generate(request, options)));
+}
+export function stream(input, options) {
+    return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => ImageClient.stream(request, options))));
+}
+export function start(input) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => ImageClient.start(request)));
 }
+export const resume = (model, token) => ImageClient.resume(model, token);
 export const Image = {
     request,
     generate,
+    stream,
+    start,
+    resume,
 };

package/dist/index.d.ts

@@ -6,9 +6,24 @@ export { ProviderPackage } from "./provider-package.js";
 export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js";
 export type { RouteLanguageModelInput, RouteRoutedLanguageModelInput, Interface as LLMClientShape, Service as LLMClientService, } from "./route/client.js";
 export * from "./schema/index.js";
-export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image.js";
-export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute } from "./image.js";
+export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";
+export type { ImageFormat, ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute, } from "./image.js";
 export { Image } from "./image.js";
+export { VideoClient } from "./video-client.js";
+export { VideoAspectRatio, VideoEvent, VideoFrames, VideoModel, VideoModelSchema, VideoRequest, VideoResponse, } from "./video.js";
+export type { VideoModelOptions, VideoOptions, VideoRequestFor, VideoRequestInput, VideoResolution, VideoRoute, } from "./video.js";
+export { Video } from "./video.js";
+export { SpeechClient } from "./speech-client.js";
+export { SpeechEvent, SpeechModel, SpeechModelSchema, SpeechRequest, SpeechResponse, SpeechTimestamp, SpeechVoice, } from "./speech.js";
+export type { SpeechFormat, SpeechModelOptions, SpeechOptions, SpeechRequestFor, SpeechRequestInput, SpeechRoute, } from "./speech.js";
+export { Speech } from "./speech.js";
+export { TranscriptionClient } from "./transcription-client.js";
+export { TranscriptionEvent, TranscriptionModel, TranscriptionModelSchema, TranscriptionRequest, TranscriptionResponse, TranscriptionSegment, TranscriptionTimestamps, TranscriptionWord, } from "./transcription.js";
+export type { TranscriptionModelOptions, TranscriptionOptions, TranscriptionRequestFor, TranscriptionRequestInput, TranscriptionRoute, } from "./transcription.js";
+export { Transcription } from "./transcription.js";
+export { Media } from "./media.js";
+export { Generation } from "./generation.js";
+export type { AwaitOptions as GenerationAwaitOptions, Event as GenerationEvent, Poll, Route as GenerationRoute, Snapshot as GenerationSnapshot, Status as GenerationStatus, } from "./generation.js";
 export { Tool, ToolFailure, toDefinitions } from "./tool.js";
 export { ToolRuntime } from "./tool-runtime.js";
 export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime.js";

package/dist/index.js

@@ -5,8 +5,19 @@ export { Provider } from "./provider.js";
 export { ProviderPackage } from "./provider-package.js";
 export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js";
 export * from "./schema/index.js";
-export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image.js";
+export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";
 export { Image } from "./image.js";
+export { VideoClient } from "./video-client.js";
+export { VideoAspectRatio, VideoEvent, VideoFrames, VideoModel, VideoModelSchema, VideoRequest, VideoResponse, } from "./video.js";
+export { Video } from "./video.js";
+export { SpeechClient } from "./speech-client.js";
+export { SpeechEvent, SpeechModel, SpeechModelSchema, SpeechRequest, SpeechResponse, SpeechTimestamp, SpeechVoice, } from "./speech.js";
+export { Speech } from "./speech.js";
+export { TranscriptionClient } from "./transcription-client.js";
+export { TranscriptionEvent, TranscriptionModel, TranscriptionModelSchema, TranscriptionRequest, TranscriptionResponse, TranscriptionSegment, TranscriptionTimestamps, TranscriptionWord, } from "./transcription.js";
+export { Transcription } from "./transcription.js";
+export { Media } from "./media.js";
+export { Generation } from "./generation.js";
 export { Tool, ToolFailure, toDefinitions } from "./tool.js";
 export { ToolRuntime } from "./tool-runtime.js";
 export * as LLM from "./llm.js";

package/dist/llm.d.ts

@@ -191,6 +191,14 @@ export declare class GenerateObjectResponse<T> {
             };
         } | 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: {
@@ -219,12 +227,12 @@ export declare class GenerateObjectResponse<T> {
     } | {
         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;
     })[];
     get usage(): import("./schema/events.js").Usage | undefined;
 }

package/dist/media-model.d.ts

@@ -0,0 +1,44 @@
+import { Effect } from "effect";
+import { Endpoint } from "./route/endpoint.js";
+import { MediaRoute } from "./route/media.js";
+import type { MediaProtocol } from "./route/media-protocol.js";
+import { AIError, HttpOptions, ModelID, ProviderID } from "./schema/index.js";
+/**
+ * What every media model carries: ids, the configured route, and deployment `http` overlays. Modality classes
+ * (`ImageModel`, `VideoModel`, `SpeechModel`) extend it with their route type and a nominal marker so one cannot stand
+ * in for the other in requests.
+ */
+export declare class MediaModel<Route, Options> {
+    protected readonly _Options: (options: Options) => Options;
+    readonly id: ModelID;
+    readonly provider: ProviderID;
+    readonly route: Route;
+    readonly http?: HttpOptions;
+    constructor(input: MediaModel.Input<Route>);
+}
+export declare namespace MediaModel {
+    interface Input<Route> {
+        readonly id: string | ModelID;
+        readonly provider: string | ProviderID;
+        readonly route: Route;
+        readonly http?: HttpOptions;
+    }
+    /** A protocol plus its canonical start path; `ModelInput.baseURL` overrides `baseURL` per deployment. */
+    interface RouteInput<Request extends MediaRoute.MediaRequest, Protocol> {
+        readonly id: string;
+        readonly provider: string | ProviderID;
+        readonly protocol: Protocol;
+        readonly path: Endpoint.EndpointPart<MediaProtocol.Body, Request>;
+        readonly baseURL?: string;
+        /** Headers the protocol requires on every call, such as a pinned API version; deployment headers win. */
+        readonly headers?: Record<string, string>;
+    }
+    type AnyRouteInput<Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token> = RouteInput<Request, MediaProtocol.Inline<Request, Response>> | RouteInput<MediaProtocol.Addressed<Request>, MediaProtocol.Streamed<Request, Event, Frame, State>> | RouteInput<Request, MediaProtocol.Queued<Request, Response, Token>>;
+}
+/** Compose a protocol route input with one deployment through `MediaRoute.inline`, `queued`, or `stream`. */
+export declare const composeRoute: <Request extends MediaRoute.MediaRequest, Protocol, Route>(compose: (input: MediaRoute.Composition<Request> & {
+    readonly protocol: Protocol;
+}) => Route, route: MediaModel.RouteInput<Request, Protocol>, input: MediaRoute.ModelInput) => Route;
+export declare const composeAnyRoute: <Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token>(route: MediaModel.AnyRouteInput<Request, Event, Response, Frame, State, Token>, input: MediaRoute.ModelInput, collect: (events: ReadonlyArray<Event>) => Effect.Effect<Response, AIError>) => MediaRoute.AnyRoute<Request, Event, Response>;
+/** Lift a synchronous Schema-class constructor into a typed `InvalidRequest` failure. */
+export declare const tryRequest: <A>(make: () => A) => Effect.Effect<A, AIError>;

package/dist/media-model.js

@@ -0,0 +1,49 @@
+import { Effect } from "effect";
+import { Endpoint } from "./route/endpoint.js";
+import { MediaRoute } from "./route/media.js";
+import { AIError, HttpOptions, InvalidRequestError, ModelID, ProviderID } from "./schema/index.js";
+/**
+ * What every media model carries: ids, the configured route, and deployment `http` overlays. Modality classes
+ * (`ImageModel`, `VideoModel`, `SpeechModel`) extend it with their route type and a nominal marker so one cannot stand
+ * in for the other in requests.
+ */
+export class MediaModel {
+    id;
+    provider;
+    route;
+    http;
+    constructor(input) {
+        this.id = ModelID.make(input.id);
+        this.provider = ProviderID.make(input.provider);
+        this.route = input.route;
+        this.http = input.http;
+    }
+}
+/** Compose a protocol route input with one deployment through `MediaRoute.inline`, `queued`, or `stream`. */
+export const composeRoute = (compose, route, input) => compose({
+    id: route.id,
+    provider: route.provider,
+    protocol: route.protocol,
+    endpoint: Endpoint.path(route.path, { baseURL: input.baseURL ?? route.baseURL }),
+    auth: input.auth,
+    headers: route.headers === undefined && input.headers === undefined ? undefined : { ...route.headers, ...input.headers },
+});
+export const composeAnyRoute = (route, input, collect) => {
+    if (isStreamInput(route))
+        return composeRoute((composition) => MediaRoute.stream({ ...composition, collect }), route, input);
+    if (isQueuedInput(route))
+        return composeRoute(MediaRoute.queued, route, input);
+    return composeRoute(MediaRoute.inline, route, input);
+};
+const isStreamInput = (route) => route.protocol.kind === "stream";
+const isQueuedInput = (route) => route.protocol.kind === "queued";
+/** Lift a synchronous Schema-class constructor into a typed `InvalidRequest` failure. */
+export const tryRequest = (make) => Effect.try({
+    try: make,
+    catch: (error) => new AIError({
+        reason: new InvalidRequestError({
+            message: error instanceof Error ? error.message : String(error),
+            cause: error,
+        }),
+    }),
+});

package/dist/media.d.ts

@@ -0,0 +1,213 @@
+export * as Media from "./media.js";
+import { Effect, FileSystem, Schema } from "effect";
+import { ProviderID } from "./schema/ids.js";
+import { AIError } from "./schema/errors.js";
+import { ProviderMetadata } from "./schema/options.js";
+import { Service } from "./route/executor-service.js";
+export { detectMediaType } from "./utils/media-type.js";
+export declare const 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>;
+    /** Epoch milliseconds after which the provider no longer serves the URL. */
+    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>;
+}>]>;
+export type Source = Schema.Schema.Type<typeof Source>;
+export type AspectRatio = `${number}:${number}`;
+export declare const AspectRatio: Schema.declare<`${number}:${number}`, `${number}:${number}`>;
+export declare const Kind: Schema.Literals<readonly ["image", "video", "audio", "document", "other"]>;
+export type Kind = Schema.Schema.Type<typeof Kind>;
+export declare const kindOf: (mediaType: string) => Kind;
+/** Container-independent facts about the payload; raw PCM audio relies on these because it has no header. */
+export declare const Info: 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>;
+}>;
+export type Info = Schema.Schema.Type<typeof Info>;
+/** A provider-side partial result such as stripped audio or a moderated sample; never a silent drop. */
+export declare const Notice: Schema.Struct<{
+    readonly type: Schema.Literals<readonly ["moderated", "filtered", "other"]>;
+    readonly message: Schema.String;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>;
+export type Notice = Schema.Schema.Type<typeof Notice>;
+/** Synchronous view of an inline payload; `undefined` for `url` and `ref` sources, which carry no local bytes. */
+export interface Inline {
+    readonly mime: string;
+    readonly base64: string;
+    readonly dataUrl: string;
+}
+export declare class Asset {
+    #private;
+    readonly source: Source;
+    /** Derived from the source: declared type, sniffed magic bytes, then `application/octet-stream`. */
+    readonly mediaType: string;
+    readonly kind: Kind;
+    readonly info?: Info;
+    /** Epoch milliseconds after which a `url` source stops resolving. */
+    readonly expiresAt?: number;
+    readonly providerMetadata?: ProviderMetadata;
+    /** Transient download credentials for `url` sources; see `Asset.Input.headers`. */
+    readonly headers?: Record<string, string>;
+    constructor(input: Asset.Input);
+    /** Inline payload without effects, for protocols that embed base64 or data URLs directly. */
+    inline(): Inline | undefined;
+    /** Decoded payload; downloads `url` sources through the request executor and caches the result. */
+    bytes(): Effect.Effect<Uint8Array, AIError, Service>;
+    base64(): Effect.Effect<string, AIError, Service>;
+    dataUrl(): Effect.Effect<string, AIError, Service>;
+    /**
+     * The `AssetEncoded` JSON form with `bytes` sources as base64, matching `Schema.toCodecJson(AssetSchema)`, so a
+     * plain `JSON.stringify` of messages or events stays lossless and decodes back through the JSON codec.
+     */
+    toJSON(): {
+        source: {
+            readonly type: "base64";
+            readonly data: string;
+            readonly mediaType: string;
+        } | {
+            readonly type: "url";
+            readonly url: string;
+            readonly mediaType?: string | undefined;
+            readonly expiresAt?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "ref";
+            readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+            readonly mediaType?: string | undefined;
+        } | {
+            data: string;
+            type: "bytes";
+            mediaType: string;
+        };
+        info: {
+            readonly format?: string | undefined;
+            readonly width?: number | undefined;
+            readonly height?: number | undefined;
+            readonly durationSeconds?: number | undefined;
+            readonly sampleRate?: number | undefined;
+            readonly channels?: number | undefined;
+            readonly encoding?: string | undefined;
+        } | undefined;
+        providerMetadata: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    };
+    /** Pull `url` sources into owned bytes before the URL expires. Inline sources return themselves. */
+    materialize(): Effect.Effect<Asset, AIError, Service>;
+}
+export declare namespace Asset {
+    interface Input {
+        readonly source: Source;
+        readonly info?: Info;
+        readonly providerMetadata?: ProviderMetadata;
+        /**
+         * Headers required to download a `url` source, such as the provider API key Veo demands for its file URIs.
+         * They are runtime-only: never part of `source`, `toJSON()`, or `AssetSchema`, so a persisted asset cannot leak
+         * credentials and cannot be downloaded again after a round-trip. Call `materialize()` before persisting.
+         */
+        readonly headers?: Record<string, string>;
+    }
+}
+/** JSON form of an asset: the serializable `Source` plus caller-supplied metadata. `bytes` sources encode as base64. */
+export declare const AssetEncoded: 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>;
+        /** Epoch milliseconds after which the provider no longer serves the URL. */
+        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>>>;
+}>;
+/** `Asset` in the type domain and `AssetEncoded` on the wire, so messages and events holding assets serialize. */
+export declare const AssetSchema: Schema.decodeTo<Schema.declare<Asset, 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>;
+        /** Epoch milliseconds after which the provider no longer serves the URL. */
+        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>;
+export type AssetOptions = Omit<Asset.Input, "source">;
+export declare const from: (source: Source, options?: AssetOptions) => Asset;
+export declare const bytes: (data: Uint8Array, mediaType?: string, options?: AssetOptions) => Asset;
+export declare const base64: (data: string, mediaType: string, options?: AssetOptions) => Asset;
+export declare const url: (value: string, options?: AssetOptions & Omit<Extract<Source, {
+    readonly type: "url";
+}>, "type" | "url">) => Asset;
+export declare const ref: (provider: string | ProviderID, id: string, mediaType?: string, options?: AssetOptions) => Asset;
+/** Parse a `data:<mime>;base64,<data>` URL, or `undefined` when the value is not a base64 data URL. */
+export declare const parseDataUrl: (value: string, options?: AssetOptions) => Asset | undefined;
+/** Parse a `data:<mime>;base64,<data>` URL. Malformed input throws a typed `AIError` because constructors are sync. */
+export declare const fromDataUrl: (dataUrl: string, options?: AssetOptions) => Asset;
+/** Read a file through `FileSystem` and sniff its media type from magic bytes, then the extension. */
+export declare const file: (path: string, options?: AssetOptions) => Effect.Effect<Asset, AIError, FileSystem.FileSystem>;
+/** Materialize an asset and write its bytes through `FileSystem`. */
+export declare const write: (asset: Asset, path: string) => Effect.Effect<void, AIError, FileSystem.FileSystem | Service>;