@opencode/ai 0.0.0-dev-20063 → 0.0.0-dev-20066

package/dist/providers/stability.d.ts

@@ -0,0 +1,28 @@
+import { type ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { StabilityImageOptions, StabilityUpscaleOptions } from "../protocols/stability-images.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/stability-images.js").StabilityImageOptions>;
+    upscale: () => import("../image.js").ImageModel<import("../protocols/stability-images.js").StabilityUpscaleOptions>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/stability-images.js").StabilityImageOptions>;
+    upscale: () => import("../image.js").ImageModel<import("../protocols/stability-images.js").StabilityUpscaleOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/stability-images.js").StabilityImageOptions>;
+        upscale: () => import("../image.js").ImageModel<import("../protocols/stability-images.js").StabilityUpscaleOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/stability-images.js").StabilityImageOptions>;
+export declare const upscale: () => import("../image.js").ImageModel<import("../protocols/stability-images.js").StabilityUpscaleOptions>;

package/dist/providers/stability.js

@@ -0,0 +1,23 @@
+import { AuthOptions } from "../route/auth-options.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { DEFAULT_BASE_URL, StabilityImages } from "../protocols/stability-images.js";
+export const id = ProviderID.make("stability");
+const baseURL = DEFAULT_BASE_URL;
+const auth = (options) => AuthOptions.bearer(options, "STABILITY_API_KEY");
+export const configure = (input = {}) => {
+    const deployment = {
+        auth: auth(input),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    };
+    return {
+        id,
+        image: (modelID) => StabilityImages.model({ ...deployment, id: modelID }),
+        upscale: () => StabilityImages.upscaleModel(deployment),
+        configure,
+    };
+};
+export const provider = configure();
+export const image = provider.image;
+export const upscale = provider.upscale;

package/dist/route/media-protocol.d.ts

@@ -52,11 +52,13 @@ export interface Started<Token> {
 }
 /**
  * A follow-up call's inputs: the decoded token and the auth headers the route sent, so a protocol can attach them
- * to output URLs that require the same credentials to download (Veo).
+ * to output URLs that require the same credentials to download (Veo). `materialize` downloads an output through the
+ * route's executor, for URLs that expire too soon to hand back (BFL).
  */
 export interface PollContext<Token> {
     readonly token: Token;
     readonly auth: Record<string, string>;
+    readonly materialize: (asset: Media.Asset) => Effect.Effect<Media.Asset, AIError>;
 }
 /**
  * Submit, then poll. `start` posts the body to the route endpoint; `status`, `result`, and `cancel` are follow-up

package/dist/route/media.d.ts

@@ -1,9 +1,9 @@
 import { Effect, Stream } from "effect";
 import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
-import type { Interface } from "./executor-service.js";
+import { type Interface } from "./executor-service.js";
 import { MediaProtocol } from "./media-protocol.js";
-import { Generation } from "../generation.js";
+import { Generation, type AwaitOptions, type Observation } from "../generation.js";
 import { AIError, HttpOptions, ProviderID } from "../schema/index.js";
 export type Execute = Interface["execute"];
 /** The minimum a media request must carry for the route to build a transport request. */
@@ -50,6 +50,7 @@ export interface StreamRoute<Request extends MediaRequest, Event, Response> {
     readonly stream: (request: Request, execute: Execute) => Stream.Stream<Event, AIError>;
     readonly generate: (request: Request, execute: Execute) => Effect.Effect<Response, AIError>;
 }
