@opencode/ai 2.0.16 → 2.0.17

package/dist/protocols/openai-transcription.js

@@ -1,15 +1,14 @@
 import { Effect, Schema, Stream } from "effect";
+import { classifyProviderFailure } from "../provider-error.js";
 import { Framing } from "../route/framing.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { AIError, mergeJsonRecords } from "../schema/index.js";
 import { TranscriptionFinishEvent, TranscriptionModel, TranscriptionSegmentEvent, TranscriptionTextDeltaEvent, } from "../transcription.js";
 import { mediaTypeExtension } from "../utils/media-type.js";
 import { ProviderShared } from "./shared.js";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "openai-transcription";
-const NAME = "OpenAI Transcription";
-const PROVIDER = ProviderID.make("openai");
+const route = MediaProtocol.identity({ id: "openai-transcription", name: "OpenAI Transcription", provider: "openai" });
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export const PATH = "/audio/transcriptions";
 // ---------------------------------------------------------------------------
@@ -27,6 +26,7 @@ const Usage = Schema.Union([
         input_tokens: Schema.optional(Schema.Number),
         output_tokens: Schema.optional(Schema.Number),
         total_tokens: Schema.optional(Schema.Number),
+        input_token_details: Schema.optional(Schema.Struct({ audio_tokens: Schema.optional(Schema.Number), text_tokens: Schema.optional(Schema.Number) })),
     }),
     Schema.Struct({ type: Schema.Literal("duration"), seconds: Schema.Number }),
 ]);
@@ -39,14 +39,23 @@ const transcriptFields = {
     words: Schema.optional(Schema.Array(Schema.Struct({ word: Schema.String, start: Schema.Number, end: Schema.Number }))),
     usage: Schema.optional(Usage),
 };
+/** OpenAI may add stream event types; frames outside `EVENT_TYPES` are ignored. */
+const EventType = Schema.Struct({ type: Schema.String });
 const Event = Schema.Union([
     Schema.Struct({ type: Schema.Literal("transcript.text.delta"), delta: Schema.String }),
     Schema.Struct({ type: Schema.Literal("transcript.text.segment"), ...Segment.fields }),
     Schema.Struct({ type: Schema.Literal("transcript.text.done"), ...transcriptFields }),
+    Schema.Struct({
+        type: Schema.Literal("error"),
+        message: Schema.optional(Schema.String),
+        error: Schema.optional(Schema.Struct({ message: Schema.optional(Schema.String) })),
+    }),
 ]);
+const EVENT_TYPES = new Set(["transcript.text.delta", "transcript.text.segment", "transcript.text.done", "error"]);
 const Transcript = Schema.Struct(transcriptFields);
