@opencode/ai 2.0.16 → 2.0.18

package/dist/media-model.d.ts

@@ -5,11 +5,11 @@ 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.
+ * (`ImageModel`, `VideoModel`, `SpeechModel`, `TranscriptionModel`) 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;
+    protected readonly _Options: Options;
     readonly id: ModelID;
     readonly provider: ProviderID;
     readonly route: Route;
@@ -17,6 +17,7 @@ export declare class MediaModel<Route, Options> {
     constructor(input: MediaModel.Input<Route>);
 }
 export declare namespace MediaModel {
+    type Options = Record<string, unknown>;
     interface Input<Route> {
         readonly id: string | ModelID;
         readonly provider: string | ProviderID;
@@ -25,20 +26,18 @@ export declare namespace MediaModel {
     }
     /** 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>>;
+    type InlineRouteInput<Request extends MediaRoute.MediaRequest, Response> = RouteInput<Request, MediaProtocol.Inline<Request, Response>>;
+    type StreamRouteInput<Request extends MediaRoute.MediaRequest, Event, Frame, State> = RouteInput<MediaProtocol.Addressed<Request>, MediaProtocol.Streamed<Request, Event, Frame, State>>;
+    type QueuedRouteInput<Request extends MediaRoute.MediaRequest, Response, Token> = RouteInput<Request, MediaProtocol.Queued<Request, Response, Token>>;
+    type AnyRouteInput<Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token> = InlineRouteInput<Request, Response> | StreamRouteInput<Request, Event, Frame, State> | QueuedRouteInput<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>;
+export declare const composeRoute: <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

@@ -4,8 +4,8 @@ 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.
+ * (`ImageModel`, `VideoModel`, `SpeechModel`, `TranscriptionModel`) extend it with their route type and a nominal
+ * marker so one cannot stand in for the other in requests.
  */
 export class MediaModel {
     id;
@@ -20,21 +20,19 @@ export class MediaModel {
     }
 }
 /** 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,
+export const composeRoute = (route, input, collect) => {
+    if (isStreamInput(route))
+        return MediaRoute.stream({ ...composition(route, input), collect });
+    if (isQueuedInput(route))
+        return MediaRoute.queued(composition(route, input));
+    return MediaRoute.inline(composition(route, input));
+};
+const composition = (route, input) => ({
     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. */

package/dist/media.js

@@ -5,7 +5,7 @@ import { ProviderID } from "./schema/ids.js";
 import { AIError, HttpContext, InvalidProviderOutputError, InvalidRequestError } from "./schema/errors.js";
 import { ProviderMetadata } from "./schema/options.js";
 import { Service } from "./route/executor-service.js";
-import { detectMediaType, extensionMediaType } from "./utils/media-type.js";
+import { detectMediaType, fileMediaType } from "./utils/media-type.js";
 export { detectMediaType } from "./utils/media-type.js";
 const OCTET_STREAM = "application/octet-stream";
 // ---------------------------------------------------------------------------
@@ -215,7 +215,7 @@ export const file = (path, options) => Effect.gen(function* () {
     const data = yield* fs
         .readFile(path)
         .pipe(Effect.mapError((cause) => invalid(`Failed to read media file ${path}`, cause)));
-    return bytes(data, detectMediaType(data) ?? extensionMediaType(path), options);
+    return bytes(data, fileMediaType(data, path), options);
 });
 /** Materialize an asset and write its bytes through `FileSystem`. */
 export const write = (asset, path) => Effect.gen(function* () {

package/dist/promise.d.ts

@@ -1,40 +1,53 @@
 import { Effect, Layer } from "effect";
-import type { AwaitOptions, Snapshot } from "./generation.js";
-import { ImageModel, ImageRequest, type ImageOptions, type ImageRequestInput } from "./image.js";
-import { ImageClient } from "./image-client.js";
-import { LLMClient } from "./route/client.js";
+import { AIClient } from "./ai-client.js";
+import type { AwaitOptions, Event, Snapshot } from "./generation.js";
+import { type ImageModel, type ImageRequest, type ImageRequestInput } from "./image.js";
+import { Media } from "./media.js";
 import { RequestExecutor } from "./route/executor.js";
 import { LanguageModel, LLMRequest } from "./schema/index.js";
 import type { RequestInput } from "./llm.js";
-import { SpeechModel, SpeechRequest, type SpeechRequestInput } from "./speech.js";
-import { SpeechClient } from "./speech-client.js";
-import { TranscriptionModel, TranscriptionRequest, type TranscriptionOptions, type TranscriptionRequestInput } from "./transcription.js";
-import { TranscriptionClient } from "./transcription-client.js";
-import { VideoModel, VideoRequest, type VideoOptions, type VideoRequestInput } from "./video.js";
-import { VideoClient } from "./video-client.js";
+import { type SpeechModel, type SpeechRequest, type SpeechRequestInput } from "./speech.js";
+import { type TranscriptionModel, type TranscriptionRequest, type TranscriptionRequestInput } from "./transcription.js";
+import { type VideoModel, type VideoRequest, type VideoRequestInput } from "./video.js";
 /**
  * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM, image, video, speech,
  * and transcription clients over a request executor; every method runs the corresponding Effect API and rethrows
- * `AIError` unchanged.
+ * `AIError` unchanged. `file` and `write` load `node:fs/promises` on first use, so importing this module does not.
  */
 export interface Options {
-    /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or middleware here. */
+    /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or `RequestExecutor.middleware(fn)` here. */
     readonly layer?: Layer.Layer<RequestExecutor.Service>;
 }
 export interface RunOptions {
     readonly signal?: AbortSignal;
 }
-export type Services = Layer.Success<typeof LLMClient.layer> | Layer.Success<typeof ImageClient.layer> | Layer.Success<typeof VideoClient.layer> | Layer.Success<typeof SpeechClient.layer> | Layer.Success<typeof TranscriptionClient.layer> | RequestExecutor.Service;
-/** Promise view of a `Generation`: its snapshot plus `await`, `refresh`, and `cancel` returning promises. */
+export type Services = AIClient.Services;
+/**
+ * Promise view of a `Generation`. Its fields are a snapshot taken when the handle was created; `refresh()` resolves to a
+ * new handle rather than updating this one.
+ */
 export type GenerationHandle<Response> = Snapshot & {
     /** Serializable JSON; pass it back to `resume` from another process. */
     readonly token: unknown;
     readonly await: (options?: AwaitOptions & RunOptions) => Promise<Response>;
+    /** Status observations until the first terminal one, polling like `await`; abort ends iteration without throwing. */
+    readonly events: (options?: AwaitOptions & RunOptions) => AsyncIterable<Event>;
+    /** The result without polling; fails when the generation has not completed. */
+    readonly result: (options?: RunOptions) => Promise<Response>;
     readonly refresh: (options?: RunOptions) => Promise<GenerationHandle<Response>>;
     readonly cancel: (options?: RunOptions) => Promise<void>;
 };
 export declare const make: (options?: Options) => {
     run: <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) => Promise<A>;
+    /** Decoded asset bytes, downloading `url` sources through the executor. */
+    bytes: (asset: Media.Asset, options?: RunOptions) => Promise<Uint8Array<ArrayBufferLike>>;
+    base64: (asset: Media.Asset, options?: RunOptions) => Promise<string>;
+    /** Pull a `url` asset into owned bytes before the provider URL expires. */
+    materialize: (asset: Media.Asset, options?: RunOptions) => Promise<Media.Asset>;
+    /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
+    file: (path: string, options?: Media.AssetOptions & RunOptions) => Promise<Media.Asset>;
+    /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
+    write: (asset: Media.Asset, path: string, options?: RunOptions) => Promise<void>;
     llm: {
         request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
         generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
@@ -209,7 +222,7 @@ export declare const make: (options?: Options) => {
             readonly namespace?: string | undefined;
         } | {
             readonly type: "media";
-            readonly media: import("./media.js").Asset;
+            readonly media: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -265,11 +278,11 @@ export declare const make: (options?: Options) => {
         } | {
             readonly type: "image-partial";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.Asset;
         } | {
             readonly type: "image";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.Asset;
         } | {
             readonly type: "finish";
             readonly providerMetadata?: {
@@ -309,13 +322,13 @@ export declare const make: (options?: Options) => {
             }[] | undefined;
         }>;
         start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
-        resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: (model: ImageModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
     };
     video: {
         request: typeof import("./video.js").request;
         start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
         generate: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => Promise<import("./video.js").VideoResponse>;
-        resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        resume: (model: VideoModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
         stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
             readonly id: string;
             readonly type: "generation-queued";
@@ -327,7 +340,7 @@ export declare const make: (options?: Options) => {
         } | {
             readonly type: "video";
             readonly index: number;
-            readonly video: import("./media.js").Asset;
+            readonly video: Media.Asset;
         } | {
             readonly type: "finish";
             readonly providerMetadata?: {
@@ -371,6 +384,14 @@ export declare const make: (options?: Options) => {
         request: typeof import("./speech.js").request;
         generate: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => Promise<import("./speech.js").SpeechResponse>;
         stream: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
             readonly type: "audio-delta";
             readonly chunk: Uint8Array<ArrayBufferLike>;
         } | {
@@ -382,7 +403,7 @@ export declare const make: (options?: Options) => {
             }[];
         } | {
             readonly type: "finish";
-            readonly audio: import("./media.js").Asset;
+            readonly audio: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -497,7 +518,7 @@ export declare const make: (options?: Options) => {
             }[] | undefined;
         }>;
         start: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
-        resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+        resume: (model: TranscriptionModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
     };
     dispose: () => Promise<void>;
 };
@@ -505,6 +526,15 @@ export type Client = ReturnType<typeof make>;
 /** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
 export declare const ai: {
     run: <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) => Promise<A>;
+    /** Decoded asset bytes, downloading `url` sources through the executor. */
+    bytes: (asset: Media.Asset, options?: RunOptions) => Promise<Uint8Array<ArrayBufferLike>>;
+    base64: (asset: Media.Asset, options?: RunOptions) => Promise<string>;
+    /** Pull a `url` asset into owned bytes before the provider URL expires. */
+    materialize: (asset: Media.Asset, options?: RunOptions) => Promise<Media.Asset>;
+    /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
+    file: (path: string, options?: Media.AssetOptions & RunOptions) => Promise<Media.Asset>;
+    /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
+    write: (asset: Media.Asset, path: string, options?: RunOptions) => Promise<void>;
     llm: {
         request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
         generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
@@ -679,7 +709,7 @@ export declare const ai: {
             readonly namespace?: string | undefined;
         } | {
             readonly type: "media";
-            readonly media: import("./media.js").Asset;
+            readonly media: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -735,11 +765,11 @@ export declare const ai: {
         } | {
             readonly type: "image-partial";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.Asset;
         } | {
             readonly type: "image";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.Asset;
         } | {
             readonly type: "finish";
             readonly providerMetadata?: {
@@ -779,13 +809,13 @@ export declare const ai: {
             }[] | undefined;
         }>;
         start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
-        resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: (model: ImageModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
     };
     video: {
         request: typeof import("./video.js").request;
         start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
         generate: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => Promise<import("./video.js").VideoResponse>;
-        resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        resume: (model: VideoModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
         stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
             readonly id: string;
             readonly type: "generation-queued";
@@ -797,7 +827,7 @@ export declare const ai: {
         } | {
             readonly type: "video";
             readonly index: number;
-            readonly video: import("./media.js").Asset;
+            readonly video: Media.Asset;
         } | {
             readonly type: "finish";
             readonly providerMetadata?: {
@@ -841,6 +871,14 @@ export declare const ai: {
         request: typeof import("./speech.js").request;
         generate: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => Promise<import("./speech.js").SpeechResponse>;
         stream: <const Model extends SpeechModel>(input: SpeechRequestInput<Model> | SpeechRequest, options?: RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
             readonly type: "audio-delta";
             readonly chunk: Uint8Array<ArrayBufferLike>;
         } | {
@@ -852,7 +890,7 @@ export declare const ai: {
             }[];
         } | {
             readonly type: "finish";
-            readonly audio: import("./media.js").Asset;
+            readonly audio: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -967,7 +1005,7 @@ export declare const ai: {
             }[] | undefined;
         }>;
         start: <const Model extends TranscriptionModel>(input: TranscriptionRequestInput<Model> | TranscriptionRequest, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
-        resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
+        resume: (model: TranscriptionModel, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./transcription.js").TranscriptionResponse>>;
     };
     dispose: () => Promise<void>;
 };

package/dist/promise.js

@@ -1,16 +1,15 @@
 import { Effect, Layer, ManagedRuntime, Stream } from "effect";
-import { Image, ImageModel, ImageRequest } from "./image.js";
-import { ImageClient } from "./image-client.js";
+import { AIClient } from "./ai-client.js";
+import { Image } from "./image.js";
 import { LLM } from "./index.js";
-import { LLMClient } from "./route/client.js";
+import { Media } from "./media.js";
+import { tryRequest } from "./media-model.js";
 import { RequestExecutor } from "./route/executor.js";
-import { LanguageModel, LLMRequest } from "./schema/index.js";
-import { Speech, SpeechModel, SpeechRequest } from "./speech.js";
-import { SpeechClient } from "./speech-client.js";
-import { Transcription, TranscriptionModel, TranscriptionRequest, } from "./transcription.js";
-import { TranscriptionClient } from "./transcription-client.js";
-import { Video, VideoModel, VideoRequest } from "./video.js";
-import { VideoClient } from "./video-client.js";
+import { AIError, InvalidRequestError, LanguageModel, LLMRequest } from "./schema/index.js";
+import { Speech } from "./speech.js";
+import { Transcription, } from "./transcription.js";
+import { fileMediaType } from "./utils/media-type.js";
+import { Video } from "./video.js";
 const abortEffect = (signal) => signal === undefined
     ? Effect.never
     : Effect.callback((resume) => {
@@ -23,59 +22,81 @@ const abortEffect = (signal) => signal === undefined
         return Effect.sync(() => signal.removeEventListener("abort", onAbort));
     });
 export const make = (options = {}) => {
-    const runtime = ManagedRuntime.make(Layer.mergeAll(LLMClient.layer, ImageClient.layer, VideoClient.layer, SpeechClient.layer, TranscriptionClient.layer).pipe(Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer)));
-    /** Run any package Effect (for example `asset.bytes()`) inside this runtime. */
+    const runtime = ManagedRuntime.make(AIClient.layerWith(options.layer ?? RequestExecutor.fetchLayer));
+    /** Run any package Effect (for example `LLMClient.compact(...)`) inside this runtime. */
     const run = (effect, options) => runtime.runPromise(effect, { signal: options?.signal });
     const iterate = (stream, options) => Stream.toAsyncIterable(Stream.unwrap(runtime.contextEffect.pipe(Effect.map((context) => stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context))))));
     const handle = (generation) => ({
         ...generation.snapshot,
         token: generation.token,
         await: (options) => run(generation.await({ poll: options?.poll }), options),
+        events: (options) => iterate(generation.events({ poll: options?.poll }), options),
+        result: (options) => run(generation.result(), options),
         refresh: (options) => run(generation.refresh(), options).then(handle),
         cancel: (options) => run(generation.cancel(), options),
     });
-    // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
-    const llmRequest = (input) => (input instanceof LLMRequest ? input : LLM.request(input));
-    const imageRequest = (input) => input instanceof ImageRequest ? input : Image.request(input);
-    const videoRequest = (input) => input instanceof VideoRequest ? input : Video.request(input);
-    const speechRequest = (input) => input instanceof SpeechRequest ? input : Speech.request(input);
-    const transcriptionRequest = (input) => input instanceof TranscriptionRequest ? input : Transcription.request(input);
+    const llmRequest = (input) => input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => LLM.request(input));
     return {
         run,
+        /** Decoded asset bytes, downloading `url` sources through the executor. */
+        bytes: (asset, options) => run(asset.bytes(), options),
+        base64: (asset, options) => run(asset.base64(), options),
+        /** Pull a `url` asset into owned bytes before the provider URL expires. */
+        materialize: (asset, options) => run(asset.materialize(), options),
+        /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
+        file: async (path, options) => {
+            const { readFile } = await import("node:fs/promises");
+            return run(Effect.tryPromise({
+                try: (signal) => readFile(path, { signal }),
+                catch: (cause) => fileError(`Failed to read media file ${path}`, cause),
+            }).pipe(Effect.map((buffer) => {
+                const data = new Uint8Array(buffer);
+                return Media.bytes(data, fileMediaType(data, path), options);
+            })), options);
+        },
+        /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
+        write: async (asset, path, options) => {
+            const { writeFile } = await import("node:fs/promises");
+            return run(asset.bytes().pipe(Effect.flatMap((data) => Effect.tryPromise({
+                try: (signal) => writeFile(path, data, { signal }),
+                catch: (cause) => fileError(`Failed to write media file ${path}`, cause),
+            }))), options);
+        },
         llm: {
             request: LLM.request,
-            generate: (input, options) => run(LLM.generate(llmRequest(input)), options),
-            stream: (input, options) => iterate(LLM.stream(llmRequest(input)), options),
+            generate: (input, options) => run(Effect.flatMap(llmRequest(input), LLM.generate), options),
+            stream: (input, options) => iterate(Stream.unwrap(Effect.map(llmRequest(input), LLM.stream)), options),
         },
         image: {
             request: Image.request,
-            generate: (input, options) => run(Image.generate(imageRequest(input), { poll: options?.poll }), options),
-            stream: (input, options) => iterate(Image.stream(imageRequest(input), { poll: options?.poll }), options),
-            start: (input, options) => run(Image.start(imageRequest(input)), options).then(handle),
+            generate: (input, options) => run(Image.generate(input, { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Image.stream(input, { poll: options?.poll }), options),
+            start: (input, options) => run(Image.start(input), options).then(handle),
             resume: (model, token, options) => run(Image.resume(model, token), options).then(handle),
         },
         video: {
             request: Video.request,
-            start: (input, options) => run(Video.start(videoRequest(input)), options).then(handle),
-            generate: (input, options) => run(Video.generate(videoRequest(input), { poll: options?.poll }), options),
+            start: (input, options) => run(Video.start(input), options).then(handle),
+            generate: (input, options) => run(Video.generate(input, { poll: options?.poll }), options),
             resume: (model, token, options) => run(Video.resume(model, token), options).then(handle),
-            stream: (input, options) => iterate(Video.stream(videoRequest(input), { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Video.stream(input, { poll: options?.poll }), options),
         },
         speech: {
             request: Speech.request,
-            generate: (input, options) => run(Speech.generate(speechRequest(input)), options),
-            stream: (input, options) => iterate(Speech.stream(speechRequest(input)), options),
+            generate: (input, options) => run(Speech.generate(input), options),
+            stream: (input, options) => iterate(Speech.stream(input), options),
         },
         transcription: {
             request: Transcription.request,
-            generate: (input, options) => run(Transcription.generate(transcriptionRequest(input), { poll: options?.poll }), options),
-            stream: (input, options) => iterate(Transcription.stream(transcriptionRequest(input), { poll: options?.poll }), options),
-            start: (input, options) => run(Transcription.start(transcriptionRequest(input)), options).then(handle),
+            generate: (input, options) => run(Transcription.generate(input, { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Transcription.stream(input, { poll: options?.poll }), options),
+            start: (input, options) => run(Transcription.start(input), options).then(handle),
             resume: (model, token, options) => run(Transcription.resume(model, token), options).then(handle),
         },
         dispose: () => runtime.dispose(),
     };
 };
+const fileError = (message, cause) => new AIError({ reason: new InvalidRequestError({ message, cause }) });
 /** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
 export const ai = make();
 export * as AI from "./promise.js";

package/dist/protocols/alibaba-chat.js

@@ -55,7 +55,10 @@ export const protocol = Protocol.make({
             return {
                 ...(yield* OpenAIChat.protocol.body.from(req)),
                 enable_thinking: opts.enableThinking,
-                thinking_budget: opts.thinkingBudget,
+                // Alibaba also rejects an explicit budget that is not below `max_completion_tokens`.
+                thinking_budget: opts.thinkingBudget === undefined
+                    ? undefined
+                    : ProviderShared.fitThinkingBudget(opts.thinkingBudget, req.generation?.maxTokens),
                 preserve_thinking: opts.preserveThinking,
                 clear_thinking: opts.clearThinking,
                 thinking: opts.thinking,

package/dist/protocols/alibaba-messages.d.ts

@@ -228,7 +228,7 @@ export declare const protocol: Protocol<{
         readonly type: string;
         readonly budget_tokens?: number | undefined;
     } | undefined;
-    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
+    readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "standard_only"> | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/protocols/alibaba-messages.js

@@ -22,15 +22,17 @@ export const protocol = Protocol.make({
         from: Effect.fn("AlibabaMessages.fromRequest")(function* (req) {
             const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {});
             // Model Studio accepts enabled thinking without Anthropic's mandatory token budget.
+            const body = yield* AnthropicMessages.protocol.body.from(LLMRequest.update(req, {
+                providerOptions: { ...req.providerOptions, thinking: undefined },
+            }));
+            const budget = opts.thinking?.budgetTokens ?? opts.thinking?.budget_tokens;
             return {
-                ...(yield* AnthropicMessages.protocol.body.from(LLMRequest.update(req, {
-                    providerOptions: { ...req.providerOptions, thinking: undefined },
-                }))),
+                ...body,
                 thinking: opts.thinking === undefined
                     ? undefined
                     : {
                         type: opts.thinking.type,
-                        budget_tokens: opts.thinking.budgetTokens ?? opts.thinking.budget_tokens,
+                        budget_tokens: budget === undefined ? undefined : ProviderShared.fitThinkingBudget(budget, body.max_tokens),
                     },
             };
         }),