+export type AnyRoute<Request extends MediaRequest, Event, Response> = Route<Request, Response> | StreamRoute<Request, Event, Response> | QueuedRoute<Request, Response>;
 export interface Composition<Request extends MediaRequest> {
     readonly id: string;
     readonly provider: string | ProviderID;
@@ -83,4 +84,14 @@ export declare const inline: <Request extends MediaRequest, Response>(input: Inl
 export declare const queued: <Request extends MediaRequest, Response, Token>(input: QueuedInput<Request, Response, Token>) => QueuedRoute<Request, Response>;
 /** Compose a streaming media protocol; `generate` runs the same stream in `generate` mode and folds it with `collect`. */
 export declare const stream: <Request extends MediaRequest, Event, Response, Frame, State>(input: StreamInput<Request, Event, Response, Frame, State>) => StreamRoute<Request, Event, Response>;
+export declare const dispatch: <Event, Response>(input: {
+    readonly modality: string;
+    readonly execute: Execute;
+    readonly responseEvents: (response: Response) => ReadonlyArray<Event>;
+}) => {
+    start: <Request extends MediaRequest>(route: AnyRoute<Request, Event, Response>, request: Request) => Effect.Effect<Generation<Response>, AIError, never>;
+    resume: <Request extends MediaRequest>(route: AnyRoute<Request, Event, Response>, model: MediaRequest["model"], token: unknown) => Effect.Effect<Generation<Response>, AIError, never>;
+    generate: <Request extends MediaRequest>(route: AnyRoute<Request, Event, Response>, request: Request, options?: AwaitOptions) => Effect.Effect<Response, AIError, never>;
+    stream: <Request extends MediaRequest>(route: AnyRoute<Request, Event, Response>, request: Request, options?: AwaitOptions) => Stream.Stream<Event | Observation, AIError>;
+};
 export * as MediaRoute from "./media.js";

package/dist/route/media.js

@@ -2,9 +2,10 @@ import { Effect, Schema, Stream } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
+import { Service as RequestExecutorService } from "./executor-service.js";
 import { RequestExecutor } from "./executor.js";
 import { MediaProtocol } from "./media-protocol.js";
-import { Generation } from "../generation.js";
+import { Generation, resultEvents, } from "../generation.js";
 import { ProviderShared } from "../protocols/shared.js";
 import { AIError, AIErrorReason, HttpOptions, InvalidRequestError, ProviderID, mergeHttpOptions, } from "../schema/index.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
@@ -39,9 +40,10 @@ export const queued = (input) => {
     // A protocol producing a token its own codec rejects is a programmer defect, not a provider error.
     const encodeToken = Schema.encodeSync(protocol.token);
     const generationRoute = (token, http, execute) => {
+        const materialize = (asset) => asset.materialize().pipe(Effect.provideService(RequestExecutorService, { execute }));
         const poll = (operation) => transport
             .call("GET", operation.path(token), http, execute)
-            .pipe(Effect.flatMap((sent) => operation.decode(sent.response, { token, auth: sent.auth })));
+            .pipe(Effect.flatMap((sent) => operation.decode(sent.response, { token, auth: sent.auth, materialize })));
         const cancel = protocol.cancel;
         const route = {
             status: poll(protocol.status),
@@ -104,6 +106,39 @@ export const stream = (input) => {
         generate: (request, execute) => events(request, execute, "generate").pipe(Stream.runCollect, Effect.flatMap(input.collect)),
     };
 };
+export const dispatch = (input) => {
+    const notQueued = (route, operation) => ProviderShared.unsupportedOperation({
+        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 = (route, request) => {
+        if (route.kind !== "queued")
+            return Effect.fail(notQueued(route, "start"));
+        return route.start(request, input.execute);
+    };
+    return {
+        start,
+        resume: (route, model, token) => {
+            if (route.kind !== "queued")
+                return Effect.fail(notQueued(route, "resume"));
+            return route.resume(model, token, input.execute);
+        },
+        generate: (route, request, options) => {
+            if (route.kind !== "queued")
+                return route.generate(request, input.execute);
+            return start(route, request).pipe(Effect.flatMap((generation) => generation.await(options)));
+        },
+        stream: (route, request, options) => {
+            if (route.kind === "stream")
+                return route.stream(request, input.execute);
+            if (route.kind === "queued")
+                return Stream.unwrap(start(route, request).pipe(Effect.map((generation) => resultEvents(generation, input.responseEvents, options))));
+            return Stream.fromIterableEffect(Effect.map(route.generate(request, input.execute), input.responseEvents));
+        },
+    };
+};
 // ---------------------------------------------------------------------------
 // Transport plumbing shared by every kind
 // ---------------------------------------------------------------------------

package/dist/transcription-client.d.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer, Stream } from "effect";
-import { type AwaitOptions, type Generation } from "./generation.js";
+import type { AwaitOptions, Generation } from "./generation.js";
 import { RequestExecutor } from "./route/executor.js";
 import type { AIError } from "./schema/index.js";
 import { type TranscriptionEvent, type TranscriptionModel, type TranscriptionOptions, type TranscriptionRequestFor, type TranscriptionResponse } from "./transcription.js";

package/dist/transcription-client.js

@@ -1,7 +1,6 @@
 import { Context, Effect, Layer, Stream } from "effect";
-import { resultEvents } from "./generation.js";
-import { ProviderShared } from "./protocols/shared.js";
 import { RequestExecutor } from "./route/executor.js";
+import { MediaRoute } from "./route/media.js";
 import { responseEvents, } from "./transcription.js";
 export class Service extends Context.Service()("@opencode/TranscriptionClient") {
 }
@@ -21,42 +20,18 @@ export const resume = (model, token) => Effect.gen(function* () {
     const client = yield* Service;
     return yield* client.resume(model, token);
 });
-const notQueued = (route, operation) => ProviderShared.unsupportedOperation({
-    operation: `transcription.${operation}`,
-    provider: route.provider,
-    route: route.id,
-    message: `${route.provider}/${route.id} is not a queued route; use Transcription.generate or Transcription.stream`,
-});
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service;
-    const start = (request) => {
-        const route = request.model.route;
-        if (route.kind !== "queued")
-            return Effect.fail(notQueued(route, "start"));
-        return route.start(request, executor.execute);
-    };
+    const dispatch = MediaRoute.dispatch({
+        modality: "transcription",
+        execute: executor.execute,
+        responseEvents,
+    });
     return Service.of({
-        start,
-        resume: (model, token) => {
-            const route = model.route;
-            if (route.kind !== "queued")
-                return Effect.fail(notQueued(route, "resume"));
-            return 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, responseEvents, options))));
-            return Stream.fromIterableEffect(Effect.map(route.generate(request, executor.execute), responseEvents));
-        },
+        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 TranscriptionClient = {

package/dist/transcription.d.ts

@@ -7,7 +7,7 @@ import type { MediaProtocol } from "./route/media-protocol.js";
 import { AIError, HttpOptions } from "./schema/index.js";
 import { Service } from "./transcription-client.js";
 export type TranscriptionOptions = Record<string, unknown>;
-export type TranscriptionRoute<Options extends TranscriptionOptions = TranscriptionOptions> = MediaRoute.Route<TranscriptionRequestFor<Options>, TranscriptionResponse> | MediaRoute.StreamRoute<TranscriptionRequestFor<Options>, TranscriptionEvent, TranscriptionResponse> | MediaRoute.QueuedRoute<TranscriptionRequestFor<Options>, TranscriptionResponse>;
+export type TranscriptionRoute<Options extends TranscriptionOptions = TranscriptionOptions> = MediaRoute.AnyRoute<TranscriptionRequestFor<Options>, TranscriptionEvent, TranscriptionResponse>;
 export declare class TranscriptionModel<Options extends TranscriptionOptions = TranscriptionOptions> extends MediaModel<TranscriptionRoute<Options>, Options> {
     protected readonly _TranscriptionModel: void;
     static make<Options extends TranscriptionOptions = TranscriptionOptions>(input: MediaModel.Input<TranscriptionRoute<Options>>): TranscriptionModel<Options>;
@@ -20,7 +20,7 @@ export declare namespace TranscriptionModel {
     type InlineRouteInput<Options extends TranscriptionOptions = TranscriptionOptions> = MediaModel.RouteInput<TranscriptionRequestFor<Options>, MediaProtocol.Inline<TranscriptionRequestFor<Options>, TranscriptionResponse>>;
     type StreamRouteInput<Options extends TranscriptionOptions = TranscriptionOptions, Frame = unknown, State = unknown> = MediaModel.RouteInput<MediaProtocol.Addressed<TranscriptionRequestFor<Options>>, MediaProtocol.Streamed<TranscriptionRequestFor<Options>, TranscriptionEvent, Frame, State>>;
     type QueuedRouteInput<Options extends TranscriptionOptions = TranscriptionOptions, Token = unknown> = MediaModel.RouteInput<TranscriptionRequestFor<Options>, MediaProtocol.Queued<TranscriptionRequestFor<Options>, TranscriptionResponse, Token>>;
-    type RouteInput<Options extends TranscriptionOptions = TranscriptionOptions, Frame = unknown, State = unknown, Token = unknown> = InlineRouteInput<Options> | StreamRouteInput<Options, Frame, State> | QueuedRouteInput<Options, Token>;
+    type RouteInput<Options extends TranscriptionOptions = TranscriptionOptions, Frame = unknown, State = unknown, Token = unknown> = MediaModel.AnyRouteInput<TranscriptionRequestFor<Options>, TranscriptionEvent, TranscriptionResponse, Frame, State, Token>;
 }
 export declare const TranscriptionModelSchema: Schema.declare<TranscriptionModel<TranscriptionOptions>, TranscriptionModel<TranscriptionOptions>>;
 export declare const TranscriptionTimestamps: Schema.Literals<readonly ["none", "segment", "word"]>;

package/dist/transcription.js

@@ -1,7 +1,7 @@
 import { Effect, Schema, Stream } from "effect";
 import { Generation, ProgressEvent, QueuedEvent } from "./generation.js";
 import { Media } from "./media.js";
-import { MediaModel, composeRoute, tryRequest } from "./media-model.js";
+import { MediaModel, composeAnyRoute, tryRequest } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
 import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js";
 import { TranscriptionClient, Service } from "./transcription-client.js";
@@ -10,21 +10,14 @@ export class TranscriptionModel extends MediaModel {
         return new TranscriptionModel(input);
     }
     static fromRoute(route, input) {
-        const composed = isStreamInput(route)
-            ? composeRoute((composition) => MediaRoute.stream({ ...composition, collect: collectResponse }), route, input)
-            : isQueuedInput(route)
-                ? composeRoute(MediaRoute.queued, route, input)
-                : composeRoute(MediaRoute.inline, route, input);
         return new TranscriptionModel({
             id: input.id,
             provider: route.provider,
             http: input.http,
-            route: composed,
+            route: composeAnyRoute(route, input, collectResponse),
         });
     }
 }
-const isStreamInput = (route) => route.protocol.kind === "stream";
-const isQueuedInput = (route) => route.protocol.kind === "queued";
 export const TranscriptionModelSchema = Schema.declare((value) => value instanceof TranscriptionModel, { expected: "Transcription.Model" });
 // ---------------------------------------------------------------------------
 // Request

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-20063",
+  "version": "0.0.0-dev-20066",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-20063",
+    "@opencode/http-recorder": "0.0.0-dev-20066",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "0.0.0-dev-20063",
+    "@opencode/schema": "0.0.0-dev-20066",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"