@opencode/ai 2.0.16 → 2.0.17

package/dist/experimental/evaluation-client.d.ts

@@ -11,11 +11,11 @@ export declare class Service extends Service_base {
 }
 export declare const evaluate: <Options extends EvaluationOptions, const Questions extends EvaluationQuestions>(request: EvaluationRequestFor<Options, Questions>) => Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
-export declare const fetchLayer: Layer.Layer<Service, never, never>;
+export declare const fetchLayer: Layer.Layer<import("../route/executor-service.js").RequestExecutorService | Service, never, never>;
 export declare const EvaluationClient: {
     readonly Service: typeof Service;
-    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
-    readonly fetchLayer: Layer.Layer<Service, never, never>;
+    readonly layer: Layer.Layer<Service, never, import("../route/executor-service.js").RequestExecutorService>;
+    readonly fetchLayer: Layer.Layer<import("../route/executor-service.js").RequestExecutorService | Service, never, never>;
     readonly evaluate: <Options extends EvaluationOptions, const Questions extends EvaluationQuestions>(request: EvaluationRequestFor<Options, Questions>) => Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
 };
 export {};

package/dist/experimental/evaluation-client.js

@@ -55,7 +55,7 @@ export const layer = Layer.effect(Service, Effect.gen(function* () {
         })),
     });
 }));
