@opencode/ai 2.0.14 → 2.0.16

package/dist/providers/togetherai.d.ts

@@ -28,6 +28,12 @@ export declare const route: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -43,6 +49,12 @@ export declare const route: Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;
@@ -127,6 +139,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";
@@ -142,6 +160,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;

package/dist/providers/vercel-ai-gateway.d.ts

@@ -0,0 +1,41 @@
+import { EvaluationModel } from "../experimental/evaluation.js";
+import { type ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, ModelID } from "../schema/index.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export interface EvaluationOptions {
+    readonly [key: string]: unknown;
+    readonly gateway?: Readonly<{
+        readonly [key: string]: unknown;
+        readonly zeroDataRetention?: boolean;
+        readonly only?: ReadonlyArray<string>;
+    }>;
+}
+export type Options = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Options) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+    };
+    configure: (input?: Options) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+    };
+    configure: (input?: Options) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        experimental: {
+            evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+        };
+        configure: /*elided*/ any;
+    };
+};
+export declare const experimental: {
+    evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+};
+export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway.js

@@ -0,0 +1,85 @@
+import { Effect, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationQuestion, EvaluationResponse, EvaluationRounding, } from "../experimental/evaluation.js";
+import { Auth } from "../route/auth.js";
+import { AuthOptions } from "../route/auth-options.js";
+import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, ProviderID, ProviderMetadata, Usage, } from "../schema/index.js";
+export const id = ProviderID.make("vercel-ai-gateway");
+const baseURL = "https://ai-gateway.vercel.sh/v1";
+const Request = Schema.StructWithRest(Schema.Struct({
+    model: Schema.String,
+    state: EvaluationInput,
+    questions: Schema.Record(Schema.String, EvaluationQuestion),
+    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}), [Schema.Record(Schema.String, Schema.Any)]);
+const Response = Schema.Struct({
+    model: Schema.optional(Schema.String),
+    answers: Schema.Record(Schema.String, EvaluationAnswer),
+    usage: Schema.optional(Schema.Struct({
+        inputTokens: Schema.optional(Schema.Number),
+        outputTokens: Schema.optional(Schema.Number),
+    })),
+    rounding: Schema.optional(EvaluationRounding),
+    providerMetadata: Schema.optional(ProviderMetadata),
+});
+export const configure = (input = {}) => {
+    const evaluation = (modelID) => EvaluationModel.make({
+        id: modelID,
+        provider: id,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        route: {
+            id: "vercel-evaluation",
+            evaluate: (req, send) => Effect.gen(function* () {
+                const url = new URL(`${(input.baseURL ?? baseURL).replace(/\/$/, "")}/evaluate`);
+                Object.entries(req.http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value));
+                const body = yield* Schema.encodeUnknownEffect(Schema.fromJsonString(Request))({
+                    ...req.http?.body,
+                    model: req.model.id,
+                    state: req.state,
+                    questions: req.questions,
+                    providerOptions: req.options,
+                }).pipe(Effect.mapError((cause) => new AIError({ reason: new InvalidRequestError({ message: cause.message, cause }) })));
+                const headers = yield* Auth.toEffect(AuthOptions.bearer(input, ["AI_GATEWAY_API_KEY", "VERCEL_OIDC_TOKEN"]))({
+                    request: req,
+                    method: "POST",
+                    url: url.toString(),
+                    body,
+                    headers: Headers.fromInput({ ...input.headers, ...req.http?.headers }),
+                });
+                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: "vercel-evaluation",
+                        message,
+                        body,
+                        http,
+                        cause,
+                    }),
+                });
+                const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the Vercel AI Gateway evaluation response", cause)));
+                const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("Vercel AI Gateway returned an invalid evaluation response", cause, text)));
+                return new EvaluationResponse({
+                    model: ModelID.make(data.model ?? req.model.id),
+                    answers: data.answers,
+                    usage: data.usage
+                        ? new Usage({
+                            inputTokens: data.usage.inputTokens,
+                            outputTokens: data.usage.outputTokens,
+                            totalTokens: data.usage.inputTokens === undefined && data.usage.outputTokens === undefined
+                                ? undefined
+                                : (data.usage.inputTokens ?? 0) + (data.usage.outputTokens ?? 0),
+                            providerMetadata: { gateway: data.usage },
+                        })
+                        : undefined,
+                    rounding: data.rounding,
+                    providerMetadata: data.providerMetadata,
+                });
+            }),
+        },
+    });
+    return { id, experimental: { evaluation }, configure };
+};
+export const provider = configure();
+export const experimental = provider.experimental;
+export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/providers/xai.d.ts

