@opencode/ai 2.0.15 → 2.0.17

package/dist/ai-client.d.ts

@@ -0,0 +1,8 @@
+import { Layer } from "effect";
+import { RequestExecutor } from "./route/executor.js";
+/** Every modality client over `executor`, which stays in the output so `asset.bytes()` and `Media.write` resolve. */
+export declare const layerWith: <E, R>(executor: Layer.Layer<RequestExecutor.Service, E, R>) => Layer.Layer<import("./route/executor-service.js").RequestExecutorService | import("./route/client.js").LLMClientService | import("./image-client.js").ImageClientService | import("./speech-client.js").SpeechClientService | import("./transcription-client.js").TranscriptionClientService | import("./video-client.js").VideoClientService, E, R>;
+/** Every modality client plus the executor over `RequestExecutor.fetchLayer`: the one layer most programs need. */
+export declare const layer: Layer.Layer<import("./route/executor-service.js").RequestExecutorService | import("./route/client.js").LLMClientService | import("./image-client.js").ImageClientService | import("./speech-client.js").SpeechClientService | import("./transcription-client.js").TranscriptionClientService | import("./video-client.js").VideoClientService, never, never>;
+export type Services = Layer.Success<typeof layer>;
+export * as AIClient from "./ai-client.js";

package/dist/ai-client.js

@@ -0,0 +1,12 @@
+import { Layer } from "effect";
+import { ImageClient } from "./image-client.js";
+import { LLMClient } from "./route/client.js";
+import { RequestExecutor } from "./route/executor.js";
+import { SpeechClient } from "./speech-client.js";
+import { TranscriptionClient } from "./transcription-client.js";
+import { VideoClient } from "./video-client.js";
+/** Every modality client over `executor`, which stays in the output so `asset.bytes()` and `Media.write` resolve. */
+export const layerWith = (executor) => Layer.mergeAll(LLMClient.layer, ImageClient.layer, VideoClient.layer, SpeechClient.layer, TranscriptionClient.layer).pipe(Layer.provideMerge(executor));
+/** Every modality client plus the executor over `RequestExecutor.fetchLayer`: the one layer most programs need. */
+export const layer = layerWith(RequestExecutor.fetchLayer);
+export * as AIClient from "./ai-client.js";

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,61 +9,71 @@ export interface Snapshot {
     /** Normalized 0..1 when the provider reports progress. */
     readonly progress?: number;
     readonly position?: number;
-    readonly expiresAt?: number;
 }
 /**
- * Route-owned generation operations. `token` is the route's serializable handle (operation name, task id, response URL)
- * so a generation can be resumed from another process; its shape is opaque to `Generation`.
+ * 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: (token: unknown) => Effect.Effect<Snapshot, AIError>;
-    readonly result: (token: unknown) => Effect.Effect<Response, AIError>;
-    readonly cancel?: (token: unknown) => 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;
+    readonly status: Effect.Effect<Snapshot, AIError>;
+    readonly result: Effect.Effect<Response, AIError>;
+    readonly cancel?: Effect.Effect<void, AIError>;
 }
 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 type Event = {
-    readonly type: "generation-queued";
-    readonly id: string;
-    readonly position?: number;
-} | {
-    readonly type: "generation-progress";
-    readonly id: string;
-    readonly progress?: number;
-} | {
+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 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. */
     readonly token: unknown;
     readonly id: string;
     readonly status: Status;
     readonly progress?: number;
     readonly position?: number;
-    readonly expiresAt?: number;
-    constructor(route: Route<Response>, token: unknown, snapshot: Snapshot);
+    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?: {
-        readonly poll?: Poll;
-    }): Effect.Effect<Response, AIError>;
+    await(options?: AwaitOptions): Effect.Effect<Response, AIError>;
     cancel(): Effect.Effect<void, AIError>;
-    /** Status observations as a stream, ending after the first terminal observation. */
-    events(options?: {
-        readonly poll?: Poll;
-    }): Stream.Stream<Event, AIError>;
+    /**
+     * 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;
+    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

@@ -1,9 +1,20 @@
-import { Duration, Effect, Schedule, Schema, Stream } from "effect";
+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 const isTerminal = (status) => TERMINAL.has(status);
 export class Generation {
     route;
     token;
@@ -11,15 +22,15 @@ export class Generation {
     status;
     progress;
     position;
-    expiresAt;
-    constructor(route, token, snapshot) {
+    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 {
@@ -27,14 +38,17 @@ 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(this.token).pipe(Effect.map((snapshot) => new Generation(this.route, this.token, snapshot)));
+        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) {
@@ -42,43 +56,55 @@ export class Generation {
         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.route.result(generation.token)), Effect.timeoutOrElse({
-            duration: timeout,
-            orElse: () => new AIError({
-                reason: new TimeoutError({
-                    message: `Generation ${this.id} did not finish within ${Duration.format(timeout)}`,
-                    timeoutMs: Duration.toMillis(timeout),
-                }),
-            }),
-        }));
+        Effect.flatMap((generation) => generation.result()), Effect.timeoutOrElse({ duration: timeout, orElse: () => this.timeoutError(timeout) }));
     }
     cancel() {
-        return this.route.cancel?.(this.token) ?? Effect.void;
+        return this.route.cancel ?? Effect.void;
     }
-    /** Status observations as a stream, ending after the first terminal observation. */
+    /**
+     * 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) {
-        const observations = this.terminal
-            ? Stream.make(this)
-            : Stream.fromEffectSchedule(this.refresh(), this.schedule(options?.poll)).pipe(Stream.takeUntil((generation) => generation.terminal));
-        return observations.pipe(Stream.map((generation) => {
-            if (generation.terminal)
-                return { type: "generation-finished", id: generation.id, status: generation.status };
-            if (generation.status === "queued")
-                return { type: "generation-queued", id: generation.id, position: generation.position };
-            return { type: "generation-progress", id: generation.id, progress: generation.progress };
-        }));
+        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);
+            // 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() {
+        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)));
+        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,21 +1,63 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { RequestExecutor } from "./route/executor.js";
-import type { AIError } from "./schema/index.js";
-import { type ImageEvent, 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 stream: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Stream.Stream<ImageEvent, 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>) => Effect.Effect<ImageResponse, AIError, Service>;
-export declare const stream: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Stream.Stream<ImageEvent, 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>) => Effect.Effect<ImageResponse, AIError, Service>;
-    readonly stream: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Stream.Stream<ImageEvent, 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,28 +1,20 @@
-import { Context, Effect, Layer, Stream } from "effect";
-import { RequestExecutor } from "./route/executor.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) => Effect.gen(function* () {
-    const client = yield* Service;
-    return yield* client.generate(request);
-});
-export const stream = (request) => Stream.unwrap(Effect.gen(function* () {
-    const client = yield* Service;
-    return client.stream(request);
-}));
-export const layer = Layer.effect(Service, Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service;
-    const generate = (request) => request.model.route.generate(request, executor.execute);
-    return Service.of({
-        generate,
-        // Inline routes have no partial frames yet; the stream is the completed response expanded into events.
-        stream: (request) => Stream.unwrap(generate(request).pipe(Effect.map((response) => Stream.fromIterable(responseEvents(response))))),
-    });
-}));
+export const Service = ImageClientService;
 export const ImageClient = {
     Service,
-    layer,
-    generate,
-    stream,
+    ...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,
+            }),
+        ],
+    }),
 };