@opencode/ai 2.0.14 → 2.0.15

package/dist/generation.js

@@ -0,0 +1,84 @@
+import { 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);
+const TERMINAL = new Set(["completed", "failed", "cancelled", "expired"]);
+export class Generation {
+    route;
+    token;
+    id;
+    status;
+    progress;
+    position;
+    expiresAt;
+    constructor(route, 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(this.token).pipe(Effect.map((snapshot) => new Generation(this.route, this.token, snapshot)));
+    }
+    /** 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.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),
+                }),
+            }),
+        }));
+    }
+    cancel() {
+        return this.route.cancel?.(this.token) ?? Effect.void;
+    }
+    /** Status observations as a stream, ending after the first terminal observation. */
+    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 };
+        }));
+    }
+    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)));
+    }
+}

package/dist/image-client.d.ts

@@ -1,19 +1,21 @@
-import { Context, Effect, Layer } from "effect";
+import { Context, Effect, Layer, Stream } from "effect";
 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 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>;
 }
 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 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>;
 };
 export {};

package/dist/image-client.js

@@ -1,28 +1,28 @@
-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 { responseEvents, } from "./image.js";
 export class Service 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: (request) => request.model.route.generate({
-            ...sanitizeSurrogates({
-                ...request,
-                model: undefined,
-                http: mergeHttpOptions(request.model.http, request.http),
-            }),
-            model: request.model,
-        }, executor.execute),
+        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 ImageClient = {
     Service,
     layer,
     generate,
+    stream,
 };