@@ -16,6 +16,7 @@ export type Settings = ProviderPackage.Settings & XAIProviderOptionsInput & {
     readonly baseURL?: string;
 };
 export type { XAIImageOptions } from "../protocols/xai-images.js";
+export type { XAIVideoOptions } from "../protocols/xai-video.js";
 declare const responsesRoute: Route<unknown, import("../protocols/open-responses-channel.js").Prepared, {
     endpoint: import("../route/client.js").CompactOperation;
 }>;
@@ -35,6 +36,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";
@@ -50,6 +57,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;
@@ -130,6 +143,7 @@ export declare const configure: (input?: LanguageModelOptions) => {
     }>;
     chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/xai-video.js").XAIVideoOptions>;
     configure: (input?: LanguageModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
@@ -142,6 +156,7 @@ export declare const provider: {
     }>;
     chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/xai-video.js").XAIVideoOptions>;
     configure: (input?: LanguageModelOptions) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, {
@@ -152,6 +167,7 @@ export declare const provider: {
         }>;
         chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
+        video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/xai-video.js").XAIVideoOptions>;
         configure: /*elided*/ any;
     };
 };
@@ -161,3 +177,4 @@ export declare const responses: (modelID: string | ModelID) => import("../schema
 }>;
 export declare const chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
+export declare const video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/xai-video.js").XAIVideoOptions>;

package/dist/providers/xai.js

@@ -6,6 +6,7 @@ import { OpenAIChat } from "../protocols/openai-chat.js";
 import { OpenResponsesChannel } from "../protocols/open-responses-channel.js";
 import { XAIResponses } from "../protocols/xai-responses.js";
 import { XAIImages } from "../protocols/xai-images.js";
+import { XAIVideo } from "../protocols/xai-video.js";
 export const id = ProviderID.make("xai");
 const baseURL = "https://api.x.ai/v1";
 const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000;
