@opencode/ai 2.0.14 → 2.0.16

package/dist/experimental/evaluation-client.js

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer } from "effect";
 import { RequestExecutor } from "../route/executor.js";
-import { mergeHttpOptions } from "../schema/index.js";
+import { AIError, InvalidProviderOutputError, mergeHttpOptions } from "../schema/index.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
 import {} from "./evaluation.js";
 export class Service extends Context.Service()("@opencode/AI/Experimental/EvaluationClient") {
@@ -9,14 +9,50 @@ export const evaluate = (request) => Effect.flatMap(Service, (client) => client.
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service;
     return Service.of({
-        evaluate: (request) => request.model.route.evaluate({
+        evaluate: (request) => request.model.route
+            .evaluate({
             ...sanitizeSurrogates({
                 ...request,
                 model: undefined,
                 http: mergeHttpOptions(request.model.http, request.http),
             }),
             model: request.model,
-        }, executor.execute),
+        }, executor.execute)
+            .pipe(Effect.flatMap((response) => {
+            const questions = Object.entries(request.questions);
+            if (questions.length === Object.keys(response.answers).length &&
+                questions.every(([id, question]) => {
+                    const answer = response.answers[id];
+                    if (question.type === "boolean")
+                        return answer?.type === "boolean";
+                    if (question.type === "choice") {
+                        if (answer?.type !== "choice" || !Object.hasOwn(question.criteria, answer.choice))
+                            return false;
+                        if (answer.probabilities === undefined)
+                            return true;
+                        const keys = Object.keys(question.criteria);
+                        const probabilities = answer.probabilities;
+                        return (Object.keys(probabilities).length === keys.length &&
+                            keys.every((key) => Object.hasOwn(probabilities, key)));
+                    }
+                    if (answer?.type !== "score" || answer.score < 0 || answer.score > question.criteria.length - 1)
+                        return false;
+                    if (answer.probabilities === undefined)
+                        return true;
+                    const keys = question.criteria.map((_, index) => String(index));
+                    const probabilities = answer.probabilities;
+                    return (Object.keys(probabilities).length === keys.length &&
+                        keys.every((key) => Object.hasOwn(probabilities, key)));
+                }))
+                return Effect.succeed(response);
+            return Effect.fail(new AIError({
+                reason: new InvalidProviderOutputError({
+                    route: request.model.route.id,
+                    message: "Evaluation answers do not match the requested questions",
+                    cause: response.answers,
+                }),
+            }));
+        })),
     });
 }));
 export const fetchLayer = layer.pipe(Layer.provide(RequestExecutor.fetchLayer));

package/dist/experimental/evaluation.d.ts

@@ -96,7 +96,7 @@ export type AnswersFor<Questions extends EvaluationQuestions> = {
 export type EvaluationOptions = Record<string, unknown>;
 export interface EvaluationRoute<Options extends EvaluationOptions = EvaluationOptions> {
     readonly id: string;
-    readonly evaluate: <const Questions extends EvaluationQuestions>(request: EvaluationRequestFor<Options, Questions>, execute: Execute) => Effect.Effect<EvaluationResponseFor<Questions>, AIError>;
+    readonly evaluate: (request: EvaluationRequestFor<Options>, execute: Execute) => Effect.Effect<EvaluationResponse, AIError>;
 }
 export declare class EvaluationModel<Options extends EvaluationOptions = EvaluationOptions> {
     protected readonly _Options: (options: Options) => Options;
@@ -225,10 +225,10 @@ export type EvaluationResponseFor<Questions extends EvaluationQuestions> = Omit<
 };
 export declare function request<const Model extends object, const Questions extends EvaluationQuestions>(input: EvaluationRequestInput<Model, Questions>): EvaluationRequestFor<EvaluationModelOptions<Model>, Questions>;
 export declare function request(input: EvaluationRequest): EvaluationRequest;
-export declare function evaluate<const Model extends object, const Questions extends EvaluationQuestions>(input: EvaluationRequestInput<Model, Questions>): Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
-export declare function evaluate(input: EvaluationRequest): Effect.Effect<EvaluationResponse, AIError, Service>;
+export declare function run<const Model extends object, const Questions extends EvaluationQuestions>(input: EvaluationRequestInput<Model, Questions>): Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
+export declare function run(input: EvaluationRequest): Effect.Effect<EvaluationResponse, AIError, Service>;
 export declare const Evaluation: {
     readonly request: typeof request;
-    readonly evaluate: typeof evaluate;
+    readonly run: typeof run;
 };
 export {};

package/dist/experimental/evaluation.js

@@ -97,7 +97,7 @@ export function request(input) {
         http: input.http === undefined ? undefined : HttpOptions.make(input.http),
     });
 }
