@opencode/ai 2.0.16 → 2.0.17

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

@@ -4,7 +4,7 @@ import { AIError, type HttpOptions } from "../schema/index.js";
 export declare class MissingCredentialError extends Error {
     readonly source: string;
     readonly _tag = "MissingCredentialError";
-    constructor(source: string);
+    constructor(source: string, message?: string);
 }
 export type CredentialError = MissingCredentialError | Config.ConfigError;
 export type AuthError = CredentialError | AIError;

package/dist/route/auth.js

@@ -1,11 +1,11 @@
-import { Config, Effect, Redacted } from "effect";
+import { Config, Effect, Option, Redacted } from "effect";
 import { Headers } from "effect/unstable/http";
-import { AuthenticationError, InvalidRequestError, AIError } from "../schema/index.js";
+import { AuthenticationError, AIError } from "../schema/index.js";
 export class MissingCredentialError extends Error {
     source;
     _tag = "MissingCredentialError";
-    constructor(source) {
-        super(`Missing auth credential: ${source}`);
+    constructor(source, message = `Missing auth credential: ${source}`) {
+        super(message);
         this.source = source;
     }
 }
@@ -47,7 +47,12 @@ export const value = (secret, source = "value") => credentialFromSecret(secret,
 export const optional = (secret, source = "optional value") => secret === undefined
     ? credential(Effect.fail(new MissingCredentialError(source)))
     : credentialFromSecret(secret, source);
-export const config = (name) => credentialFromSecret(Config.redacted(name), name);
+export const config = (name) => credential(Effect.gen(function* () {
+    const secret = yield* Config.option(Config.redacted(name));
+    if (Option.isSome(secret) && Redacted.value(secret.value) !== "")
+        return secret.value;
+    return yield* Effect.fail(new MissingCredentialError(name, `${name} is not set`));
+}));
 export const effect = (load) => credential(load);
 export const none = auth((input) => Effect.succeed(input.headers));
 export const headers = (input) => auth((inputAuth) => Effect.succeed(Headers.setAll(inputAuth.headers, input)));
@@ -80,14 +85,10 @@ export function scheme(name, source) {
     return render(source);
 }
 const toAIError = (error) => {
-    if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
-        return new AIError({
-            reason: error instanceof MissingCredentialError
-                ? new AuthenticationError({ message: error.message, cause: error })
-                : new InvalidRequestError({ message: `Failed to resolve auth config: ${error.message}`, cause: error }),
-        });
-    }
-    return error;
+    if (error instanceof AIError)
+        return error;
+    const message = error instanceof MissingCredentialError ? error.message : `Failed to resolve auth config: ${error.message}`;
+    return new AIError({ reason: new AuthenticationError({ message, cause: error }) });
 };
 export const toEffect = (input) => (authInput) => input.apply(authInput).pipe(Effect.mapError(toAIError));
 export * as Auth from "./auth.js";

package/dist/route/client.d.ts

@@ -6,7 +6,7 @@ import { Framing } from "./framing.js";
 import { HttpTransport } from "./transport/index.js";
 import type { HttpMiddleware, Transport, TransportRuntime, WebSocketChannelExecutor } from "./transport/index.js";
 import type { Protocol } from "./protocol.js";
-import type { ProtocolID, ProviderOptions } from "../schema/index.js";
+import type { LanguageModelSanitizerCompatibility, ProtocolID, ProviderOptions } from "../schema/index.js";
 import { AIError, CompactionResponse, CompactionCheckpointResponse, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, ProviderID } from "../schema/index.js";
 export interface RouteBody<Body> {
     /** Schema for the validated provider-native body sent as the JSON request. */
@@ -31,6 +31,7 @@ export interface Route<Body, Prepared = unknown, Compact extends CompactionOpera
     readonly defaults: RouteDefaults;
     readonly body: RouteBody<Body>;
     readonly supportsEffortUpdates?: (request: LLMRequest) => boolean;
+    readonly sanitizer?: LanguageModelSanitizerCompatibility;
     readonly with: {
         <Next extends CompactionOperations | undefined>(patch: RoutePatch<Body, Prepared> & {
             readonly compact: Next;
@@ -71,7 +72,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;
@@ -121,9 +121,11 @@ export declare function canCompact(request: LLMRequest, options?: {
 export declare function canCompact(request: LLMRequest, options: {
     readonly mechanism: "trigger";
 }): request is CheckpointRequest;
-declare const Service_base: Context.ServiceClass<Service, "@opencode/LLMClient", Interface>;
-export declare class Service extends Service_base {
+declare const LLMClientService_base: Context.ServiceClass<LLMClientService, "@opencode/LLMClient", Interface>;
+export declare class LLMClientService extends LLMClientService_base {
 }
+export declare const Service: typeof LLMClientService;
+export type Service = LLMClientService;
 export interface MakeInput<Body, Frame, Event, State> {
     readonly compact?: CompactionOperations;
     /** Route id used in diagnostics and prepared request metadata. */
@@ -423,7 +425,7 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
             readonly [x: string]: unknown;
         };
     } | undefined;
-}, AIError, Service>;
+}, AIError, LLMClientService>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const Route: {
     readonly make: typeof make;
@@ -431,8 +433,8 @@ export declare const Route: {
 export declare const LLMClient: {
     readonly canCompact: typeof canCompact;
     readonly compact: typeof compact;
-    readonly Service: typeof Service;
-    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly Service: typeof LLMClientService;
+    readonly layer: Layer.Layer<LLMClientService, never, import("./executor-service.js").RequestExecutorService>;
     readonly stream: typeof stream;
     readonly generate: typeof generate;
 };

package/dist/route/client.js

@@ -9,6 +9,7 @@ import { applyEffortUpdates } from "../effort-updates.js";
 import { normalizeToolHistory } from "../tool-history.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
 import * as ProviderShared from "../protocols/shared.js";
+import { ToolSchemaProjection } from "../protocols/utils/tool-schema.js";
 import { AIError, CompactionResponse, CompactionCheckpointResponse, AIErrorReason, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, InvalidProviderOutputError, ProviderConfigurationError, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema/index.js";
 const makeRouteLanguageModel = (route, mapped) => {
     const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined);
@@ -33,7 +34,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 +45,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;
@@ -66,8 +62,9 @@ const unsupportedCompaction = (request, mechanism) => {
         message: `${request.model.provider}/${request.model.route.id} does not support ${mechanism === "trigger" ? "trigger" : "explicit"} compaction`,
     });
 };
-export class Service extends Context.Service()("@opencode/LLMClient") {
+export class LLMClientService extends Context.Service()("@opencode/LLMClient") {
 }
+export const Service = LLMClientService;
 const resolveRequestOptions = (request) => {
     const messages = normalizeToolHistory(request.messages);
     const normalized = messages === request.messages ? request : LLMRequest.update(request, { messages });
@@ -122,6 +119,7 @@ function makeFromTransport(input) {
             defaults: routeInput.defaults ?? {},
             body: protocol.body,
             supportsEffortUpdates: protocol.supportsEffortUpdates,
+            sanitizer: protocol.sanitizer,
             with: (patch) => {
                 const { compact, id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch;
                 return build({
@@ -214,7 +212,7 @@ const prepareRequest = (request) => {
     const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }));
     // Deduplicate per sibling level; a tool and a namespace may share a name.
     const dedupe = (tools) => [...new Map(tools.map((tool) => [`${tool.type}:${tool.name}`, tool])).values()].map((tool) => tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) });
-    const resolved = applyCachePolicy(applyEffortUpdates(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) })));
+    const resolved = applyCachePolicy(applyEffortUpdates(LLMRequest.update(sanitized, { tools: ToolSchemaProjection.tools(dedupe(sanitized.tools), sanitized.model) })));
     const headers = resolved.model.route.headers?.({ request: resolved });
     return headers === undefined
         ? resolved

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

@@ -6,7 +6,9 @@ export interface Interface {
 }
 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 {
+declare const RequestExecutorService_base: Context.ServiceClass<RequestExecutorService, "@opencode/AI/RequestExecutor", Interface>;
+export declare class RequestExecutorService extends RequestExecutorService_base {
 }
+export declare const Service: typeof RequestExecutorService;
+export type Service = RequestExecutorService;
 export {};

package/dist/route/executor-service.js

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

package/dist/route/executor.d.ts

@@ -18,5 +18,7 @@ export declare const httpFailure: (input: {
 export declare const responseStream: (response: HttpClientResponse.HttpClientResponse) => Stream.Stream<Uint8Array, AIError>;
 export declare const stream: (executor: Interface, request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Stream.Stream<Uint8Array, AIError>;
 export declare const layer: Layer.Layer<Service, never, HttpClient.HttpClient>;
-export declare const fetchLayer: Layer.Layer<Service, never, never>;
+export declare const fetchLayer: Layer.Layer<import("./executor-service.js").RequestExecutorService, never, never>;
+/** Run `fn` on every request: it sees the raw response before status classification, inside middleware already on `executor`, and outside per-call middleware. */
+export declare const middleware: (fn: HttpMiddleware, executor?: Layer.Layer<Service>) => Layer.Layer<Service>;
 export * as RequestExecutor from "./executor.js";

package/dist/route/executor.js

@@ -180,4 +180,11 @@ export const layer = Layer.effect(Service, Effect.gen(function* () {
     });
 }));
 export const fetchLayer = layer.pipe(Layer.provide(FetchHttpClient.layer));
+/** Run `fn` on every request: it sees the raw response before status classification, inside middleware already on `executor`, and outside per-call middleware. */
+export const middleware = (fn, executor = fetchLayer) => Layer.effect(Service, Effect.gen(function* () {
+    const inner = yield* Service;
+    return Service.of({
+        execute: (request, next) => inner.execute(request, next === undefined ? fn : (input, handler) => fn(input, (forwarded) => next(forwarded, handler))),
+    });
+})).pipe(Layer.provide(executor));
 export * as RequestExecutor from "./executor.js";

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",

package/dist/route/index.d.ts

@@ -1,5 +1,5 @@
 export { Route, LLMClient } from "./client.js";
-export type { Route as RouteShape, RouteLanguageModelInput, RouteRoutedLanguageModelInput, RouteDefaults, RouteDefaultsInput, AnyRoute, Interface as LLMClientShape, Service as LLMClientService, StreamOptions, CompactMethod, CompactionOperations, CompactionRequest, CheckpointRequest, EndpointCompactOptions, TriggerCompactOptions, } from "./client.js";
+export type { Route as RouteShape, RouteLanguageModelInput, RouteRoutedLanguageModelInput, RouteDefaults, RouteDefaultsInput, AnyRoute, Interface as LLMClientShape, LLMClientService, StreamOptions, CompactMethod, CompactionOperations, CompactionRequest, CheckpointRequest, EndpointCompactOptions, TriggerCompactOptions, } from "./client.js";
 export * from "./executor.js";
 export { Auth } from "./auth.js";
 export { AuthOptions } from "./auth-options.js";