@@ -59,7 +60,7 @@ export const configure = (input = {}) => {
     const chatRoute = configuredChatRoute(input);
     const responses = (modelID) => responsesRoute.model({ id: modelID });
     const chat = (modelID) => chatRoute.model({ id: modelID });
-    const image = (modelID) => XAIImages.model({
+    const media = (modelID) => ({
         id: modelID,
         auth: auth(input),
         baseURL: input.baseURL ?? baseURL,
@@ -71,7 +72,8 @@ export const configure = (input = {}) => {
         model: responses,
         responses,
         chat,
-        image,
+        image: (modelID) => XAIImages.model(media(modelID)),
+        video: (modelID) => XAIVideo.model(media(modelID)),
         configure,
     };
 };
@@ -86,3 +88,4 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
 export const responses = provider.responses;
 export const chat = provider.chat;
 export const image = provider.image;
+export const video = provider.video;

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/client.d.ts

@@ -381,6 +381,14 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("../media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -409,12 +417,12 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
 } | {
     readonly type: "provider-error";
     readonly message: string;
+    readonly classification?: "context-overflow" | "payload-too-large" | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly classification?: "context-overflow" | "payload-too-large" | undefined;
 }, AIError, Service>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const Route: {

package/dist/route/endpoint.d.ts

@@ -1,9 +1,9 @@
 import type { LLMRequest } from "../schema/index.js";
-export interface EndpointInput<Body> {
-    readonly request: LLMRequest;
+export interface EndpointInput<Body, Request = LLMRequest> {
+    readonly request: Request;
     readonly body: Body;
 }
-export type EndpointPart<Body> = string | ((input: EndpointInput<Body>) => string);
+export type EndpointPart<Body, Request = LLMRequest> = string | ((input: EndpointInput<Body, Request>) => string);
 /**
  * Declarative URL construction for one route.
  *
@@ -13,16 +13,16 @@ export type EndpointPart<Body> = string | ((input: EndpointInput<Body>) => strin
  *
  * `path` may be a string or a function of `EndpointInput`, for routes whose
  * URL embeds the model id, region, or another body field (e.g. Bedrock,
- * Gemini).
+ * Gemini). Media routes reuse the same shape with their own request type.
  */
-export interface Definition<Body> {
+export interface Definition<Body, Request = LLMRequest> {
     readonly baseURL?: string;
-    readonly path: EndpointPart<Body>;
+    readonly path: EndpointPart<Body, Request>;
     readonly query?: Record<string, string>;
 }
-export type EndpointPatch<Body> = Partial<Definition<Body>>;
+export type EndpointPatch<Body, Request = LLMRequest> = Partial<Definition<Body, Request>>;
 /** Construct an `Endpoint` from a path string or path function. */
-export declare const path: <Body>(value: EndpointPart<Body>, options?: Omit<Definition<Body>, "path">) => Definition<Body>;
-export declare const merge: <Body>(base: Definition<Body>, patch: EndpointPatch<Body>) => Definition<Body>;
-export declare const render: <Body>(endpoint: Definition<Body>, input: EndpointInput<Body>) => URL;
+export declare const path: <Body, Request = LLMRequest>(value: EndpointPart<Body, Request>, options?: Omit<Definition<Body, Request>, "path">) => Definition<Body, Request>;
+export declare const merge: <Body, Request = LLMRequest>(base: Definition<Body, Request>, patch: EndpointPatch<Body, Request>) => Definition<Body, Request>;
+export declare const render: <Body, Request = LLMRequest>(endpoint: Definition<Body, Request>, input: EndpointInput<Body, Request>) => URL;
 export * as Endpoint from "./endpoint.js";

package/dist/route/executor-service.d.ts

@@ -0,0 +1,12 @@
+import { Context, type Effect } from "effect";
+import type { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import type { AIError } from "../schema/errors.js";
+export interface Interface {
+    readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
+}
+export type HttpHandler = (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
+export type HttpMiddleware = (request: HttpClientRequest.HttpClientRequest, handler: HttpHandler) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
+export declare class Service extends Service_base {
+}
+export {};

package/dist/route/executor-service.js

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+export class Service extends Context.Service()("@opencode/AI/RequestExecutor") {
+}

package/dist/route/executor.d.ts

@@ -1,14 +1,9 @@
-import { Context, Effect, Layer, Stream } from "effect";
+import { Layer, Stream } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { HttpContext, AIError } from "../schema/index.js";
-export interface Interface {
-    readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
-}
-export type HttpHandler = (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
-export type HttpMiddleware = (request: HttpClientRequest.HttpClientRequest, handler: HttpHandler) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
-declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
-export declare class Service extends Service_base {
-}
+import { Service, type HttpMiddleware, type Interface } from "./executor-service.js";
+export { Service } from "./executor-service.js";
+export type { HttpHandler, HttpMiddleware, Interface } from "./executor-service.js";
 export declare const responseHttp: (response: HttpClientResponse.HttpClientResponse) => HttpContext;
 /** Preserve HTTP diagnostics for executor and externally captured failures alike. */
 export declare const httpFailure: (input: {

package/dist/route/executor.js

@@ -1,9 +1,9 @@
-import { Cause, Context, Effect, Layer, Option, Schema, Stream } from "effect";
+import { Cause, Effect, Layer, Option, Schema, Stream } from "effect";
 import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/unstable/http";
 import { HttpContext, HttpRateLimitDetails, AIError, TransportError } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
-export class Service extends Context.Service()("@opencode/AI/RequestExecutor") {
-}
+import { Service } from "./executor-service.js";
+export { Service } from "./executor-service.js";
 const headerDetails = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]));
 const normalizedHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
 const retryAfterMs = (headers) => {

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/index.d.ts

@@ -4,6 +4,8 @@ export * from "./executor.js";
 export { Auth } from "./auth.js";
 export { AuthOptions } from "./auth-options.js";
 export { Endpoint } from "./endpoint.js";
+export { MediaRoute } from "./media.js";
+export { MediaProtocol } from "./media-protocol.js";
 export { Framing } from "./framing.js";
 export { Protocol } from "./protocol.js";
 export { HttpTransport, WebSocketTransport } from "./transport/index.js";

package/dist/route/index.js

@@ -3,6 +3,8 @@ export * from "./executor.js";
 export { Auth } from "./auth.js";
 export { AuthOptions } from "./auth-options.js";
 export { Endpoint } from "./endpoint.js";
+export { MediaRoute } from "./media.js";
+export { MediaProtocol } from "./media-protocol.js";
 export { Framing } from "./framing.js";
 export { Protocol } from "./protocol.js";
 export { HttpTransport, WebSocketTransport } from "./transport/index.js";