-export function evaluate(input) {
+export function run(input) {
     return Effect.try({
         try: () => (input instanceof EvaluationRequest ? input : request(input)),
         catch: (cause) => new AIError({
@@ -110,5 +110,5 @@ export function evaluate(input) {
 }
 export const Evaluation = {
     request,
-    evaluate,
+    run,
 };

package/dist/experimental/system-one.d.ts

@@ -1,4 +1,4 @@
-import { EvaluationModel } from "./evaluation.js";
+import { EvaluationModel, type EvaluationOptions } from "./evaluation.js";
 import { type Definition as AuthDefinition } from "../route/auth.js";
 import { HttpOptions, ModelID } from "../schema/index.js";
 export interface ModelInput {
@@ -10,7 +10,7 @@ export interface ModelInput {
     readonly headers?: Record<string, string>;
     readonly http?: HttpOptions;
 }
-export declare const model: (cfg: ModelInput) => EvaluationModel<import("./evaluation.js").EvaluationOptions>;
+export declare const model: <Options extends EvaluationOptions = EvaluationOptions>(cfg: ModelInput) => EvaluationModel<Options>;
 export declare const SystemOne: {
-    readonly model: (cfg: ModelInput) => EvaluationModel<import("./evaluation.js").EvaluationOptions>;
+    readonly model: <Options extends EvaluationOptions = EvaluationOptions>(cfg: ModelInput) => EvaluationModel<Options>;
 };

package/dist/experimental/system-one.js

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
-import { BooleanAnswer, ChoiceAnswer, ChoiceQuestion, EvaluationInput, EvaluationModel, EvaluationResponse, EvaluationRounding, ScoreAnswer, ScoreQuestion, } from "./evaluation.js";
+import { ChoiceQuestion, EvaluationInput, EvaluationModel, EvaluationResponse, EvaluationRounding, ScoreQuestion, } from "./evaluation.js";
 import { Auth } from "../route/auth.js";
 import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, Usage, mergeJsonRecords, } from "../schema/index.js";
 const Noul = Schema.Struct({
@@ -40,19 +40,29 @@ const Score = Schema.Struct({
     legend: Schema.optional(Schema.Record(Schema.String, Schema.Json)),
     confidence: Schema.optional(Probability),
 });
-const NativeUsage = Schema.Struct({
+const Answer = Schema.Union([NoulAnswer, Choice, Score]).pipe(Schema.toTaggedUnion("type"));
+const NativeUsage = Schema.StructWithRest(Schema.Struct({
     input_tokens: Schema.optional(Schema.Number),
     output_tokens: Schema.optional(Schema.Number),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Response = Schema.Struct({
+    model: Schema.String,
+    answers: Schema.Record(Schema.String, Answer),
+    usage: Schema.optional(NativeUsage),
+    id: Schema.optional(Schema.String),
+    provider: Schema.optional(Schema.String),
+    provider_metadata: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
 });
-const encode = Schema.encodeUnknownEffect(Schema.fromJsonString(Request));
-const exact = (x, keys) => Object.keys(x).length === keys.length && keys.every((key) => Object.hasOwn(x, key));
-export const model = (cfg) => {
-    const route = {
+export const model = (cfg) => EvaluationModel.make({
+    id: cfg.id,
+    provider: cfg.provider,
+    http: cfg.http,
+    route: {
         id: "system-one",
         evaluate: (req, send) => Effect.gen(function* () {
             const url = new URL(`${cfg.baseURL.replace(/\/$/, "")}/systemone`);
             Object.entries(req.http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value));
-            const body = yield* encode({
+            const body = yield* Schema.encodeUnknownEffect(Schema.fromJsonString(Request))({
                 ...mergeJsonRecords(req.options, req.http?.body),
                 model: req.model.id,
                 state: req.state,
@@ -67,56 +77,36 @@ export const model = (cfg) => {
             });
             const res = yield* send(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(body, "application/json")));
             const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers });
-            const fail = (message, cause, body) => new AIError({ reason: new InvalidProviderOutputError({ route: route.id, message, body, http, cause }) });
+            const fail = (message, cause, body) => new AIError({ reason: new InvalidProviderOutputError({ route: "system-one", message, body, http, cause }) });
             const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the System One response", cause)));
-            const entries = Object.entries(req.questions);
-            const output = Schema.Struct({
-                model: Schema.String,
-                answers: Schema.Struct(Object.fromEntries(entries.map(([id, question]) => {
-                    if (question.type === "boolean")
-                        return [id, NoulAnswer];
-                    if (question.type === "choice") {
-                        const keys = Object.keys(question.criteria);
-                        return [
-                            id,
-                            Choice.pipe(Schema.refine((x) => Object.hasOwn(question.criteria, x.choice) && exact(x.probabilities, keys), { message: `Question "${id}" returned an invalid choice answer` })),
-                        ];
-                    }
-                    const keys = question.criteria.map((_, index) => String(index));
-                    return [
-                        id,
-                        Score.pipe(Schema.refine((x) => x.score >= 0 && x.score <= question.criteria.length - 1 && exact(x.probabilities, keys), { message: `Question "${id}" returned an invalid score answer` })),
-                    ];
-                }))),
-                usage: Schema.optional(NativeUsage),
-            });
-            const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(output))(text).pipe(Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)));
+            const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)));
             const confidence = {};
             const legend = {};
-            const answers = Object.fromEntries(entries.map(([id, question]) => {
-                const answer = data.answers[id];
-                if (question.type === "boolean")
+            const answers = Object.fromEntries(Object.entries(data.answers).map(([id, answer]) => {
+                if (answer.type === "noul")
+                    return [id, { type: "boolean", probability: answer.noul }];
+                if (answer.type === "choice") {
+                    if (answer.confidence !== undefined)
+                        confidence[id] = answer.confidence;
                     return [
                         id,
-                        { type: "boolean", probability: answer.noul },
-                    ];
-                if (question.type === "choice") {
-                    const value = answer;
-                    if (value.confidence !== undefined)
-                        confidence[id] = value.confidence;
-                    return [
-                        id,
-                        { type: "choice", choice: value.choice, probabilities: value.probabilities },
+                        {
+                            type: "choice",
+                            choice: answer.choice,
+                            probabilities: answer.probabilities,
+                        },
                     ];
                 }
-                const value = answer;
-                if (value.confidence !== undefined)
-                    confidence[id] = value.confidence;
-                if (value.legend !== undefined)
-                    legend[id] = value.legend;
-                return [id, { type: "score", score: value.score, probabilities: value.probabilities }];
+                if (answer.confidence !== undefined)
+                    confidence[id] = answer.confidence;
+                if (answer.legend !== undefined)
+                    legend[id] = answer.legend;
+                return [id, { type: "score", score: answer.score, probabilities: answer.probabilities }];
             }));
             const meta = {
+                ...(data.id === undefined ? {} : { responseId: data.id }),
+                ...(data.provider === undefined ? {} : { provider: data.provider }),
+                ...data.provider_metadata?.[cfg.providerMetadataKey],
                 ...(Object.keys(confidence).length === 0 ? {} : { confidence }),
                 ...(Object.keys(legend).length === 0 ? {} : { legend }),
             };
@@ -137,7 +127,6 @@ export const model = (cfg) => {
                 providerMetadata: Object.keys(meta).length === 0 ? undefined : { [cfg.providerMetadataKey]: meta },
             });
         }),
-    };
-    return EvaluationModel.make({ id: cfg.id, provider: cfg.provider, route, http: cfg.http });
-};
+    },
+});
 export const SystemOne = { model };

package/dist/generation.d.ts

@@ -0,0 +1,83 @@
+import { Duration, Effect, Schedule, 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>;
+/** Provider-neutral view of one generation observation. */
+export interface Snapshot {
+    readonly id: string;
+    readonly status: Status;
+    /** 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
+ * submission response or a `resume` input) and closes over it, so `Generation` never sees the token's shape.
+ */
+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;
+}
+export declare const DEFAULT_POLL_INTERVAL: Duration.Duration;
+export declare const DEFAULT_POLL_TIMEOUT: Duration.Duration;
+export declare const QueuedEvent: Schema.Struct<{
+    readonly type: Schema.tag<"generation-queued">;
+    readonly id: Schema.String;
+    readonly position: Schema.optional<Schema.Number>;
+}>;
+export declare const ProgressEvent: Schema.Struct<{
+    readonly type: Schema.tag<"generation-progress">;
+    readonly id: Schema.String;
+    readonly progress: Schema.optional<Schema.Number>;
+}>;
+export type Observation = Schema.Schema.Type<typeof QueuedEvent> | Schema.Schema.Type<typeof ProgressEvent>;
+export type Event = Observation | {
+    readonly type: "generation-finished";
+    readonly id: string;
+    readonly status: Status;
+};
+export declare class Generation<Response> {
+    readonly route: Route<Response>;
+    /** Route-owned serializable JSON; pass it to the modality's `resume` from another process. */
+    readonly token: unknown;
+    readonly id: string;
+    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);
+    get snapshot(): Snapshot;
+    get terminal(): boolean;
+    refresh(): Effect.Effect<Generation<Response>, AIError>;
+    /** Fetch the result without polling; non-completed terminal generations fail with the provider's terminal body. */
+    result(): Effect.Effect<Response, AIError>;
+    /** Poll until the generation reaches a terminal status, then fetch the result. Fails with a `Timeout` reason on deadline. */
+    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.)
+     */
+    events(options?: AwaitOptions): Stream.Stream<Event, AIError>;
+    private event;
+    private timeoutError;
+    private poll;
+    private schedule;
+}
+export declare const resultEvents: <Response, A>(generation: Generation<Response>, expand: (response: Response) => ReadonlyArray<A>, options?: AwaitOptions) => Stream.Stream<Observation | A, AIError>;

package/dist/generation.js

@@ -0,0 +1,113 @@
+import { Clock, Duration, Effect, Schedule, Schema, Stream } from "effect";
+import { AIError, TimeoutError } from "./schema/errors.js";
+export const Status = Schema.Literals(["queued", "running", "completed", "failed", "cancelled", "expired"]);
+export const DEFAULT_POLL_INTERVAL = Duration.seconds(5);
+export const DEFAULT_POLL_TIMEOUT = Duration.minutes(10);
+export const QueuedEvent = Schema.Struct({
+    type: Schema.tag("generation-queued"),
+    id: Schema.String,
+    position: Schema.optional(Schema.Number),
+}).annotate({ identifier: "Generation.Event.Queued" });
+export const ProgressEvent = Schema.Struct({
+    type: Schema.tag("generation-progress"),
+    id: Schema.String,
+    progress: Schema.optional(Schema.Number),
+}).annotate({ identifier: "Generation.Event.Progress" });
+const TERMINAL = new Set(["completed", "failed", "cancelled", "expired"]);
+export class Generation {
+    route;
+    token;
+    id;
+    status;
+    progress;
+    position;
+    expiresAt;
+    constructor(route, 
+    /** Route-owned serializable JSON; pass it to the modality's `resume` from another process. */
+    token, snapshot) {
+        this.route = route;
+        this.token = token;
+        this.id = snapshot.id;
+        this.status = snapshot.status;
+        this.progress = snapshot.progress;
+        this.position = snapshot.position;
+        this.expiresAt = snapshot.expiresAt;
+    }
+    get snapshot() {
+        return {
+            id: this.id,
+            status: this.status,
+            progress: this.progress,
+            position: this.position,
+            expiresAt: this.expiresAt,
+        };
+    }
+    get terminal() {
+        return TERMINAL.has(this.status);
+    }
+    refresh() {
+        return this.route.status.pipe(Effect.map((snapshot) => new Generation(this.route, this.token, snapshot)));
+    }
+    /** Fetch the result without polling; non-completed terminal generations fail with the provider's terminal body. */
+    result() {
+        return this.route.result;
+    }
+    /** Poll until the generation reaches a terminal status, then fetch the result. Fails with a `Timeout` reason on deadline. */
+    await(options) {
+        const timeout = Duration.fromInputUnsafe(options?.poll?.timeout ?? DEFAULT_POLL_TIMEOUT);
+        const settled = this.terminal ? Effect.succeed(this) : this.poll(options?.poll);
+        return settled.pipe(
+        // Non-completed terminal states also go through `result` so the route can surface its provider failure body.
+        Effect.flatMap((generation) => generation.result()), Effect.timeoutOrElse({ duration: timeout, orElse: () => this.timeoutError(timeout) }));
+    }
+    cancel() {
+        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.)
+     */
+    events(options) {
+        if (this.terminal)
+            return Stream.make(this.event());
+        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()));
+        })));
+    }
+    event() {
+        if (this.terminal)
+            return { type: "generation-finished", id: this.id, status: this.status };
+        if (this.status === "queued")
+            return { type: "generation-queued", id: this.id, position: this.position };
+        return { type: "generation-progress", id: this.id, progress: this.progress };
+    }
+    timeoutError(timeout) {
+        return new AIError({
+            reason: new TimeoutError({
+                message: `Generation ${this.id} did not finish within ${Duration.format(timeout)}`,
+                timeoutMs: Duration.toMillis(timeout),
+            }),
+        });
+    }
+    poll(poll) {
+        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)));
+    }
+}
+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,19 +1,28 @@
-import { Context, Effect, Layer } from "effect";
+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 { ImageOptions, ImageRequestFor, ImageResponse } from "./image.js";
-export type Execute = RequestExecutor.Interface["execute"];
+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>) => Effect.Effect<ImageResponse, AIError>;
+    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>;
 }
 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>) => Effect.Effect<ImageResponse, AIError, Service>;
+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 ImageClient: {
     readonly Service: typeof Service;
     readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
-    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, AIError, 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>;
 };
 export {};

package/dist/image-client.js

@@ -1,28 +1,44 @@
-import { Context, Effect, Layer } from "effect";
+import { Context, Effect, Layer, Stream } from "effect";
 import { RequestExecutor } from "./route/executor.js";
-import { mergeHttpOptions } from "./schema/index.js";
-import { sanitizeSurrogates } from "./utils/sanitize.js";
+import { MediaRoute } from "./route/media.js";
+import { responseEvents, } from "./image.js";
 export class Service extends Context.Service()("@opencode/ImageClient") {
 }
-export const generate = (request) => Effect.gen(function* () {
+export const generate = (request, options) => Effect.gen(function* () {
     const client = yield* Service;
-    return yield* client.generate(request);
+    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({
-        generate: (request) => request.model.route.generate({
-            ...sanitizeSurrogates({
-                ...request,
-                model: undefined,
-                http: mergeHttpOptions(request.model.http, request.http),
-            }),
-            model: request.model,
-        }, executor.execute),
+        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 ImageClient = {
     Service,
     layer,
     generate,
+    stream,
+    start,
+    resume,
 };