@opencode/ai 2.0.15 → 2.0.16

package/dist/providers/zai-coding-plan.d.ts

@@ -86,8 +86,8 @@ export declare const routes: (Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -123,8 +123,8 @@ export declare const routes: (Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -200,6 +200,12 @@ export declare const routes: (Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -215,6 +221,12 @@ export declare const routes: (Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;
@@ -290,8 +302,8 @@ export declare const routes: (Route<{
     readonly response_format?: {
         readonly type: string;
     } | undefined;
-    readonly do_sample?: boolean | undefined;
     readonly request_id?: string | undefined;
+    readonly do_sample?: boolean | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined> | Route<{
     readonly max_tokens: number;
     readonly model: string;

package/dist/providers/zai.d.ts

@@ -30,6 +30,12 @@ export declare const routes: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -45,6 +51,12 @@ export declare const routes: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;
@@ -120,8 +132,8 @@ export declare const routes: Route<{
     readonly response_format?: {
         readonly type: string;
     } | undefined;
-    readonly do_sample?: boolean | undefined;
     readonly request_id?: string | undefined;
+    readonly do_sample?: boolean | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;

package/dist/route/auth.d.ts

@@ -13,7 +13,7 @@ export interface AuthInput {
     readonly request: {
         readonly http?: HttpOptions;
     };
-    readonly method: "POST" | "GET";
+    readonly method: "POST" | "GET" | "PUT" | "DELETE";
     readonly url: string;
     readonly body: string;
     readonly headers: Headers.Headers;
@@ -47,5 +47,8 @@ export declare function header(name: string): (source: Secret | Credential) => D
 export declare function header(name: string, source: Secret | Credential): Definition;
 export declare function bearerHeader(name: string): (source: Secret | Credential) => Definition;
 export declare function bearerHeader(name: string, source: Secret | Credential): Definition;
+/** `Authorization: <scheme> <secret>` for providers whose scheme is not `Bearer`, such as fal's `Key`. */
+export declare function scheme(name: string): (source: Secret | Credential) => Definition;
+export declare function scheme(name: string, source: Secret | Credential): Definition;
 export declare const toEffect: (input: Definition) => (authInput: AuthInput) => Effect.Effect<Headers.Headers, AIError>;
 export * as Auth from "./auth.js";

package/dist/route/auth.js

@@ -73,6 +73,12 @@ export function bearerHeader(name, source) {
         return render;
     return render(source);
 }
+export function scheme(name, source) {
+    const render = (input) => fromCredential(credentialInput(input), (secret) => ({ authorization: `${name} ${secret}` }));
+    if (source === undefined)
+        return render;
+    return render(source);
+}
 const toAIError = (error) => {
     if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
         return new AIError({

package/dist/route/framing.d.ts

@@ -1,4 +1,4 @@
-import type { Stream } from "effect";
+import { Stream } from "effect";
 import type { AIError } from "../schema/index.js";
 /**
  * Decode a streaming HTTP response body into provider-protocol frames.
@@ -10,6 +10,8 @@ import type { AIError } from "../schema/index.js";
  *   `[DONE]`; protocols that use it as a terminal select `sseWithDone`.
  * - AWS event stream — length-prefixed binary frames with CRC checksums.
  *   Each emitted frame is one parsed binary event record.
+ * - Media streams — newline-delimited JSON (`lines`) or the whole body as one
+ *   frame (`document`); chunked binary bodies need no framing.
  *
  * The frame type is opaque to this layer; the protocol's event schema decodes
  * each frame before its state machine handles it.
@@ -26,4 +28,6 @@ export declare const sse: Definition<string>;
 export declare const sseWithDone: Definition<string>;
 /** SSE framing restricted to protocol-recognized event names. */
 export declare const sseEvents: (events: ReadonlySet<string>) => Definition<string>;
+export declare const lines: Definition<string>;
+export declare const document: Definition<string>;
 export * as Framing from "./framing.js";

package/dist/route/framing.js

@@ -1,3 +1,4 @@
+import { Stream } from "effect";
 import * as ProviderShared from "../protocols/shared.js";
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse = { id: "sse", frame: ProviderShared.sseFraming };
@@ -11,4 +12,12 @@ export const sseEvents = (events) => ({
     id: "sse",
     frame: (bytes) => ProviderShared.sseFraming(bytes, events),
 });
+export const lines = {
+    id: "lines",
+    frame: (bytes) => bytes.pipe(Stream.decodeText(), Stream.splitLines, Stream.filter((line) => line.trim().length > 0)),
+};
+export const document = {
+    id: "document",
+    frame: (bytes) => Stream.fromEffect(Stream.mkString(bytes.pipe(Stream.decodeText()))),
+};
 export * as Framing from "./framing.js";

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

@@ -1,15 +1,31 @@
-import { Effect, Schema } from "effect";
+import { Duration, Effect, Schema, type Stream } from "effect";
 import { HttpClientResponse } from "effect/unstable/http";
+import type { Snapshot, Status } from "../generation.js";
+import { Media } from "../media.js";
+import type { AuthInput } from "./auth.js";
 import { AIError, HttpContext } from "../schema/index.js";
+/** Array values become repeated parameters (`keyterm=a&keyterm=b`). */
+export type Query = Readonly<Record<string, string | ReadonlyArray<string>>>;
+/** `query` is appended to the endpoint URL before the route and caller `http.query` overlays. */
 export type Body = {
     readonly type: "json";
     readonly value: Record<string, unknown>;
+    readonly query?: Query;
 } | {
     readonly type: "multipart";
     readonly value: FormData;
+} | {
+    readonly type: "binary";
+    readonly value: Uint8Array;
+    readonly contentType: string;
+    readonly query?: Query;
 };
-export declare const json: (value: Record<string, unknown>) => Body;
+export declare const json: (value: Record<string, unknown>, query?: Query) => Body;
 export declare const multipart: (value: FormData) => Body;
+export declare const binary: (value: Uint8Array, contentType: string, query?: Query) => Body;
+export type Send = (path: string, body: Body) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
+/** Runs after unsupported-field rejection and before `body.from`, for providers that need an upload first. */
+export type Prepare<Request> = (request: Request, send: Send) => Effect.Effect<Request, AIError>;
 export interface DecodeContext<Request> {
     readonly request: Request;
     readonly body: Body;
@@ -29,17 +45,114 @@ export interface Inline<Request, Response> {
     };
 }
 export declare const inline: <Request, Response>(input: Omit<Inline<Request, Response>, "kind">) => Inline<Request, Response>;
-/** Read a text body while retaining the original payload and HTTP context on every downstream error. */
+/** What `start` learned from the submission response: the route-owned handle plus the first observation. */
+export interface Started<Token> {
+    readonly token: Token;
+    readonly snapshot: Snapshot;
+}
+/**
+ * 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). `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
+ * calls addressed by the token. Paths are relative to the route base URL unless the provider hands back absolute
+ * URLs (fal `status_url`), in which case they are used verbatim. `result` is always its own GET: providers that
+ * return the output inside the status body (Veo, xAI, Runway) point `result.path` at the status path and decode the
+ * same document, so `Generation.await` and `Video.resume(...).await()` behave identically everywhere.
+ */
+export interface Queued<Request, Response, Token> {
+    readonly kind: "queued";
+    readonly id: string;
+    readonly name: string;
+    /** Common request fields this protocol cannot lower; the route rejects them before `start.body.from` runs. */
+    readonly unsupported?: ReadonlyArray<keyof Request & string>;
+    /** Serializable handle. `Generation.token` carries the encoded form so it can be persisted and resumed elsewhere. */
+    readonly token: Schema.Codec<Token, unknown>;
+    readonly start: {
+        readonly prepare?: Prepare<Request>;
+        readonly body: {
+            readonly from: (request: Request) => Effect.Effect<Body, AIError>;
+        };
+        readonly decode: (response: HttpClientResponse.HttpClientResponse, context: DecodeContext<Request>) => Effect.Effect<Started<Token>, AIError>;
+    };
+    readonly status: {
+        readonly path: (token: Token) => string;
+        readonly decode: (response: HttpClientResponse.HttpClientResponse, context: PollContext<Token>) => Effect.Effect<Snapshot, AIError>;
+    };
+    readonly result: {
+        readonly path: (token: Token) => string;
+        readonly decode: (response: HttpClientResponse.HttpClientResponse, context: PollContext<Token>) => Effect.Effect<Response, AIError>;
+    };
+    readonly cancel?: {
+        readonly method: AuthInput["method"];
+        readonly path: (token: Token) => string;
+    };
+}
+export declare const queued: <Request, Response, Token>(input: Omit<Queued<Request, Response, Token>, "kind">) => Queued<Request, Response, Token>;
+export type Mode = "generate" | "stream";
+export type Addressed<Request> = Request & {
+    readonly mode: Mode;
+};
+export interface ResponseContext<Request> extends DecodeContext<Addressed<Request>> {
+    readonly http: HttpContext;
+}
+/**
+ * One request whose body is parsed incrementally, like LLM protocols: `frames` → `step`* → `finish`. `generate` and
+ * `stream` share this state machine; `request.mode` lets a protocol pick a different body, path, or framing.
+ */
+export interface Streamed<Request, Event, Frame, State> {
+    readonly kind: "stream";
+    readonly id: string;
+    readonly name: string;
+    /** Common request fields this protocol cannot lower; the route rejects them before `body.from` runs. */
+    readonly unsupported?: ReadonlyArray<keyof Request & string>;
+    readonly body: {
+        readonly from: (request: Addressed<Request>) => Effect.Effect<Body, AIError>;
+    };
+    readonly frames: (bytes: Stream.Stream<Uint8Array, AIError>, context: DecodeContext<Addressed<Request>>) => Stream.Stream<Frame, AIError>;
+    readonly initial: () => State;
+    readonly step: (state: State, frame: Frame) => Effect.Effect<readonly [State, ReadonlyArray<Event>], AIError>;
+    /** Emit exactly one terminal event, or fail when the provider stopped before completing. */
+    readonly finish: (state: State, context: ResponseContext<Request>) => Effect.Effect<ReadonlyArray<Event>, AIError>;
+}
+export declare const stream: <Request, Event, Frame, State>(input: Omit<Streamed<Request, Event, Frame, State>, "kind">) => Streamed<Request, Event, Frame, State>;
+/**
+ * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
+ * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
+ * provider-side, `cancelled`/`expired` mean the result will never exist); `contentPolicy` is a moderated result.
+ */
 export declare const text: (route: string, name: string, response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
     body: string;
     http: HttpContext;
     invalid: (message: string, cause?: unknown) => AIError;
+    ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
+    contentPolicy: (message: string) => AIError;
 }, AIError, never>;
+export type Output = Effect.Success<ReturnType<typeof text>>;
 /** Read and Schema-decode a JSON body. Decode failures keep the raw body as `reason.body`. */
 export declare const decodeJson: <A>(route: string, name: string, schema: Schema.Codec<A, unknown>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
     value: A;
     body: string;
     http: HttpContext;
     invalid: (message: string, cause?: unknown) => AIError;
+    ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
+    contentPolicy: (message: string) => AIError;
 }, AIError, never>;
+/** Decode a submission response into the token and first snapshot. */
+export declare const decodeStarted: <A, Token>(route: string, name: string, schema: Schema.Codec<A, unknown>, started: (value: A) => Started<Token>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<Started<Token>, AIError, never>;
+/** Map a provider status string through the protocol's table; unknown values are an invalid provider document. */
+export declare const status: <Table extends Record<string, Status>>(table: Table, raw: string, output: Output) => Effect.Effect<Status, AIError>;
+export declare const frameError: (route: string, message: string, body?: string, cause?: unknown) => AIError;
+export declare const incomplete: (route: string) => AIError;
+/** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
+export declare const decodeFrame: <A>(route: string, name: string, schema: Schema.Codec<A, unknown>) => (frame: string) => Effect.Effect<A, AIError, never>;
+/** A `url` asset whose provider-declared retention window starts now. */
+export declare const expiringUrl: (url: string, retention: Duration.Duration, options?: Parameters<typeof Media.url>[1]) => Effect.Effect<Media.Asset, never, never>;
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media-protocol.js

@@ -1,17 +1,40 @@
-import { Effect, Schema } from "effect";
+import { Clock, Duration, Effect, Schema } from "effect";
 import { HttpClientResponse } from "effect/unstable/http";
-import { AIError, HttpContext, InvalidProviderOutputError } from "../schema/index.js";
-export const json = (value) => ({ type: "json", value });
+import { Media } from "../media.js";
+import { AIError, ContentPolicyError, HttpContext, InvalidProviderOutputError, InvalidRequestError, ProviderInternalError, } from "../schema/index.js";
+export const json = (value, query) => ({
+    type: "json",
+    value,
+    query,
+});
 export const multipart = (value) => ({ type: "multipart", value });
+export const binary = (value, contentType, query) => ({
+    type: "binary",
+    value,
+    contentType,
+    query,
+});
 export const inline = (input) => ({
     kind: "inline",
     ...input,
 });
+export const queued = (input) => ({
+    kind: "queued",
+    ...input,
+});
+export const stream = (input) => ({
+    kind: "stream",
+    ...input,
+});
 // ---------------------------------------------------------------------------
 // Response helpers
 // ---------------------------------------------------------------------------
 const context = (response) => new HttpContext({ url: response.request.url, status: response.status, headers: response.headers });
-/** Read a text body while retaining the original payload and HTTP context on every downstream error. */
+/**
+ * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
+ * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
+ * provider-side, `cancelled`/`expired` mean the result will never exist); `contentPolicy` is a moderated result.
+ */
 export const text = Effect.fn("MediaProtocol.text")(function* (route, name, response) {
     const http = context(response);
     const body = yield* response.text.pipe(Effect.mapError((cause) => new AIError({
@@ -26,6 +49,12 @@ export const text = Effect.fn("MediaProtocol.text")(function* (route, name, resp
         body,
         http,
         invalid: (message, cause) => new AIError({ reason: new InvalidProviderOutputError({ route, message, body, http, cause }) }),
+        ended: (status, message) => new AIError({
+            reason: status === "failed"
+                ? new ProviderInternalError({ message, body, http })
+                : new InvalidRequestError({ message, body, http }),
+        }),
+        contentPolicy: (message) => new AIError({ reason: new ContentPolicyError({ message, body, http }) }),
     };
 });
 /** Read and Schema-decode a JSON body. Decode failures keep the raw body as `reason.body`. */
@@ -37,4 +66,31 @@ export const decodeJson = (route, name, schema) => {
         return { ...output, value };
     });
 };
+/** Decode a submission response into the token and first snapshot. */
+export const decodeStarted = (route, name, schema, started) => {
+    const decode = decodeJson(route, name, schema);
+    return (response) => decode(response).pipe(Effect.map((output) => started(output.value)));
+};
+/** Map a provider status string through the protocol's table; unknown values are an invalid provider document. */
+export const status = (table, raw, output) => {
+    const normalized = table[raw];
+    if (normalized === undefined)
+        return Effect.fail(output.invalid(`Unknown generation status "${raw}"`));
+    return Effect.succeed(normalized);
+};
+export const frameError = (route, message, body, cause) => new AIError({ reason: new InvalidProviderOutputError({ route, message, body, cause }) });
+export const incomplete = (route) => new AIError({
+    reason: new InvalidProviderOutputError({
+        route,
+        message: "The provider response ended unexpectedly.",
+        classification: "incomplete-stream",
+    }),
+});
+/** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
+export const decodeFrame = (route, name, schema) => {
+    const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema));
+    return (frame) => decode(frame).pipe(Effect.mapError((cause) => frameError(route, `${name} sent an invalid stream event`, frame, cause)));
+};
+/** A `url` asset whose provider-declared retention window starts now. */
+export const expiringUrl = (url, retention, options) => Clock.currentTimeMillis.pipe(Effect.map((now) => Media.url(url, { ...options, expiresAt: now + Duration.toMillis(retention) })));
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media.d.ts

@@ -1,8 +1,9 @@
-import { Effect } from "effect";
+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, 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. */
@@ -22,25 +23,75 @@ export interface ModelInput {
     readonly headers?: Record<string, string>;
     readonly http?: HttpOptions;
 }
+/** One request, one response. */
 export interface Route<Request extends MediaRequest, Response> {
+    readonly kind: "inline";
     readonly id: string;
     readonly provider: ProviderID;
     readonly protocol: string;
     readonly generate: (request: Request, execute: Execute) => Effect.Effect<Response, AIError>;
 }
-export interface MakeInput<Request extends MediaRequest, Response> {
+/** Submit, then poll through the returned `Generation`. */
+export interface QueuedRoute<Request extends MediaRequest, Response> {
+    readonly kind: "queued";
+    readonly id: string;
+    readonly provider: ProviderID;
+    readonly protocol: string;
+    readonly start: (request: Request, execute: Execute) => Effect.Effect<Generation<Response>, AIError>;
+    /** Rebuild a handle from a persisted `Generation.token`; fails typed when the token is not this route's. */
+    readonly resume: (model: MediaRequest["model"], token: unknown, execute: Execute) => Effect.Effect<Generation<Response>, AIError>;
+}
+/** One request whose response parses into events; `generate` runs the same stream and collects it. */
+export interface StreamRoute<Request extends MediaRequest, Event, Response> {
+    readonly kind: "stream";
+    readonly id: string;
+    readonly provider: ProviderID;
+    readonly protocol: string;
+    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;
-    readonly protocol: MediaProtocol.Inline<Request, Response>;
     readonly endpoint: Endpoint.Definition<MediaProtocol.Body, Request>;
     readonly auth: Auth.Definition;
     /** Deployment headers applied before transport authentication. */
     readonly headers?: Record<string, string>;
 }
+export interface InlineInput<Request extends MediaRequest, Response> extends Composition<Request> {
+    readonly protocol: MediaProtocol.Inline<Request, Response>;
+}
+export interface QueuedInput<Request extends MediaRequest, Response, Token> extends Composition<Request> {
+    readonly protocol: MediaProtocol.Queued<Request, Response, Token>;
+}
+export interface StreamInput<Request extends MediaRequest, Event, Response, Frame, State> extends Composition<MediaProtocol.Addressed<Request>> {
+    readonly protocol: MediaProtocol.Streamed<Request, Event, Frame, State>;
+    readonly collect: (events: ReadonlyArray<Event>) => Effect.Effect<Response, AIError>;
+}
 /**
  * Compose an inline media protocol with an endpoint and auth into a runnable route. The route owns the transport
- * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field rejection, URL and query
- * rendering, auth headers, JSON vs multipart encoding, and handing the response back to the protocol for decoding.
+ * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field
+ * rejection, URL and query rendering, auth headers, JSON, multipart, or binary encoding, and handing responses back
+ * to the protocol.
+ */
+export declare const inline: <Request extends MediaRequest, Response>(input: InlineInput<Request, Response>) => Route<Request, Response>;
+/**
+ * Compose a queued media protocol the same way, adding `start`/`resume` handles whose polls reuse the route's auth,
+ * deployment headers, and (for `start`) the request's `http` overlay. The token is decoded once at the boundary and
+ * closed over by the resulting `Generation.Route`.
  */
-export declare const make: <Request extends MediaRequest, Response>(input: MakeInput<Request, Response>) => Route<Request, Response>;
+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";