@opencode/ai 0.0.0-dev-20122 → 0.0.0-dev-20124

package/dist/providers/minimax.d.ts

@@ -249,20 +249,20 @@ export declare const routes: (Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
+        readonly display?: import("../schema/options.js").OpenString<"summarized" | "omitted"> | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
+            readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
+        readonly display?: import("../schema/options.js").OpenString<"summarized" | "omitted"> | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
+            readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
+    readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "standard_only"> | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/moonshot.d.ts

@@ -247,20 +247,20 @@ export declare const routes: (Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
+        readonly display?: import("../schema/options.js").OpenString<"summarized" | "omitted"> | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
+            readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
+        readonly display?: import("../schema/options.js").OpenString<"summarized" | "omitted"> | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
+            readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
+    readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "standard_only"> | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/openai.d.ts

@@ -1,10 +1,9 @@
 import { type ProviderAuthOption } from "../route/auth-options.js";
 import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js";
 import type { ProviderPackage } from "../provider-package.js";
-import { ToolDefinition, type ModelID } from "../schema/index.js";
+import { ToolDefinition, type ModelID, type OpenString } from "../schema/index.js";
 import * as OpenAIResponses from "../protocols/openai-responses.js";
 import { type OpenAIProviderOptionsInput } from "./openai-options.js";
-import { type OpenAIImageString } from "../protocols/openai-images.js";
 export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options.js";
 export type { OpenAIImageOptions } from "../protocols/openai-images.js";
 export type { OpenAISpeechOptions } from "../protocols/openai-speech.js";
@@ -357,14 +356,14 @@ export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly providerOptions?: OpenAIProviderOptionsInput;
 };
 export interface ImageGenerationOptions {
-    readonly action?: OpenAIImageString<"auto" | "generate" | "edit">;
-    readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">;
-    readonly inputFidelity?: OpenAIImageString<"low" | "high">;
+    readonly action?: OpenString<"auto" | "generate" | "edit">;
+    readonly background?: OpenString<"auto" | "opaque" | "transparent">;
+    readonly inputFidelity?: OpenString<"low" | "high">;
     readonly outputCompression?: number;
-    readonly outputFormat?: OpenAIImageString<"png" | "jpeg" | "webp">;
+    readonly outputFormat?: OpenString<"png" | "jpeg" | "webp">;
     readonly partialImages?: number;
-    readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
-    readonly size?: OpenAIImageString<"auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792">;
+    readonly quality?: OpenString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
+    readonly size?: OpenString<"auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792">;
 }
 export declare const imageGeneration: (options?: ImageGenerationOptions) => ToolDefinition;
 export type Settings = ProviderPackage.Settings & OpenAIProviderOptionsInput & {

package/dist/providers/openai.js

@@ -1,5 +1,6 @@
 import { AuthOptions } from "../route/auth-options.js";
-import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions } from "../schema/index.js";
+import { MediaRoute } from "../route/media.js";
+import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, } from "../schema/index.js";
 import * as OpenAIChat from "../protocols/openai-chat.js";
 import * as OpenAIResponses from "../protocols/openai-responses.js";
 import { withOpenAIOptions } from "./openai-options.js";
@@ -46,16 +47,14 @@ export const configure = (input = {}) => {
         id,
         compatibility: { supportsPromptCacheKey: true },
     });