-export const fetchLayer = layer.pipe(Layer.provide(RequestExecutor.fetchLayer));
+export const fetchLayer = layer.pipe(Layer.provideMerge(RequestExecutor.fetchLayer));
 export const EvaluationClient = {
     Service,
     layer,

package/dist/experimental/evaluation.js

@@ -94,7 +94,7 @@ export function request(input) {
     return new EvaluationRequest({
         ...input,
         model: input.model,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
 }
 export function run(input) {

package/dist/generation.d.ts

@@ -1,4 +1,4 @@
-import { Duration, Effect, Schedule, Schema, Stream } from "effect";
+import { Duration, Effect, Schema, Stream } from "effect";
 import { AIError } from "./schema/errors.js";
 export declare const Status: Schema.Literals<readonly ["queued", "running", "completed", "failed", "cancelled", "expired"]>;
 export type Status = Schema.Schema.Type<typeof Status>;
@@ -9,7 +9,6 @@ export interface Snapshot {
     /** Normalized 0..1 when the provider reports progress. */
     readonly progress?: number;
     readonly position?: number;
-    readonly expiresAt?: number;
 }
 /**
  * Route-owned generation operations for one generation. The media route decodes its serializable token once (from the
@@ -19,14 +18,10 @@ export interface Route<Response> {
     readonly status: Effect.Effect<Snapshot, AIError>;
     readonly result: Effect.Effect<Response, AIError>;
     readonly cancel?: Effect.Effect<void, AIError>;
-    /** Provider polling hint (e.g. `openai-poll-after-ms`) that overrides the default interval for the next poll. */
-    readonly pollHint?: (snapshot: Snapshot) => Duration.Duration | undefined;
 }
 export interface Poll {
     readonly interval?: Duration.Input;
     readonly timeout?: Duration.Input;
-    /** Full override of the polling schedule; `interval` and `pollHint` are ignored when supplied. */
-    readonly schedule?: Schedule.Schedule<unknown, Snapshot>;
 }
 export interface AwaitOptions {
     readonly poll?: Poll;
@@ -49,6 +44,7 @@ export type Event = Observation | {
     readonly id: string;
     readonly status: Status;
 };
+export declare const isTerminal: (status: Status) => boolean;
 export declare class Generation<Response> {
     readonly route: Route<Response>;
     /** Route-owned serializable JSON; pass it to the modality's `resume` from another process. */
@@ -57,7 +53,6 @@ export declare class Generation<Response> {
     readonly status: Status;
     readonly progress?: number;
     readonly position?: number;
-    readonly expiresAt?: number;
     constructor(route: Route<Response>, 
     /** Route-owned serializable JSON; pass it to the modality's `resume` from another process. */
     token: unknown, snapshot: Snapshot);
@@ -70,9 +65,10 @@ export declare class Generation<Response> {
     await(options?: AwaitOptions): Effect.Effect<Response, AIError>;
     cancel(): Effect.Effect<void, AIError>;
     /**
-     * Status observations as a stream, ending after the first terminal observation. Each poll is bounded by the time
-     * remaining until `poll.timeout`, so a hung status request fails the stream instead of stalling it. (`Stream.interruptWhen`
-     * would express this directly but deadlocks under `TestClock` when the source completes while the timer sleeps.)
+     * Status observations as a stream, ending after the first terminal observation. Each poll and each sleep between polls
+     * is bounded by the time remaining until `poll.timeout`, so a hung status request or a long interval fails the stream at
+     * the deadline instead of stalling it. (`Stream.interruptWhen` would express this directly but deadlocks under
+     * `TestClock` when the source completes while the timer sleeps.)
      */
     events(options?: AwaitOptions): Stream.Stream<Event, AIError>;
     private event;

package/dist/generation.js

@@ -14,6 +14,7 @@ export const ProgressEvent = Schema.Struct({
     progress: Schema.optional(Schema.Number),
 }).annotate({ identifier: "Generation.Event.Progress" });
 const TERMINAL = new Set(["completed", "failed", "cancelled", "expired"]);
+export const isTerminal = (status) => TERMINAL.has(status);
 export class Generation {
     route;
     token;
@@ -21,7 +22,6 @@ export class Generation {
     status;
     progress;
     position;
-    expiresAt;
     constructor(route, 
     /** Route-owned serializable JSON; pass it to the modality's `resume` from another process. */
     token, snapshot) {
@@ -31,7 +31,6 @@ export class Generation {
         this.status = snapshot.status;
         this.progress = snapshot.progress;
         this.position = snapshot.position;
-        this.expiresAt = snapshot.expiresAt;
     }
     get snapshot() {
         return {
@@ -39,11 +38,10 @@ export class Generation {
             status: this.status,
             progress: this.progress,
             position: this.position,
-            expiresAt: this.expiresAt,
         };
     }
     get terminal() {
-        return TERMINAL.has(this.status);
+        return isTerminal(this.status);
     }
     refresh() {
         return this.route.status.pipe(Effect.map((snapshot) => new Generation(this.route, this.token, snapshot)));
@@ -64,9 +62,10 @@ export class Generation {
         return this.route.cancel ?? Effect.void;
     }
     /**
-     * Status observations as a stream, ending after the first terminal observation. Each poll is bounded by the time
-     * remaining until `poll.timeout`, so a hung status request fails the stream instead of stalling it. (`Stream.interruptWhen`
-     * would express this directly but deadlocks under `TestClock` when the source completes while the timer sleeps.)
+     * Status observations as a stream, ending after the first terminal observation. Each poll and each sleep between polls
+     * is bounded by the time remaining until `poll.timeout`, so a hung status request or a long interval fails the stream at
+     * the deadline instead of stalling it. (`Stream.interruptWhen` would express this directly but deadlocks under
+     * `TestClock` when the source completes while the timer sleeps.)
      */
     events(options) {
         if (this.terminal)
@@ -74,11 +73,16 @@ export class Generation {
         const timeout = Duration.fromInputUnsafe(options?.poll?.timeout ?? DEFAULT_POLL_TIMEOUT);
         return Stream.unwrap(Clock.currentTimeMillis.pipe(Effect.map((start) => {
             const deadline = start + Duration.toMillis(timeout);
-            const refresh = Clock.currentTimeMillis.pipe(Effect.flatMap((now) => this.refresh().pipe(Effect.timeoutOrElse({
-                duration: Duration.millis(Math.max(0, deadline - now)),
-                orElse: () => this.timeoutError(timeout),
-            }))));
-            return Stream.fromEffectSchedule(refresh, this.schedule(options?.poll)).pipe(Stream.takeUntil((generation) => generation.terminal), Stream.map((generation) => generation.event()));
+            // Fail before polling once the deadline has passed: a fast status request could otherwise win the zero-budget
+            // race and schedule another zero-delay poll.
+            const refresh = Clock.currentTimeMillis.pipe(Effect.flatMap((now) => now >= deadline
+                ? this.timeoutError(timeout)
+                : this.refresh().pipe(Effect.timeoutOrElse({
+                    duration: Duration.millis(deadline - now),
+                    orElse: () => this.timeoutError(timeout),
+                }))));
+            const schedule = this.schedule(options?.poll).pipe(Schedule.modifyDelay((meta) => Effect.succeed(Duration.min(meta.duration, Duration.millis(Math.max(0, deadline - meta.now))))));
+            return Stream.fromEffectSchedule(refresh, schedule).pipe(Stream.takeUntil((generation) => generation.terminal), Stream.map((generation) => generation.event()));
         })));
     }
     event() {
@@ -100,14 +104,7 @@ export class Generation {
         return this.refresh().pipe(Effect.repeat({ schedule: this.schedule(poll), until: (generation) => generation.terminal }));
     }
     schedule(poll) {
-        if (poll?.schedule)
-            return poll.schedule.pipe(Schedule.setInputType());
-        const interval = poll?.interval ?? DEFAULT_POLL_INTERVAL;
-        const pollHint = this.route.pollHint;
-        const spaced = Schedule.spaced(interval).pipe(Schedule.setInputType());
-        if (!pollHint)
-            return spaced;
-        return spaced.pipe(Schedule.modifyDelay((metadata) => Effect.succeed(pollHint(metadata.input.snapshot) ?? interval)));
+        return Schedule.spaced(poll?.interval ?? DEFAULT_POLL_INTERVAL);
     }
 }
 export const resultEvents = (generation, expand, options) => generation.events(options).pipe(Stream.filter((event) => event.type !== "generation-finished"), Stream.concat(Stream.fromIterableEffect(Effect.map(generation.result(), expand))));

package/dist/image-client.d.ts

@@ -1,28 +1,63 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import type { AwaitOptions, Generation } from "./generation.js";
-import { RequestExecutor } from "./route/executor.js";
-import type { AIError } from "./schema/index.js";
-import { type ImageEvent, type ImageModel, type ImageOptions, type ImageRequestFor, type ImageResponse } from "./image.js";
-export interface Interface {
-    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<ImageResponse, AIError>;
-    readonly stream: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<ImageEvent, AIError>;
-    readonly start: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<Generation<ImageResponse>, AIError>;
-    readonly resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError>;
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { type ImageEvent, type ImageRequestFor, type ImageResponse } from "./image.js";
+export type Interface = MediaClient.Interface<ImageRequestFor, ImageEvent, ImageResponse>;
+declare const ImageClientService_base: Context.ServiceClass<ImageClientService, "@opencode/ImageClient", Interface>;
+export declare class ImageClientService extends ImageClientService_base {
 }
-declare const Service_base: Context.ServiceClass<Service, "@opencode/ImageClient", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<ImageResponse, AIError, Service>;
-export declare const stream: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<ImageEvent, AIError, Service>;
-export declare const start: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-export declare const resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+export declare const Service: typeof ImageClientService;
+export type Service = ImageClientService;
 export declare const ImageClient: {
-    readonly Service: typeof Service;
-    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
-    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<ImageResponse, AIError, Service>;
-    readonly stream: <Options extends ImageOptions>(request: ImageRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<ImageEvent, AIError, Service>;
-    readonly start: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-    readonly resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
+    readonly layer: import("effect/Layer").Layer<ImageClientService, never, import("./route/executor-service.js").RequestExecutorService>;
+    readonly generate: (request: ImageRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<ImageResponse, import("./index.js").AIError, ImageClientService>;
+    readonly stream: (request: ImageRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+        readonly type: "image-partial";
+        readonly index: number;
+        readonly image: import("./media.js").Asset;
+    } | {
+        readonly type: "image";
+        readonly index: number;
+        readonly image: import("./media.js").Asset;
+    } | {
+        readonly type: "finish";
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly usage?: {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "seconds";
+            readonly seconds: number;
+        } | {
+            readonly type: "characters";
+            readonly characters: number;
+        } | {
+            readonly type: "credits";
+            readonly credits: number;
+        } | {
+            readonly type: "compute";
+            readonly seconds: number;
+        } | undefined;
+        readonly notices?: readonly {
+            readonly type: "other" | "moderated" | "filtered";
+            readonly message: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }[] | undefined;
+    }, import("./index.js").AIError, ImageClientService>;
+    readonly start: (request: ImageRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<ImageResponse>, import("./index.js").AIError, ImageClientService>;
+    readonly resume: (model: import("./image.js").ImageModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<ImageResponse>, import("./index.js").AIError, ImageClientService>;
+    readonly Service: typeof ImageClientService;
 };
 export {};

package/dist/image-client.js

@@ -1,44 +1,20 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { RequestExecutor } from "./route/executor.js";
-import { MediaRoute } from "./route/media.js";
-import { responseEvents, } from "./image.js";
-export class Service extends Context.Service()("@opencode/ImageClient") {
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { ImageOutputEvent, ImageFinishEvent, } from "./image.js";
+export class ImageClientService extends Context.Service()("@opencode/ImageClient") {
 }
-export const generate = (request, options) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.generate(request, options);
-});
-export const stream = (request, options) => Stream.unwrap(Effect.gen(function* () {
-    const client = yield* Service;
-    return client.stream(request, options);
-}));
-export const start = (request) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.start(request);
-});
-export const resume = (model, token) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.resume(model, token);
-});
-export const layer = Layer.effect(Service, Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service;
-    const dispatch = MediaRoute.dispatch({
-        modality: "image",
-        execute: executor.execute,
-        responseEvents,
-    });
-    return Service.of({
-        start: (request) => dispatch.start(request.model.route, request),
-        resume: (model, token) => dispatch.resume(model.route, model, token),
-        generate: (request, options) => dispatch.generate(request.model.route, request, options),
-        stream: (request, options) => dispatch.stream(request.model.route, request, options),
-    });
-}));
+export const Service = ImageClientService;
 export const ImageClient = {
     Service,
-    layer,
-    generate,
-    stream,
-    start,
-    resume,
+    ...MediaClient.make(Service, {
+        modality: "image",
+        responseEvents: (response) => [
+            ...response.images.map((image, index) => ImageOutputEvent.make({ index, image })),
+            ImageFinishEvent.make({
+                usage: response.usage,
+                notices: response.notices,
+                providerMetadata: response.providerMetadata,
+            }),
+        ],
+    }),
 };

package/dist/image.d.ts

@@ -3,33 +3,25 @@ import { Generation, type AwaitOptions } from "./generation.js";
 import { Media } from "./media.js";
 import { MediaModel } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
-import type { MediaProtocol } from "./route/media-protocol.js";
-import { AIError, HttpOptions } from "./schema/index.js";
+import { AIError, HttpOptions, type OpenString } from "./schema/index.js";
 import { Service } from "./image-client.js";
-export type ImageOptions = Record<string, unknown>;
-export type ImageRoute<Options extends ImageOptions = ImageOptions> = MediaRoute.AnyRoute<ImageRequestFor<Options>, ImageEvent, ImageResponse>;
-export declare class ImageModel<Options extends ImageOptions = ImageOptions> extends MediaModel<ImageRoute<Options>, Options> {
+export type ImageOptions = MediaModel.Options;
+export type ImageRoute = MediaRoute.AnyRoute<ImageRequestFor, ImageEvent, ImageResponse>;
+export declare class ImageModel<Options extends ImageOptions = ImageOptions> extends MediaModel<ImageRoute, Options> {
     protected readonly _ImageModel: void;
-    static make<Options extends ImageOptions = ImageOptions>(input: MediaModel.Input<ImageRoute<Options>>): ImageModel<Options>;
     /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
-    static fromRoute<Options extends ImageOptions>(route: ImageModel.InlineRouteInput<Options>, input: MediaRoute.ModelInput): ImageModel<Options>;
-    static fromRoute<Options extends ImageOptions, Frame, State>(route: ImageModel.StreamRouteInput<Options, Frame, State>, input: MediaRoute.ModelInput): ImageModel<Options>;
-    static fromRoute<Options extends ImageOptions, Token>(route: ImageModel.QueuedRouteInput<Options, Token>, input: MediaRoute.ModelInput): ImageModel<Options>;
+    static fromRoute<Options extends ImageOptions>(route: MediaModel.InlineRouteInput<ImageRequestFor<Options>, ImageResponse>, input: MediaRoute.ModelInput): ImageModel<Options>;
+    static fromRoute<Options extends ImageOptions, Frame, State>(route: MediaModel.StreamRouteInput<ImageRequestFor<Options>, ImageEvent, Frame, State>, input: MediaRoute.ModelInput): ImageModel<Options>;
+    static fromRoute<Options extends ImageOptions, Token>(route: MediaModel.QueuedRouteInput<ImageRequestFor<Options>, ImageResponse, Token>, input: MediaRoute.ModelInput): ImageModel<Options>;
 }
-export declare namespace ImageModel {
-    type InlineRouteInput<Options extends ImageOptions = ImageOptions> = MediaModel.RouteInput<ImageRequestFor<Options>, MediaProtocol.Inline<ImageRequestFor<Options>, ImageResponse>>;
-    type StreamRouteInput<Options extends ImageOptions = ImageOptions, Frame = unknown, State = unknown> = MediaModel.RouteInput<MediaProtocol.Addressed<ImageRequestFor<Options>>, MediaProtocol.Streamed<ImageRequestFor<Options>, ImageEvent, Frame, State>>;
-    type QueuedRouteInput<Options extends ImageOptions = ImageOptions, Token = unknown> = MediaModel.RouteInput<ImageRequestFor<Options>, MediaProtocol.Queued<ImageRequestFor<Options>, ImageResponse, Token>>;
-    type RouteInput<Options extends ImageOptions = ImageOptions, Frame = unknown, State = unknown, Token = unknown> = MediaModel.AnyRouteInput<ImageRequestFor<Options>, ImageEvent, ImageResponse, Frame, State, Token>;
-}
-export declare const ImageModelSchema: Schema.declare<ImageModel<ImageOptions>, ImageModel<ImageOptions>>;
+export declare const ImageModelSchema: Schema.declare<ImageModel<MediaModel.Options>, ImageModel<MediaModel.Options>>;
 export type ImageSize = `${number}x${number}`;
 export declare const ImageSize: Schema.declare<`${number}x${number}`, `${number}x${number}`>;
 export type ImageAspectRatio = Media.AspectRatio;
 export declare const ImageAspectRatio: Schema.declare<`${number}:${number}`, `${number}:${number}`>;
-export type ImageFormat = "png" | "jpeg" | "webp" | (string & {});
+export type ImageFormat = OpenString<"png" | "jpeg" | "webp">;
 declare const ImageRequest_base: Schema.Class<ImageRequest, Schema.Struct<{
-    readonly model: Schema.declare<ImageModel<ImageOptions>, ImageModel<ImageOptions>>;
+    readonly model: Schema.declare<ImageModel<MediaModel.Options>, ImageModel<MediaModel.Options>>;
     readonly prompt: Schema.String;
     /** Edit sources or style/subject references, in order. */
     readonly images: Schema.optional<Schema.$Array<Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{
@@ -1418,22 +1410,18 @@ export declare const ImageEvent: Schema.Union<readonly [Schema.Struct<{
     };
 };
 export type ImageEvent = Schema.Schema.Type<typeof imageEventTagged>;
-export declare const responseEvents: (response: ImageResponse) => ReadonlyArray<ImageEvent>;
 export declare function request<const Model extends ImageModel>(input: ImageRequestInput<Model>): ImageRequestFor<ImageModelOptions<Model>>;
 export declare function request(input: ImageRequest): ImageRequest;
-export declare function generate<const Model extends ImageModel>(input: ImageRequestInput<Model>, options?: AwaitOptions): Effect.Effect<ImageResponse, AIError, Service>;
-export declare function generate(input: ImageRequest, options?: AwaitOptions): Effect.Effect<ImageResponse, AIError, Service>;
-export declare function stream<const Model extends ImageModel>(input: ImageRequestInput<Model>, options?: AwaitOptions): Stream.Stream<ImageEvent, AIError, Service>;
-export declare function stream(input: ImageRequest, options?: AwaitOptions): Stream.Stream<ImageEvent, AIError, Service>;
+export declare function generate<const Model extends ImageModel>(input: ImageRequest | ImageRequestInput<Model>, options?: AwaitOptions): Effect.Effect<ImageResponse, AIError, Service>;
+export declare function stream<const Model extends ImageModel>(input: ImageRequest | ImageRequestInput<Model>, options?: AwaitOptions): Stream.Stream<ImageEvent, AIError, Service>;
 /** Inline and streaming routes fail with `UnsupportedOperation`. */
-export declare function start<const Model extends ImageModel>(input: ImageRequestInput<Model>): Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-export declare function start(input: ImageRequest): Effect.Effect<Generation<ImageResponse>, AIError, Service>;
-export declare const resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
+export declare function start<const Model extends ImageModel>(input: ImageRequest | ImageRequestInput<Model>): Effect.Effect<Generation<ImageResponse>, AIError, Service>;
+export declare const resume: (model: ImageModel, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
 export declare const Image: {
     readonly request: typeof request;
     readonly generate: typeof generate;
     readonly stream: typeof stream;
     readonly start: typeof start;
-    readonly resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
+    readonly resume: (model: ImageModel, token: unknown) => Effect.Effect<Generation<ImageResponse>, AIError, Service>;
 };
 export {};

package/dist/image.js

@@ -1,20 +1,17 @@
 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 { MediaModel, composeRoute, 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 extends MediaModel {
-    static make(input) {
-        return new ImageModel(input);
-    }
     static fromRoute(route, input) {
         return new ImageModel({
             id: input.id,
-            provider: route.provider,
+            provider: route.protocol.provider,
             http: input.http,
-            route: composeAnyRoute(route, input, collectResponse),
+            route: composeRoute(route, input, collectResponse),
         });
     }
 }
@@ -85,14 +82,6 @@ export const ImageEvent = Object.assign(imageEventTagged, {
         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.
@@ -110,7 +99,7 @@ export function request(input) {
         return input;
     return new ImageRequest({
         ...input,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
 }
 const requestEffect = (input) => tryRequest(() => request(input));

package/dist/index.d.ts

@@ -1,10 +1,11 @@
+export { AIClient } from "./ai-client.js";
 export { LLMClient } from "./route/client.js";
 export { ImageClient } from "./image-client.js";
 export { Auth } from "./route/auth.js";
 export { Provider } from "./provider.js";
 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 type { RouteLanguageModelInput, RouteRoutedLanguageModelInput, Interface as LLMClientShape, LLMClientService, } from "./route/client.js";
 export * from "./schema/index.js";
 export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";
 export type { ImageFormat, ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute, } from "./image.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+export { AIClient } from "./ai-client.js";
 export { LLMClient } from "./route/client.js";
 export { ImageClient } from "./image-client.js";
 export { Auth } from "./route/auth.js";

package/dist/llm.d.ts

@@ -1,6 +1,6 @@
-import { Effect, JsonSchema, Schema } from "effect";
-import { Service } from "./route/client.js";
-import { GenerationOptions, HttpOptions, AIError, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, type ContentPart, type LanguageModelProviderOptions, type ToolEntryInput } from "./schema/index.js";
+import { Effect, JsonSchema, Schema, Stream } from "effect";
+import { Service, type StreamOptions } from "./route/client.js";
+import { GenerationOptions, HttpOptions, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, type ContentPart, type LanguageModelProviderOptions, type ToolEntryInput } from "./schema/index.js";
 import { type ToolSchema } from "./tool.js";
 /** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
 export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<ConstructorParameters<typeof LLMRequest>[0], "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"> & {
@@ -14,8 +14,10 @@ export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageM
     readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>;
     readonly http?: HttpOptions.Input;
 };
-export declare const generate: typeof import("./route/client.js").generate;
-export declare const stream: typeof import("./route/client.js").stream;
+export declare function generate<const Model extends LanguageModel>(input: RequestInput<Model>, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>;
+export declare function generate(input: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>;
+export declare function stream<const Model extends LanguageModel>(input: RequestInput<Model>, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service>;
+export declare function stream(input: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service>;
 export declare const request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
 type GenerateObjectBase<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<RequestInput<SelectedLanguageModel>, "tools" | "toolChoice">;
 export declare class GenerateObjectResponse<T> {

package/dist/llm.js

@@ -1,9 +1,15 @@
-import { Effect, JsonSchema, Schema } from "effect";
+import { Effect, JsonSchema, Schema, Stream } from "effect";
+import { tryRequest } from "./media-model.js";
 import { LLMClient, Service } from "./route/client.js";
 import { GenerationOptions, HttpOptions, InvalidProviderOutputError, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolEntry, } from "./schema/index.js";
 import { make as makeTool, toDefinitions } from "./tool.js";
-export const generate = LLMClient.generate;
-export const stream = LLMClient.stream;
+export function generate(input, options) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => LLMClient.generate(request, options)));
+}
+export function stream(input, options) {
+    return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => LLMClient.stream(request, options))));
+}
+const requestEffect = (input) => input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => request(input));
 export const request = (input) => {
     const { system: requestSystem, prompt, messages, tools, toolChoice: requestToolChoice, generation: requestGeneration, providerOptions: requestProviderOptions, http: requestHttp, ...rest } = input;
     return new LLMRequest({
@@ -14,7 +20,7 @@ export const request = (input) => {
         toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
         generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
         providerOptions: requestProviderOptions,
-        http: requestHttp === undefined ? undefined : HttpOptions.make(requestHttp),
+        http: HttpOptions.make(requestHttp),
     });
 };
 const GENERATE_OBJECT_TOOL_NAME = "generate_object";

package/dist/media-client.d.ts

@@ -0,0 +1,30 @@
+import { type Context, Effect, Layer, Stream } from "effect";
+import { type AwaitOptions, type Generation, type Observation } from "./generation.js";
+import type { MediaRoute } from "./route/media.js";
+import { AIError } from "./schema/index.js";
+/** A media request whose model carries the route that executes it. */
+export interface RoutedRequest<Self extends MediaRoute.MediaRequest, Event, Response> extends MediaRoute.MediaRequest {
+    readonly model: MediaRoute.MediaRequest["model"] & {
+        readonly route: MediaRoute.AnyRoute<Self, Event, Response>;
+    };
+}
+/** `start` and `resume` fail with `UnsupportedOperation` on inline and stream routes. */
+export interface Interface<Req extends RoutedRequest<Req, Event, Response>, Event, Response> {
+    readonly generate: (request: Req, options?: AwaitOptions) => Effect.Effect<Response, AIError>;
+    readonly stream: (request: Req, options?: AwaitOptions) => Stream.Stream<Event | Observation, AIError>;
+    readonly start: (request: Req) => Effect.Effect<Generation<Response>, AIError>;
+    readonly resume: (model: Req["model"], token: unknown) => Effect.Effect<Generation<Response>, AIError>;
+}
+/** One modality's layer and service accessors, dispatching each request on its route's `kind`. */
+export declare const make: <Self, Req extends RoutedRequest<Req, Event, Response>, Event, Response>(service: Context.Service<Self, Interface<Req, Event, Response>>, input: {
+    readonly modality: string;
+    /** A completed response expanded into the streaming event shape. */
+    readonly responseEvents: (response: Response) => ReadonlyArray<Event>;
+}) => {
+    layer: Layer.Layer<Self, never, import("./route/executor-service.js").RequestExecutorService>;
+    generate: (request: Req, options?: AwaitOptions) => Effect.Effect<Response, AIError, Self>;
+    stream: (request: Req, options?: AwaitOptions) => Stream.Stream<Observation | Event, AIError, Exclude<Self, import("effect/Scope").Scope>>;
+    start: (request: Req) => Effect.Effect<Generation<Response>, AIError, Self>;
+    resume: (model: Req["model"], token: unknown) => Effect.Effect<Generation<Response>, AIError, Self>;
+};
+export * as MediaClient from "./media-client.js";

package/dist/media-client.js

@@ -0,0 +1,51 @@
+import { Effect, Layer, Stream } from "effect";
+import { resultEvents } from "./generation.js";
+import { RequestExecutor } from "./route/executor.js";
+import { AIError, UnsupportedOperationError } from "./schema/index.js";
+/** One modality's layer and service accessors, dispatching each request on its route's `kind`. */
+export const make = (service, input) => ({
+    layer: Layer.effect(service, Effect.gen(function* () {
+        const executor = yield* RequestExecutor.Service;
+        const notQueued = (route, operation) => new AIError({
+            reason: new UnsupportedOperationError({
+                operation: `${input.modality}.${operation}`,
+                provider: route.provider,
+                route: route.id,
+                message: `${route.provider}/${route.id} is not a queued route; use generate or stream`,
+            }),
+        });
+        const start = (request) => {
+            const route = request.model.route;
+            if (route.kind !== "queued")
+                return Effect.fail(notQueued(route, "start"));
+            return route.start(request, executor.execute);
+        };
+        return service.of({
+            start,
+            resume: (model, token) => {
+                if (model.route.kind !== "queued")
+                    return Effect.fail(notQueued(model.route, "resume"));
+                return model.route.resume(model, token, executor.execute);
+            },
+            generate: (request, options) => {
+                const route = request.model.route;
+                if (route.kind !== "queued")
+                    return route.generate(request, executor.execute);
+                return start(request).pipe(Effect.flatMap((generation) => generation.await(options)));
+            },
+            stream: (request, options) => {
+                const route = request.model.route;
+                if (route.kind === "stream")
+                    return route.stream(request, executor.execute);
+                if (route.kind === "queued")
+                    return Stream.unwrap(start(request).pipe(Effect.map((generation) => resultEvents(generation, input.responseEvents, options))));
+                return Stream.fromIterableEffect(Effect.map(route.generate(request, executor.execute), input.responseEvents));
+            },
+        });
+    })),
+    generate: (request, options) => service.use((client) => client.generate(request, options)),
+    stream: (request, options) => Stream.unwrap(service.useSync((client) => client.stream(request, options))),
+    start: (request) => service.use((client) => client.start(request)),
+    resume: (model, token) => service.use((client) => client.resume(model, token)),
+});
+export * as MediaClient from "./media-client.js";