-const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, Event);
-const decodeTranscript = MediaProtocol.decodeFrame(ADAPTER, NAME, Transcript);
+const decodeEventType = route.decodeFrame(EventType);
+const decodeEvent = route.decodeFrame(Event);
+const decodeTranscript = route.decodeFrame(Transcript);
 const TRANSCRIBE = { stream: true, timestamps: [], diarize: false, languageField: "language" };
 const capabilities = (model) => {
     if (model.startsWith("whisper"))
@@ -58,20 +67,19 @@ const capabilities = (model) => {
         return { ...TRANSCRIBE, languageField: "languages" };
     return TRANSCRIBE;
 };
-const unsupported = (operation, message) => Effect.fail(ProviderShared.unsupportedOperation({ operation, provider: PROVIDER, route: ADAPTER, message }));
+/** whisper-1 ignores `stream`, so its `stream` mode sends a plain request and emits only `finish`. */
+const streamsEvents = (request) => request.mode === "stream" && capabilities(request.model.id).stream;
 const validate = (request, model) => {
     const id = request.model.id;
-    if (request.mode === "stream" && !model.stream)
-        return unsupported("media.stream", `${id} does not stream; use Transcription.generate`);
     if (request.diarize === true && !model.diarize)
-        return unsupported("media.diarize", `${id} does not diarize; use gpt-4o-transcribe-diarize`);
+        return Effect.fail(route.unsupported("media.diarize", `${id} does not diarize; use gpt-4o-transcribe-diarize`));
     if (request.prompt !== undefined && model.diarize)
-        return unsupported("media.prompt", `${id} does not accept a prompt`);
+        return Effect.fail(route.unsupported("media.prompt", `${id} does not accept a prompt`));
     if (request.timestamps === undefined ||
         request.timestamps === "none" ||
         model.timestamps.includes(request.timestamps))
         return Effect.void;
-    return unsupported("media.timestamps", `${id} does not return ${request.timestamps} timestamps`);
+    return Effect.fail(route.unsupported("media.timestamps", `${id} does not return ${request.timestamps} timestamps`));
 };
 const RESERVED_FORM_FIELDS = new Set([
     "file",
@@ -82,26 +90,22 @@ const RESERVED_FORM_FIELDS = new Set([
     "timestamp_granularities",
     "stream",
 ]);
-const appendField = (form, key, value) => {
-    if (Array.isArray(value))
-        return value.forEach((item) => form.append(`${key}[]`, String(item)));
-    form.append(key, typeof value === "object" && value !== null ? ProviderShared.encodeJson(value) : String(value));
-};
 const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (request) {
     const model = capabilities(request.model.id);
     yield* validate(request, model);
     // The API detects the audio format from the upload's filename extension.
     const extension = mediaTypeExtension(request.audio.mediaType);
     if (extension === undefined)
-        return yield* ProviderShared.invalidRequest(`${NAME} cannot name a ${request.audio.mediaType} upload; send mp3, mp4, m4a, wav, webm, ogg, or flac audio`);
-    const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio);
+        return yield* ProviderShared.invalidRequest(`${route.name} cannot name a ${request.audio.mediaType} upload; send mp3, mp4, m4a, wav, webm, ogg, or flac audio`);
+    const audio = yield* MediaInput.inlineBytes(route.id, request.audio);
     const responseFormat = model.diarize
         ? "diarized_json"
         : request.timestamps === undefined || request.timestamps === "none"
             ? undefined
             : "verbose_json";
-    const native = Object.entries(mergeJsonRecords(request.providerOptions, request.http?.body) ?? {}).filter(([key]) => !RESERVED_FORM_FIELDS.has(key));
-    const fields = mergeJsonRecords({
+    const form = new FormData();
+    form.append("file", MediaInput.blob(audio, request.audio.mediaType), `audio.${extension}`);
+    MediaInput.appendFields(form, {
         model: request.model.id,
         language: model.languageField === "language" ? request.language : undefined,
         languages: model.languageField === "languages" && request.language !== undefined ? [request.language] : undefined,
@@ -110,11 +114,12 @@ const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (requ
         timestamp_granularities: responseFormat === "verbose_json" ? [request.timestamps] : undefined,
         // Diarizing audio longer than 30 seconds requires a chunking strategy.
         chunking_strategy: model.diarize ? "auto" : undefined,
-        stream: request.mode === "stream" ? true : undefined,
-    }, Object.fromEntries(native));
-    const form = new FormData();
-    form.append("file", MediaInput.blob(audio, request.audio.mediaType), `audio.${extension}`);
-    Object.entries(fields ?? {}).forEach(([key, value]) => appendField(form, key, value));
+        stream: streamsEvents(request) ? true : undefined,
+    }, {
+        overlay: mergeJsonRecords(request.providerOptions, request.http?.body),
+        reserved: RESERVED_FORM_FIELDS,
+        repeatArrays: true,
+    });
     return MediaProtocol.multipart(form);
 });
 // ---------------------------------------------------------------------------
@@ -127,7 +132,16 @@ const segment = (value) => ({
     speaker: value.speaker,
 });
 const onEvent = Effect.fn("OpenAITranscription.onEvent")(function* (state, frame) {
+    if (!EVENT_TYPES.has((yield* decodeEventType(frame)).type))
+        return [state, []];
     const event = yield* decodeEvent(frame);
+    if (event.type === "error")
+        return yield* new AIError({
+            reason: classifyProviderFailure({
+                message: `${route.name} stream failed: ${event.message ?? event.error?.message ?? "unknown error"}`,
+                rawBody: frame,
+            }),
+        });
     if (event.type === "transcript.text.done")
         return [{ ...state, transcript: event }, []];
     if (event.type === "transcript.text.delta")
@@ -155,7 +169,7 @@ const usage = (value) => {
 const finish = (state) => {
     const transcript = state.transcript;
     if (transcript === undefined)
-        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+        return Effect.fail(route.incomplete());
     const segments = transcript.segments?.map(segment) ?? state.segments;
     return Effect.succeed([
         TranscriptionFinishEvent.make({
@@ -171,19 +185,17 @@ const finish = (state) => {
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     unsupported: ["speakers"],
     body: { from: fromRequest },
-    frames: (bytes, context) => context.request.mode === "stream"
+    frames: (bytes, context) => streamsEvents(context.request)
         ? Framing.sse.frame(bytes)
         : Framing.document.frame(bytes).pipe(Stream.map((document) => ({ document }))),
     initial: () => ({ segments: [] }),
     step,
     finish,
 });
-export const model = (input) => TranscriptionModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const model = (input) => TranscriptionModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
 export const OpenAITranscription = {
     protocol,
     model,

package/dist/protocols/replicate-images.js

@@ -3,11 +3,9 @@ import { ImageModel, ImageResponse } from "../image.js";
 import { Media } from "../media.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared, optionalNull } from "./shared.js";
-const ADAPTER = "replicate-images";
-const NAME = "Replicate";
-const PROVIDER = ProviderID.make("replicate");
+const route = MediaProtocol.identity({ id: "replicate-images", name: "Replicate", provider: "replicate" });
 export const DEFAULT_BASE_URL = "https://api.replicate.com";
 const OUTPUT_RETENTION = Duration.hours(1);
 const MAX_DATA_URL_BYTES = 256 * 1024;
@@ -50,8 +48,8 @@ const inlineSize = (source) => {
 };
 const fileInput = (asset) => {
     if (inlineSize(asset.source) > MAX_DATA_URL_BYTES)
-        return Effect.fail(ProviderShared.invalidRequest(`${NAME} data URL inputs are limited to 256 KB; pass a larger file by https URL`));
-    return ProviderShared.mediaReference(asset, undefined, NAME).pipe(Effect.map((reference) => reference.value));
+        return Effect.fail(ProviderShared.invalidRequest(`${route.name} data URL inputs are limited to 256 KB; pass a larger file by https URL`));
+    return ProviderShared.mediaReference(asset, undefined, route.name).pipe(Effect.map((reference) => reference.value));
 };
 const inputValue = (value) => {
     if (value instanceof Media.Asset)
@@ -69,7 +67,7 @@ const fromRequest = Effect.fn("ReplicateImages.fromRequest")(function* (request)
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodePrediction = MediaProtocol.decodeJson(ADAPTER, NAME, Prediction);
+const decodePrediction = route.decodeJson(Prediction);
 const decodeStart = Effect.fn("ReplicateImages.decodeStart")(function* (response) {
     const output = yield* decodePrediction(response);
     const prediction = output.value;
@@ -88,16 +86,16 @@ const decodeResult = Effect.fn("ReplicateImages.decodeResult")(function* (respon
     const prediction = output.value;
     const status = yield* MediaProtocol.status(STATUS, prediction.status, output);
     if (status === "failed" || status === "cancelled" || status === "expired")
-        return yield* output.ended(status, `${NAME} prediction ${context.token.id} ${prediction.status}${typeof prediction.error === "string" ? `: ${prediction.error}` : ""}`);
+        return yield* output.ended(status, `${route.name} prediction ${context.token.id} ${prediction.status}${typeof prediction.error === "string" ? `: ${prediction.error}` : ""}`);
     if (status !== "completed")
-        return yield* output.invalid(`${NAME} prediction ${context.token.id} has not finished`);
+        return yield* output.pending(context.token.id);
     if (prediction.data_removed === true)
-        return yield* output.ended("expired", `${NAME} removed the output of prediction ${context.token.id}`);
+        return yield* output.ended("expired", `${route.name} removed the output of prediction ${context.token.id}`);
     if (!isOutput(prediction.output))
-        return yield* output.invalid(`${NAME} prediction ${context.token.id} returned output that is not image URLs`);
+        return yield* output.invalid(`${route.name} prediction ${context.token.id} returned output that is not image URLs`);
     const urls = typeof prediction.output === "string" ? [prediction.output] : prediction.output;
     if (urls.length === 0)
-        return yield* output.invalid(`${NAME} prediction ${context.token.id} returned no images`);
+        return yield* output.invalid(`${route.name} prediction ${context.token.id} returned no images`);
     const predictTime = prediction.metrics?.predict_time ?? undefined;
     const completedAt = prediction.completed_at ?? undefined;
     const expiresAt = completedAt === undefined ? undefined : Date.parse(completedAt) + Duration.toMillis(OUTPUT_RETENTION);
@@ -110,9 +108,7 @@ const decodeResult = Effect.fn("ReplicateImages.decodeResult")(function* (respon
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.queued({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.queued(route, {
     token: Token,
     unsupported: ["images", "mask", "n", "size", "aspectRatio", "seed", "format"],
     start: { body: { from: fromRequest }, decode: decodeStart },
@@ -121,8 +117,6 @@ export const protocol = MediaProtocol.queued({
     cancel: { method: "POST", path: (token) => token.cancelURL },
 });
 export const model = (input) => ImageModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
     protocol,
     baseURL: DEFAULT_BASE_URL,
     path: ({ request }) => isOfficial(request.model.id) ? `/v1/models/${request.model.id}/predictions` : "/v1/predictions",

package/dist/protocols/runway-video.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from "effect";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
 export declare const DEFAULT_BASE_URL = "https://api.dev.runwayml.com/v1";
 /** Every Runway request must pin the API version. */
@@ -9,7 +10,6 @@ export declare const TEXT_TO_VIDEO_PATH = "/text_to_video";
 export declare const IMAGE_TO_VIDEO_PATH = "/image_to_video";
 export declare const VIDEO_TO_VIDEO_PATH = "/video_to_video";
 export declare const TASKS_PATH = "/tasks";
-export type RunwayVideoString<Known extends string> = Known | (string & {});
 /**
  * Provider-native options. Common fields lower to Runway's names: `aspectRatio` → `ratio` (Runway expects pixel
  * ratios such as `1280:720` for most models), `durationSeconds` → `duration`, `audio`, `negativePrompt`,
@@ -17,9 +17,9 @@ export type RunwayVideoString<Known extends string> = Known | (string & {});
  */
 export type RunwayVideoOptions = {
     readonly contentModeration?: {
-        readonly publicFigureThreshold?: RunwayVideoString<"auto" | "low">;
+        readonly publicFigureThreshold?: OpenString<"auto" | "low">;
     };
-    readonly outputFormat?: RunwayVideoString<"mp4" | "prores" | "png_sequence">;
+    readonly outputFormat?: OpenString<"mp4" | "prores" | "png_sequence">;
 } & Record<string, unknown>;
 export type Request = VideoRequestFor<RunwayVideoOptions>;
 export declare const Token: Schema.Struct<{

package/dist/protocols/runway-video.js

@@ -2,12 +2,10 @@ import { Duration, Effect, Schema } from "effect";
 import { Media } from "../media.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { mergeJsonRecords } from "../schema/index.js";
 import { VideoModel, VideoResponse } from "../video.js";
 import { ProviderShared, optionalArray, optionalNull } from "./shared.js";
-const ADAPTER = "runway-video";
-const NAME = "Runway";
-const PROVIDER = ProviderID.make("runway");
+const route = MediaProtocol.identity({ id: "runway-video", name: "Runway", provider: "runway" });
 export const DEFAULT_BASE_URL = "https://api.dev.runwayml.com/v1";
 /** Every Runway request must pin the API version. */
 export const API_VERSION = "2024-11-06";
@@ -44,7 +42,7 @@ const STATUS = {
 // 5. Request body construction
 // ---------------------------------------------------------------------------
 // Runway accepts HTTPS URLs, `runway://` upload URIs, and data URIs, all as one string.
-const mediaUri = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((reference) => reference.value));
+const mediaUri = (asset) => ProviderShared.mediaReference(asset, route.provider, route.name).pipe(Effect.map((reference) => reference.value));
 const fromRequest = Effect.fn("RunwayVideo.fromRequest")(function* (request) {
     const first = request.frames?.first === undefined ? undefined : yield* mediaUri(request.frames.first);
     const last = request.frames?.last === undefined ? undefined : yield* mediaUri(request.frames.last);
@@ -71,11 +69,11 @@ const fromRequest = Effect.fn("RunwayVideo.fromRequest")(function* (request) {
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+const decodeStart = route.decodeStarted(StartResponse, (value) => ({
     token: { taskID: value.id },
     snapshot: { id: value.id, status: "queued" },
 }));
-const decodeTask = MediaProtocol.decodeJson(ADAPTER, NAME, Task);
+const decodeTask = route.decodeJson(Task);
 const decodeStatus = Effect.fn("RunwayVideo.decodeStatus")(function* (response, context) {
     const output = yield* decodeTask(response);
     const status = yield* MediaProtocol.status(STATUS, output.value.status, output);
@@ -87,19 +85,19 @@ const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (response,
     const status = yield* MediaProtocol.status(STATUS, task.status, output);
     if (status === "failed") {
         const code = task.failureCode ?? undefined;
-        const message = `${NAME} task failed${code === undefined ? "" : ` (${code})`}${task.failure ? `: ${task.failure}` : ""}`;
+        const message = `${route.name} task failed${code === undefined ? "" : ` (${code})`}${task.failure ? `: ${task.failure}` : ""}`;
         // Runway failure codes are dotted paths; every moderation outcome carries a SAFETY segment.
         if (code !== undefined && /(^|\.)SAFETY(\.|$)/.test(code))
             return yield* output.contentPolicy(message);
         return yield* output.ended("failed", message);
     }
     if (status === "cancelled")
-        return yield* output.ended("cancelled", `${NAME} task ${context.token.taskID} was cancelled`);
+        return yield* output.ended("cancelled", `${route.name} task ${context.token.taskID} was cancelled`);
     if (status !== "completed")
-        return yield* output.invalid(`${NAME} task ${context.token.taskID} has not finished`);
+        return yield* output.pending(context.token.taskID);
     const urls = task.output ?? [];
     if (urls.length === 0)
-        return yield* output.invalid(`${NAME} task succeeded without any output`);
+        return yield* output.invalid(`${route.name} task succeeded without any output`);
     return new VideoResponse({
         videos: yield* Effect.forEach(urls, (url) => MediaProtocol.expiringUrl(url, OUTPUT_RETENTION, { mediaType: "video/mp4" })),
         usage: task.cost === undefined ? undefined : { type: "credits", credits: task.cost.credits },
@@ -115,15 +113,13 @@ const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (response,
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
 const taskPath = (token) => `${TASKS_PATH}/${token.taskID}`;
-export const protocol = MediaProtocol.queued({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.queued(route, {
     token: Token,
     unsupported: ["n"],
     start: { body: { from: fromRequest }, decode: decodeStart },
     status: { path: taskPath, decode: decodeStatus },
     result: { path: taskPath, decode: decodeResult },
-    cancel: { method: "DELETE", path: taskPath },
+    cancel: { method: "DELETE", path: taskPath, activeOnly: true },
 });
 const startPath = (request) => {
     if (request.video !== undefined)
@@ -133,8 +129,6 @@ const startPath = (request) => {
     return TEXT_TO_VIDEO_PATH;
 };
 export const model = (input) => VideoModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
     protocol,
     baseURL: DEFAULT_BASE_URL,
     headers: { "X-Runway-Version": API_VERSION },

package/dist/protocols/shared.d.ts

@@ -1,20 +1,18 @@
 import { Tool } from "@opencode/schema/tool";
-import { Effect, Schema, Stream } from "effect";
+import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Media } from "../media.js";
-import { AIError, LLMRequest, Message, ToolDefinition, type ContentPart, type MediaPart, type ProviderID, type ToolEntry, type ToolResultPart } from "../schema/index.js";
+import { AIError, LLMRequest, Message, ToolDefinition, type ContentPart, type MediaPart, type OpenString, type ProviderID, type ToolEntry, type ToolResultPart } from "../schema/index.js";
+import { Json, decodeJson, encodeJson } from "../utils/json.js";
 import { isRecord } from "../utils/record.js";
-export { isRecord };
-export declare const Json: Schema.fromJsonString<Schema.Unknown>;
-export declare const decodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => unknown;
-export declare const encodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string;
+export { Json, decodeJson, encodeJson, isRecord };
 export declare const JsonObject: Schema.$Record<Schema.String, Schema.Unknown>;
 export declare const optionalArray: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.$Array<S>>;
 export declare const optionalNull: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.NullOr<S>>;
 /** Optional field whose malformed value decodes to `undefined` instead of failing the enclosing struct. */
 export declare const lenient: <const S extends Schema.Top>(schema: S) => Schema.optionalKey<Schema.middlewareDecoding<Schema.UndefinedOr<S>, S["DecodingServices"]>>;
 /** Provider-defined string enum: known values for autocomplete, any string accepted at runtime. */
-export declare const knownString: <Known extends string>() => Schema.declare<(string & {}) | Known, (string & {}) | Known>;
+export declare const knownString: <Known extends string>() => Schema.declare<OpenString<Known>, OpenString<Known>>;
 export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
 export declare const promptCacheKey: (request: LLMRequest) => string | undefined;
 /**
@@ -60,6 +58,12 @@ export declare const subtractTokens: (total: number | undefined, subtrahend: num
  * (e.g. Anthropic, whose `input_tokens` is already non-cached only).
  */
 export declare const sumTokens: (...values: ReadonlyArray<number | undefined>) => number | undefined;
+/**
+ * Caps an explicit thinking budget at half the output limit. Thinking counts against the output limit, so a budget
+ * near it leaves the answer, a tool call, or a summary without room. Smaller budgets, special values such as `-1` and
+ * `0`, and requests without an output limit pass through unchanged.
+ */
+export declare const fitThinkingBudget: (budget: number, maxTokens: number | undefined, minimum?: number) => number;
 export declare const eventError: (route: string, message: string, body?: string, cause?: unknown) => AIError;
 export declare const parseJson: (route: string, input: string, message: string) => Effect.Effect<unknown, AIError, never>;
 /**
@@ -131,18 +135,8 @@ export declare const mediaReference: (asset: Media.Asset, provider: ProviderID |
  * `uri`; the declared `mime` wins over any data-URL prefix so tool authors control the type the model sees.
  */
 export declare const toolFileMedia: (item: Tool.FileContent) => MediaPart;
-export declare const trimBaseUrl: (value: string) => string;
 export declare const toolResultText: (part: ToolResultPart) => string;
 export declare const errorText: (error: unknown) => string;
-/**
- * `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>;
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
  */

package/dist/protocols/shared.js

@@ -1,14 +1,11 @@
 import { Tool } from "@opencode/schema/tool";
-import { Effect, Option, Schema, Stream } from "effect";
-import * as Sse from "effect/unstable/encoding/Sse";
+import { Effect, Option, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Media } from "../media.js";
 import { InvalidProviderOutputError, InvalidRequestError, UnsupportedOperationError, AIError, LLMRequest, Message, ToolDefinition, } from "../schema/index.js";
+import { Json, decodeJson, encodeJson } from "../utils/json.js";
 import { isRecord } from "../utils/record.js";
-export { isRecord };
-export const Json = Schema.fromJsonString(Schema.Unknown);
-export const decodeJson = Schema.decodeUnknownSync(Json);
-export const encodeJson = Schema.encodeSync(Json);
+export { Json, decodeJson, encodeJson, isRecord };
 const isJson = Schema.is(Schema.Json);
 export const JsonObject = Schema.Record(Schema.String, Schema.Unknown);
 export const optionalArray = (schema) => Schema.optional(Schema.Array(schema));
@@ -78,6 +75,12 @@ export const sumTokens = (...values) => {
         return undefined;
     return values.reduce((acc, value) => acc + (value ?? 0), 0);
 };
+/**
+ * Caps an explicit thinking budget at half the output limit. Thinking counts against the output limit, so a budget
+ * near it leaves the answer, a tool call, or a summary without room. Smaller budgets, special values such as `-1` and
+ * `0`, and requests without an output limit pass through unchanged.
+ */
+export const fitThinkingBudget = (budget, maxTokens, minimum = 1) => maxTokens === undefined || budget <= maxTokens / 2 ? budget : Math.max(minimum, Math.floor(maxTokens / 2));
 export const eventError = (route, message, body, cause) => new AIError({
     reason: new InvalidProviderOutputError({ route, message, body, cause }),
 });
@@ -149,7 +152,8 @@ export const mediaReference = (asset, provider, label) => {
     if (provider !== undefined && asset.source.type === "ref" && asset.source.provider === provider)
         return Effect.succeed({ type: "ref", value: asset.source.id });
     const accepted = provider === undefined ? "" : `, and ${provider} references`;
-    return Effect.fail(invalidRequest(`${label} accepts inline bytes, data URLs, http(s) URLs${accepted}`));
+    const got = asset.source.type === "ref" ? `; got ${asset.source.provider}:${asset.source.id}` : "";
+    return Effect.fail(invalidRequest(`${label} accepts inline bytes, data URLs, http(s) URLs${accepted}${got}`));
 };
 /**
  * Lift a tool-result file into a `MediaPart`. Tool files carry either a data URL, an `http(s)` URL, or raw base64 in
@@ -164,7 +168,6 @@ export const toolFileMedia = (item) => {
             : Media.base64(item.uri, item.mime);
     return Message.media(asset, { filename: item.name });
 };
-export const trimBaseUrl = (value) => value.replace(/\/+$/, "");
 export const toolResultText = (part) => {
     if (part.result.type === "text")
         return String(part.result.value);
@@ -189,38 +192,6 @@ export const errorText = (error) => {
         return "undefined";
     return "Unknown stream error";
 };
-/**
- * `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: Sse.makeParser((event) => {
-            if (event._tag === "Event")
-                output.push(event);
-        }),
-    };
-}, (state, chunk) => Effect.gen(function* () {
-    const error = state.parser.feed(chunk);
-    if (error)
-        return yield* eventError("sse", error.message, chunk, 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));
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
  */

package/dist/protocols/stability-images.d.ts

@@ -2,8 +2,9 @@ import { Schema } from "effect";
 import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 export declare const DEFAULT_BASE_URL = "https://api.stability.ai";
-export type StabilityStylePreset = "enhance" | "anime" | "photographic" | "digital-art" | "comic-book" | "fantasy-art" | "line-art" | "analog-film" | "neon-punk" | "isometric" | "low-poly" | "origami" | "modeling-compound" | "cinematic" | "3d-model" | "pixel-art" | "tile-texture" | (string & {});
+export type StabilityStylePreset = OpenString<"enhance" | "anime" | "photographic" | "digital-art" | "comic-book" | "fantasy-art" | "line-art" | "analog-film" | "neon-punk" | "isometric" | "low-poly" | "origami" | "modeling-compound" | "cinematic" | "3d-model" | "pixel-art" | "tile-texture">;
 export type StabilityImageOptions = {
     readonly negative_prompt?: string;
     readonly style_preset?: StabilityStylePreset;