-    const media = (modelID) => ({
-        id: modelID,
-        auth: auth(input),
-        baseURL: input.baseURL,
-        headers: input.headers,
-        http: mergeHttpOptions(input.http === undefined ? undefined : HttpOptions.make(input.http), input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams })),
-    });
-    const image = (modelID) => OpenAIImages.model(media(modelID));
-    const speech = (modelID) => OpenAISpeech.model(media(modelID));
-    const transcription = (modelID) => OpenAITranscription.model(media(modelID));
+    const deployment = MediaRoute.deployment(input, auth(input));
+    const media = {
+        ...deployment,
+        http: mergeHttpOptions(deployment.http, input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams })),
+    };
+    const image = (modelID) => OpenAIImages.model({ ...media, id: modelID });
+    const speech = (modelID) => OpenAISpeech.model({ ...media, id: modelID });
+    const transcription = (modelID) => OpenAITranscription.model({ ...media, id: modelID });
     return {
         id,
         model: responses,

package/dist/providers/opencode-zen.js

@@ -11,7 +11,7 @@ export const configure = (input = {}) => {
         auth: AuthOptions.bearer(input, "OPENCODE_API_KEY"),
         baseURL: input.baseURL ?? baseURL,
         headers: input.headers,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
     return { id, experimental: { evaluation }, configure };
 };

package/dist/providers/openrouter.d.ts

@@ -2,21 +2,20 @@ import { Schema } from "effect";
 import { Route, type RouteDefaultsInput } from "../route/client.js";
 import { Protocol } from "../route/protocol.js";
 import { type ProviderAuthOption } from "../route/auth-options.js";
-import { type ModelID } from "../schema/index.js";
+import { type ModelID, type OpenString } from "../schema/index.js";
 import type { ProviderPackage } from "../provider-package.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-type OpenRouterString<Known extends string> = Known | (string & {});
 export interface OpenRouterProviderRouting {
     readonly [key: string]: unknown;
     readonly order?: ReadonlyArray<string>;
     readonly allow_fallbacks?: boolean;
     readonly require_parameters?: boolean;
-    readonly data_collection?: OpenRouterString<"allow" | "deny">;
+    readonly data_collection?: OpenString<"allow" | "deny">;
     readonly only?: ReadonlyArray<string>;
     readonly ignore?: ReadonlyArray<string>;
     readonly quantizations?: ReadonlyArray<string>;
-    readonly sort?: OpenRouterString<"price" | "throughput" | "latency">;
+    readonly sort?: OpenString<"price" | "throughput" | "latency">;
     readonly max_price?: Readonly<{
         prompt?: number | string;
         completion?: number | string;
@@ -30,7 +29,7 @@ export type OpenRouterPlugin = Readonly<{
     id: "web";
     max_results?: number;
     search_prompt?: string;
-    engine?: OpenRouterString<"native" | "exa">;
+    engine?: OpenString<"native" | "exa">;
 }> | Readonly<{
     id: "file-parser";
     max_files?: number;
@@ -59,7 +58,7 @@ export interface OpenRouterOptions {
     readonly reasoning?: Readonly<{
         enabled?: boolean;
         exclude?: boolean;
-        effort?: OpenRouterString<"none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
+        effort?: OpenString<"none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
         max_tokens?: number;
     }>;
     readonly usage?: boolean | Readonly<{
@@ -69,7 +68,7 @@ export interface OpenRouterOptions {
     readonly web_search_options?: Readonly<{
         max_results?: number;
         search_prompt?: string;
-        engine?: OpenRouterString<"native" | "exa">;
+        engine?: OpenString<"native" | "exa">;
     }>;
 }
 export type OpenRouterProviderOptionsInput = OpenRouterOptions;

package/dist/providers/openrouter.js

@@ -106,7 +106,7 @@ export const configure = (input = {}) => {
         auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
         baseURL: input.baseURL ?? baseURL,
         headers: input.headers,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
     return {
         id,

package/dist/providers/replicate.d.ts

@@ -1,5 +1,5 @@
 import { type ProviderAuthOption } from "../route/auth-options.js";
-import { HttpOptions, type ModelID } from "../schema/index.js";
+import { type HttpOptions, type ModelID } from "../schema/index.js";
 export type { ReplicateImageOptions } from "../protocols/replicate-images.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = ProviderAuthOption<"optional"> & {

package/dist/providers/replicate.js

@@ -1,17 +1,12 @@
 import { AuthOptions } from "../route/auth-options.js";
-import { HttpOptions, ProviderID } from "../schema/index.js";
-import { DEFAULT_BASE_URL, ReplicateImages } from "../protocols/replicate-images.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID } from "../schema/index.js";
+import { ReplicateImages } from "../protocols/replicate-images.js";
 export const id = ProviderID.make("replicate");
-const baseURL = DEFAULT_BASE_URL;
 const auth = (options) => AuthOptions.bearer(options, "REPLICATE_API_TOKEN");
 export const configure = (input = {}) => {
-    const image = (modelID) => ReplicateImages.model({
-        id: modelID,
-        auth: auth(input),
-        baseURL: input.baseURL ?? baseURL,
-        headers: input.headers,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    });
+    const media = MediaRoute.deployment(input, auth(input));
+    const image = (modelID) => ReplicateImages.model({ ...media, id: modelID });
     return {
         id,
         image,

package/dist/providers/runway.d.ts

@@ -1,5 +1,5 @@
 import { type ProviderAuthOption } from "../route/auth-options.js";
-import { HttpOptions, type ModelID } from "../schema/index.js";
+import { type HttpOptions, type ModelID } from "../schema/index.js";
 export type { RunwayVideoOptions } from "../protocols/runway-video.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = ProviderAuthOption<"optional"> & {

package/dist/providers/runway.js

@@ -1,17 +1,12 @@
 import { AuthOptions } from "../route/auth-options.js";
-import { HttpOptions, ProviderID } from "../schema/index.js";
-import { DEFAULT_BASE_URL, RunwayVideo } from "../protocols/runway-video.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID } from "../schema/index.js";
+import { RunwayVideo } from "../protocols/runway-video.js";
 export const id = ProviderID.make("runway");
-const baseURL = DEFAULT_BASE_URL;
 const auth = (options) => AuthOptions.bearer(options, "RUNWAYML_API_SECRET");
 export const configure = (input = {}) => {
-    const video = (modelID) => RunwayVideo.model({
-        id: modelID,
-        auth: auth(input),
-        baseURL: input.baseURL ?? baseURL,
-        headers: input.headers,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    });
+    const media = MediaRoute.deployment(input, auth(input));
+    const video = (modelID) => RunwayVideo.model({ ...media, id: modelID });
     return {
         id,
         video,

package/dist/providers/stability.d.ts

@@ -1,5 +1,5 @@
 import { type ProviderAuthOption } from "../route/auth-options.js";
-import { HttpOptions, type ModelID } from "../schema/index.js";
+import { type 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"> & {

package/dist/providers/stability.js

@@ -1,20 +1,15 @@
 import { AuthOptions } from "../route/auth-options.js";
-import { HttpOptions, ProviderID } from "../schema/index.js";
-import { DEFAULT_BASE_URL, StabilityImages } from "../protocols/stability-images.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID } from "../schema/index.js";
+import { 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),
-    };
+    const media = MediaRoute.deployment(input, auth(input));
     return {
         id,
-        image: (modelID) => StabilityImages.model({ ...deployment, id: modelID }),
-        upscale: () => StabilityImages.upscaleModel(deployment),
+        image: (modelID) => StabilityImages.model({ ...media, id: modelID }),
+        upscale: () => StabilityImages.upscaleModel(media),
         configure,
     };
 };

package/dist/providers/typesafe-ai.js

@@ -11,7 +11,7 @@ export const configure = (input = {}) => {
         auth: AuthOptions.bearer(input, "TYPESAFE_API_KEY"),
         baseURL: input.baseURL ?? baseURL,
         headers: input.headers,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
     return { id, experimental: { evaluation }, configure };
 };

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

@@ -26,7 +26,7 @@ export const configure = (input = {}) => {
     const evaluation = (modelID) => EvaluationModel.make({
         id: modelID,
         provider: id,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
         route: {
             id: "vercel-evaluation",
             evaluate: (req, send) => Effect.gen(function* () {

package/dist/providers/xai.js

@@ -1,7 +1,8 @@
 import { AuthOptions } from "../route/auth-options.js";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
-import { HttpOptions, ProviderID } from "../schema/index.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID } from "../schema/index.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
 import { OpenResponsesChannel } from "../protocols/open-responses-channel.js";
 import { XAIResponses } from "../protocols/xai-responses.js";
@@ -60,20 +61,14 @@ export const configure = (input = {}) => {
     const chatRoute = configuredChatRoute(input);
     const responses = (modelID) => responsesRoute.model({ id: modelID });
     const chat = (modelID) => chatRoute.model({ id: modelID });
-    const media = (modelID) => ({
-        id: modelID,
-        auth: auth(input),
-        baseURL: input.baseURL ?? baseURL,
-        headers: input.headers,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    });
+    const media = MediaRoute.deployment(input, auth(input));
     return {
         id,
         model: responses,
         responses,
         chat,
-        image: (modelID) => XAIImages.model(media(modelID)),
-        video: (modelID) => XAIVideo.model(media(modelID)),
+        image: (modelID) => XAIImages.model({ ...media, id: modelID }),
+        video: (modelID) => XAIVideo.model({ ...media, id: modelID }),
         configure,
     };
 };

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

@@ -520,7 +520,7 @@ export declare const routes: (Route<{
     readonly thinking?: {
         readonly type: string;
     } | undefined;
-    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
+    readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "standard_only"> | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/providers/zai.js

@@ -4,7 +4,8 @@ import { OpenAIChat } from "../protocols/openai-chat.js";
 import { AuthOptions } from "../route/auth-options.js";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
-import { HttpOptions, ProviderID } from "../schema/index.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID } from "../schema/index.js";
 export const id = ProviderID.make("zai");
 const auth = (options) => AuthOptions.bearer(options, "ZAI_API_KEY");
 const chatRoute = Route.make({
@@ -25,13 +26,8 @@ export const configure = (input = {}) => {
         auth: auth(input),
     })
         .model({ id: modelID, compatibility: ZAIChat.compatibility });
-    const image = (modelID) => ZAIImages.model({
-        id: modelID,
-        auth: auth(input),
-        baseURL: input.baseURL,
-        headers: input.headers,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    });
+    const media = MediaRoute.deployment(input, auth(input));
+    const image = (modelID) => ZAIImages.model({ ...media, id: modelID });
     return {
         id,
         model: chat,

package/dist/route/client.d.ts

@@ -71,7 +71,6 @@ export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
 }
 type RouteMappedLanguageModelInput = RouteLanguageModelInput | RouteRoutedLanguageModelInput;
 export declare const generationOptions: (input: GenerationOptions.Input | undefined) => GenerationOptions | undefined;
-export declare const httpOptions: (input: HttpOptionsInput | undefined) => HttpOptions | undefined;
 export interface Interface {
     readonly compact: CompactMethod;
     readonly stream: StreamMethod;

package/dist/route/client.js

@@ -33,7 +33,7 @@ const mergeRouteDefaults = (base, patch) => {
         headers,
         generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
         providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
-        http: mergeHttpOptions(base?.http, httpOptions(patch.http), headers === undefined ? undefined : new HttpOptions({ headers })),
+        http: mergeHttpOptions(base?.http, HttpOptions.make(patch.http), headers === undefined ? undefined : new HttpOptions({ headers })),
     };
 };
 const endpointBaseURL = (endpoint) => typeof endpoint.baseURL === "string" ? endpoint.baseURL : undefined;
@@ -44,11 +44,6 @@ const mergeHeaders = (...items) => {
     return Object.fromEntries(entries);
 };
 export const generationOptions = (input) => input === undefined ? undefined : GenerationOptions.make(input);
-export const httpOptions = (input) => {
-    if (input === undefined)
-        return input;
-    return HttpOptions.make(input);
-};
 export function canCompact(request, options) {
     if (options?.mechanism === "trigger")
         return request.model.route.compact?.trigger !== undefined;

package/dist/route/endpoint.d.ts

@@ -24,5 +24,6 @@ export type EndpointPatch<Body, Request = LLMRequest> = Partial<Definition<Body,
 /** Construct an `Endpoint` from a path string or path function. */
 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 trimBaseUrl: (value: string) => string;
 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/endpoint.js

@@ -1,4 +1,3 @@
-import * as ProviderShared from "../protocols/shared.js";
 /** Construct an `Endpoint` from a path string or path function. */
 export const path = (value, options = {}) => ({
     ...options,
@@ -11,9 +10,10 @@ export const merge = (base, patch) => ({
     path: patch.path ?? base.path,
     query: patch.query === undefined ? base.query : { ...base.query, ...patch.query },
 });
+export const trimBaseUrl = (value) => value.replace(/\/+$/, "");
 const renderPart = (part, input) => typeof part === "function" ? part(input) : part;
 export const render = (endpoint, input) => {
-    const url = new URL(`${ProviderShared.trimBaseUrl(endpoint.baseURL ?? "")}${renderPart(endpoint.path, input)}`);
+    const url = new URL(`${trimBaseUrl(endpoint.baseURL ?? "")}${renderPart(endpoint.path, input)}`);
     for (const [key, value] of Object.entries(endpoint.query ?? {}))
         url.searchParams.set(key, value);
     return url;

package/dist/route/framing.d.ts

@@ -1,5 +1,5 @@
 import { Stream } from "effect";
-import type { AIError } from "../schema/index.js";
+import { AIError } from "../schema/index.js";
 /**
  * Decode a streaming HTTP response body into provider-protocol frames.
  *
@@ -22,6 +22,15 @@ export interface Definition<Frame> {
     /** Original wire representation when framing transforms the provider payload. */
     readonly body?: (frame: Frame) => string | undefined;
 }
+/**
+ * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
+ * decoder, optionally filters named events, and drops empty events and known
+ * keepalives that proxies send as data. `[DONE]` is dropped by default or
+ * retained for protocols that use it as their stream boundary. Retry control events are ignored without
+ * interrupting the stream. Decoder failures become provider output errors so
+ * the public error channel stays `AIError`.
+ */
+export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>, events?: ReadonlySet<string>, includeDone?: boolean) => Stream.Stream<string, AIError>;
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export declare const sse: Definition<string>;
 /** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */

package/dist/route/framing.js

@@ -1,16 +1,56 @@
-import { Stream } from "effect";
-import * as ProviderShared from "../protocols/shared.js";
+import { Effect, Stream } from "effect";
+import { makeParser } from "effect/unstable/encoding/Sse";
+import { AIError, InvalidProviderOutputError } from "../schema/index.js";
+/**
+ * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
+ * decoder, optionally filters named events, and drops empty events and known
+ * keepalives that proxies send as data. `[DONE]` is dropped by default or
+ * retained for protocols that use it as their stream boundary. Retry control events are ignored without
+ * interrupting the stream. Decoder failures become provider output errors so
+ * the public error channel stays `AIError`.
+ */
+export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Stream.decodeText(), Stream.mapAccumEffect(() => {
+    const output = [];
+    return {
+        output,
+        parser: makeParser((event) => {
+            if (event._tag === "Event")
+                output.push(event);
+        }),
+    };
+}, (state, chunk) => Effect.gen(function* () {
+    const error = state.parser.feed(chunk);
+    if (error)
+        return yield* new AIError({
+            reason: new InvalidProviderOutputError({
+                route: "sse",
+                message: error.message,
+                body: chunk,
+                cause: error,
+            }),
+        });
+    return [state, state.output.splice(0)];
+})), Stream.filter((event) => (events === undefined || events.has(event.event)) &&
+    event.data.length > 0 &&
+    // Some OpenAI-compatible proxies serialize an empty flush as a bare
+    // `data: null`, between events or after `[DONE]`. No protocol has a
+    // null event, so it carries nothing and must not abort the stream.
+    event.data !== "null" &&
+    // Vertex AI partner models (e.g. `xai/grok-4.6`) send their SSE
+    // keepalive comment as `data: : keepalive` while reasoning.
+    event.data !== ": keepalive" &&
+    (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
-export const sse = { id: "sse", frame: ProviderShared.sseFraming };
+export const sse = { id: "sse", frame: sseFraming };
 /** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */
 export const sseWithDone = {
     id: "sse",
-    frame: (bytes) => ProviderShared.sseFraming(bytes, undefined, true),
+    frame: (bytes) => sseFraming(bytes, undefined, true),
 };
 /** SSE framing restricted to protocol-recognized event names. */
 export const sseEvents = (events) => ({
     id: "sse",
-    frame: (bytes) => ProviderShared.sseFraming(bytes, events),
+    frame: (bytes) => sseFraming(bytes, events),
 });
 export const lines = {
     id: "lines",