@opencode/ai 0.0.0-dev-20120 → 0.0.0-dev-20123

package/dist/experimental/evaluation.js

@@ -94,7 +94,7 @@ export function request(input) {
     return new EvaluationRequest({
         ...input,
         model: input.model,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
 }
 export function run(input) {

package/dist/generation.d.ts

@@ -1,4 +1,4 @@
-import { Duration, Effect, Schedule, Schema, Stream } from "effect";
+import { Duration, Effect, Schema, Stream } from "effect";
 import { AIError } from "./schema/errors.js";
 export declare const Status: Schema.Literals<readonly ["queued", "running", "completed", "failed", "cancelled", "expired"]>;
 export type Status = Schema.Schema.Type<typeof Status>;
@@ -9,7 +9,6 @@ export interface Snapshot {
     /** Normalized 0..1 when the provider reports progress. */
     readonly progress?: number;
     readonly position?: number;
-    readonly expiresAt?: number;
 }
 /**
  * Route-owned generation operations for one generation. The media route decodes its serializable token once (from the
@@ -19,14 +18,10 @@ export interface Route<Response> {
     readonly status: Effect.Effect<Snapshot, AIError>;
     readonly result: Effect.Effect<Response, AIError>;
     readonly cancel?: Effect.Effect<void, AIError>;
-    /** Provider polling hint (e.g. `openai-poll-after-ms`) that overrides the default interval for the next poll. */
-    readonly pollHint?: (snapshot: Snapshot) => Duration.Duration | undefined;
 }
 export interface Poll {
     readonly interval?: Duration.Input;
     readonly timeout?: Duration.Input;
-    /** Full override of the polling schedule; `interval` and `pollHint` are ignored when supplied. */
-    readonly schedule?: Schedule.Schedule<unknown, Snapshot>;
 }
 export interface AwaitOptions {
     readonly poll?: Poll;
@@ -57,7 +52,6 @@ export declare class Generation<Response> {
     readonly status: Status;
     readonly progress?: number;
     readonly position?: number;
-    readonly expiresAt?: number;
     constructor(route: Route<Response>, 
     /** Route-owned serializable JSON; pass it to the modality's `resume` from another process. */
     token: unknown, snapshot: Snapshot);

package/dist/generation.js

@@ -21,7 +21,6 @@ export class Generation {
     status;
     progress;
     position;
-    expiresAt;
     constructor(route, 
     /** Route-owned serializable JSON; pass it to the modality's `resume` from another process. */
     token, snapshot) {
@@ -31,7 +30,6 @@ export class Generation {
         this.status = snapshot.status;
         this.progress = snapshot.progress;
         this.position = snapshot.position;
-        this.expiresAt = snapshot.expiresAt;
     }
     get snapshot() {
         return {
@@ -39,7 +37,6 @@ export class Generation {
             status: this.status,
             progress: this.progress,
             position: this.position,
-            expiresAt: this.expiresAt,
         };
     }
     get terminal() {
@@ -100,14 +97,7 @@ export class Generation {
         return this.refresh().pipe(Effect.repeat({ schedule: this.schedule(poll), until: (generation) => generation.terminal }));
     }
     schedule(poll) {
-        if (poll?.schedule)
-            return poll.schedule.pipe(Schedule.setInputType());
-        const interval = poll?.interval ?? DEFAULT_POLL_INTERVAL;
-        const pollHint = this.route.pollHint;
-        const spaced = Schedule.spaced(interval).pipe(Schedule.setInputType());
-        if (!pollHint)
-            return spaced;
-        return spaced.pipe(Schedule.modifyDelay((metadata) => Effect.succeed(pollHint(metadata.input.snapshot) ?? interval)));
+        return Schedule.spaced(poll?.interval ?? DEFAULT_POLL_INTERVAL);
     }
 }
 export const resultEvents = (generation, expand, options) => generation.events(options).pipe(Stream.filter((event) => event.type !== "generation-finished"), Stream.concat(Stream.fromIterableEffect(Effect.map(generation.result(), expand))));

package/dist/image.d.ts

@@ -4,7 +4,7 @@ import { Media } from "./media.js";
 import { MediaModel } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
 import type { MediaProtocol } from "./route/media-protocol.js";
-import { AIError, HttpOptions } from "./schema/index.js";
+import { AIError, HttpOptions, type OpenString } from "./schema/index.js";
 import { Service } from "./image-client.js";
 export type ImageOptions = Record<string, unknown>;
 export type ImageRoute<Options extends ImageOptions = ImageOptions> = MediaRoute.AnyRoute<ImageRequestFor<Options>, ImageEvent, ImageResponse>;
@@ -27,7 +27,7 @@ export type ImageSize = `${number}x${number}`;
 export declare const ImageSize: Schema.declare<`${number}x${number}`, `${number}x${number}`>;
 export type ImageAspectRatio = Media.AspectRatio;
 export declare const ImageAspectRatio: Schema.declare<`${number}:${number}`, `${number}:${number}`>;
-export type ImageFormat = "png" | "jpeg" | "webp" | (string & {});
+export type ImageFormat = OpenString<"png" | "jpeg" | "webp">;
 declare const ImageRequest_base: Schema.Class<ImageRequest, Schema.Struct<{
     readonly model: Schema.declare<ImageModel<ImageOptions>, ImageModel<ImageOptions>>;
     readonly prompt: Schema.String;

package/dist/image.js

@@ -12,7 +12,7 @@ export class ImageModel extends MediaModel {
     static fromRoute(route, input) {
         return new ImageModel({
             id: input.id,
-            provider: route.provider,
+            provider: route.protocol.provider,
             http: input.http,
             route: composeAnyRoute(route, input, collectResponse),
         });
@@ -110,7 +110,7 @@ export function request(input) {
         return input;
     return new ImageRequest({
         ...input,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
 }
 const requestEffect = (input) => tryRequest(() => request(input));

package/dist/llm.js

@@ -14,7 +14,7 @@ export const request = (input) => {
         toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
         generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
         providerOptions: requestProviderOptions,
-        http: requestHttp === undefined ? undefined : HttpOptions.make(requestHttp),
+        http: HttpOptions.make(requestHttp),
     });
 };
 const GENERATE_OBJECT_TOOL_NAME = "generate_object";

package/dist/media-model.d.ts

@@ -25,8 +25,6 @@ export declare namespace MediaModel {
     }
     /** A protocol plus its canonical start path; `ModelInput.baseURL` overrides `baseURL` per deployment. */
     interface RouteInput<Request extends MediaRoute.MediaRequest, Protocol> {
-        readonly id: string;
-        readonly provider: string | ProviderID;
         readonly protocol: Protocol;
         readonly path: Endpoint.EndpointPart<MediaProtocol.Body, Request>;
         readonly baseURL?: string;

package/dist/media-model.js

@@ -21,8 +21,6 @@ export class MediaModel {
 }
 /** Compose a protocol route input with one deployment through `MediaRoute.inline`, `queued`, or `stream`. */
 export const composeRoute = (compose, route, input) => compose({
-    id: route.id,
-    provider: route.provider,
     protocol: route.protocol,
     endpoint: Endpoint.path(route.path, { baseURL: input.baseURL ?? route.baseURL }),
     auth: input.auth,

package/dist/protocols/alibaba-messages.d.ts

@@ -228,7 +228,7 @@ export declare const protocol: Protocol<{
         readonly type: string;
         readonly budget_tokens?: number | undefined;
     } | 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/protocols/anthropic-messages.d.ts

@@ -28,33 +28,33 @@ export declare const ContextManagement: Schema.Struct<{
 }>;
 export type ContextManagement = typeof ContextManagement.Type;
 declare const AnthropicThinkingBlockBinding: Schema.Struct<{
-    readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+    readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
 }>;
 declare const Thinking: Schema.Union<readonly [Schema.decodeTo<Schema.Struct<{
-    readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+    readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
     readonly block_binding: Schema.optional<Schema.Struct<{
-        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
     }>>;
     readonly type: Schema.tag<"enabled">;
     readonly budget_tokens: Schema.Number;
 }>, Schema.Union<readonly [Schema.Struct<{
-    readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+    readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
     readonly block_binding: Schema.optional<Schema.Struct<{
-        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
     }>>;
     readonly type: Schema.tag<"enabled">;
     readonly budgetTokens: Schema.Number;
 }>, Schema.Struct<{
-    readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+    readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
     readonly block_binding: Schema.optional<Schema.Struct<{
-        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
     }>>;
     readonly type: Schema.tag<"enabled">;
     readonly budget_tokens: Schema.Number;
 }>]>, never, never>, Schema.Struct<{
-    readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+    readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
     readonly block_binding: Schema.optional<Schema.Struct<{
-        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+        readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
     }>>;
     readonly type: Schema.tag<"adaptive">;
 }>, Schema.Struct<{
@@ -74,38 +74,38 @@ declare const Options: Schema.Struct<{
         }>>;
     }>>;
     readonly thinking: Schema.optional<Schema.Union<readonly [Schema.decodeTo<Schema.Struct<{
-        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
         readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
         }>>;
         readonly type: Schema.tag<"enabled">;
         readonly budget_tokens: Schema.Number;
     }>, Schema.Union<readonly [Schema.Struct<{
-        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
         readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
         }>>;
         readonly type: Schema.tag<"enabled">;
         readonly budgetTokens: Schema.Number;
     }>, Schema.Struct<{
-        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
         readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
         }>>;
         readonly type: Schema.tag<"enabled">;
         readonly budget_tokens: Schema.Number;
     }>]>, never, never>, Schema.Struct<{
-        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
         readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
         }>>;
         readonly type: Schema.tag<"adaptive">;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"disabled">;
     }>]>>;
     readonly effort: Schema.optional<Schema.String>;
-    readonly service_tier: Schema.optional<Schema.declare<"auto" | (string & {}) | "standard_only", "auto" | (string & {}) | "standard_only">>;
-    readonly serviceTier: Schema.optional<Schema.declare<"auto" | (string & {}) | "standard_only", "auto" | (string & {}) | "standard_only">>;
+    readonly service_tier: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"auto" | "standard_only">, import("../schema/options.js").OpenString<"auto" | "standard_only">>>;
+    readonly serviceTier: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"auto" | "standard_only">, import("../schema/options.js").OpenString<"auto" | "standard_only">>>;
     readonly metadata: Schema.optional<Schema.Struct<{
         readonly user_id: Schema.optional<Schema.NullOr<Schema.String>>;
     }>>;
@@ -369,16 +369,16 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
     top_k: Schema.optional<Schema.Number>;
     stop_sequences: Schema.optional<Schema.$Array<Schema.String>>;
     thinking: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
         readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
         }>>;
         readonly type: Schema.tag<"enabled">;
         readonly budget_tokens: Schema.Number;
     }>, Schema.Struct<{
-        readonly display: Schema.optional<Schema.declare<(string & {}) | "summarized" | "omitted", (string & {}) | "summarized" | "omitted">>;
+        readonly display: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"summarized" | "omitted">, import("../schema/options.js").OpenString<"summarized" | "omitted">>>;
         readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<(string & {}) | "error" | "drop_block", (string & {}) | "error" | "drop_block">>;
+            readonly prefix_mismatch_behavior: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"error" | "drop_block">, import("../schema/options.js").OpenString<"error" | "drop_block">>>;
         }>>;
         readonly type: Schema.tag<"adaptive">;
     }>, Schema.Struct<{
@@ -403,7 +403,7 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
     metadata: Schema.optional<Schema.Struct<{
         readonly user_id: Schema.optional<Schema.NullOr<Schema.String>>;
     }>>;
-    service_tier: Schema.optional<Schema.declare<"auto" | (string & {}) | "standard_only", "auto" | (string & {}) | "standard_only">>;
+    service_tier: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"auto" | "standard_only">, import("../schema/options.js").OpenString<"auto" | "standard_only">>>;
 }>;
 export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesBody>;
 /**
@@ -627,20 +627,20 @@ export declare const protocol: Protocol<{
     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 {
@@ -984,20 +984,20 @@ export declare const route: 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/protocols/assemblyai-transcription.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 { TranscriptionModel, TranscriptionResponse, type TranscriptionRequestFor } from "../transcription.js";
 export declare const DEFAULT_BASE_URL = "https://api.assemblyai.com";
 export declare const PATH = "/v2/transcript";
@@ -21,7 +22,7 @@ export type AssemblyAITranscriptionOptions = {
         readonly fallback_language?: string;
         readonly code_switching?: boolean;
     };
-    readonly speech_models?: ReadonlyArray<"universal-3-5-pro" | "universal-2" | (string & {})>;
+    readonly speech_models?: ReadonlyArray<OpenString<"universal-3-5-pro" | "universal-2">>;
 } & Record<string, unknown>;
 export type Request = TranscriptionRequestFor<AssemblyAITranscriptionOptions>;
 export declare const Token: Schema.Struct<{

package/dist/protocols/assemblyai-transcription.js

@@ -2,13 +2,11 @@ import { 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 { TranscriptionModel, TranscriptionResponse } from "../transcription.js";
 import { ProviderShared, optionalNull } from "./shared.js";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "assemblyai-transcription";
-const NAME = "AssemblyAI";
-const PROVIDER = ProviderID.make("assemblyai");
+const route = MediaProtocol.identity({ id: "assemblyai-transcription", name: "AssemblyAI", provider: "assemblyai" });
 export const DEFAULT_BASE_URL = "https://api.assemblyai.com";
 export const PATH = "/v2/transcript";
 export const UPLOAD_PATH = "/v2/upload";
@@ -49,17 +47,17 @@ const STATUS = {
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
-const decodeUpload = MediaProtocol.decodeJson(ADAPTER, NAME, Upload);
+const decodeUpload = route.decodeJson(Upload);
 /** `/v2/transcript` only takes a URL, so inline audio is uploaded to `/v2/upload` first. */
 const prepare = Effect.fn("AssemblyAITranscription.prepare")(function* (request, send) {
     if (request.audio.source.type !== "bytes" && request.audio.source.type !== "base64")
         return request;
-    const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio);
+    const audio = yield* MediaInput.inlineBytes(route.id, request.audio);
     const uploaded = yield* send(UPLOAD_PATH, MediaProtocol.binary(audio, "application/octet-stream")).pipe(Effect.flatMap(decodeUpload));
     return { ...request, audio: Media.url(uploaded.value.upload_url, { mediaType: request.audio.mediaType }) };
 });
 const fromRequest = Effect.fn("AssemblyAITranscription.fromRequest")(function* (request) {
-    const audio = yield* ProviderShared.mediaReference(request.audio, PROVIDER, NAME);
+    const audio = yield* ProviderShared.mediaReference(request.audio, route.provider, route.name);
     return MediaProtocol.json(mergeJsonRecords({
         audio_url: audio.value,
         speech_models: [request.model.id],
@@ -74,7 +72,7 @@ const fromRequest = Effect.fn("AssemblyAITranscription.fromRequest")(function* (
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeTranscript = MediaProtocol.decodeJson(ADAPTER, NAME, Transcript);
+const decodeTranscript = route.decodeJson(Transcript);
 const decodeStart = Effect.fn("AssemblyAITranscription.decodeStart")(function* (response) {
     const output = yield* decodeTranscript(response);
     const status = yield* MediaProtocol.status(STATUS, output.value.status, output);
@@ -92,9 +90,9 @@ const decodeResult = Effect.fn("AssemblyAITranscription.decodeResult")(function*
     const status = yield* MediaProtocol.status(STATUS, transcript.status, output);
     const error = transcript.error ?? undefined;
     if (status === "failed")
-        return yield* output.ended("failed", `${NAME} transcription failed${error === undefined ? "" : `: ${error}`}`);
+        return yield* output.ended("failed", `${route.name} transcription failed${error === undefined ? "" : `: ${error}`}`);
     if (status !== "completed")
-        return yield* output.invalid(`${NAME} transcript ${context.token.transcriptID} has not finished`);
+        return yield* output.invalid(`${route.name} transcript ${context.token.transcriptID} has not finished`);
     const duration = transcript.audio_duration ?? undefined;
     return new TranscriptionResponse({
         text: transcript.text ?? "",
@@ -123,15 +121,13 @@ const decodeResult = Effect.fn("AssemblyAITranscription.decodeResult")(function*
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
 const transcriptPath = (token) => `${PATH}/${token.transcriptID}`;
-export const protocol = MediaProtocol.queued({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.queued(route, {
     token: Token,
     start: { prepare, body: { from: fromRequest }, decode: decodeStart },
     status: { path: transcriptPath, decode: decodeStatus },
     result: { path: transcriptPath, decode: decodeResult },
 });
-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 AssemblyAITranscription = {
     protocol,
     model,

package/dist/protocols/bfl-images.js

@@ -3,12 +3,10 @@ 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";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "bfl-images";
-const NAME = "Black Forest Labs";
-const PROVIDER = ProviderID.make("black-forest-labs");
+const route = MediaProtocol.identity({ id: "bfl-images", name: "Black Forest Labs", provider: "black-forest-labs" });
 export const DEFAULT_BASE_URL = "https://api.bfl.ai";
 // ---------------------------------------------------------------------------
 // 2. Token and response schemas
@@ -52,31 +50,25 @@ const capabilities = (model) => {
         return { sizing: "dimensions", imageField: "input_image", maxImages: 4, mask: false };
     return { sizing: "dimensions", imageField: "input_image", maxImages: 8, mask: false };
 };
-const unsupported = (model, field, message) => ProviderShared.unsupportedOperation({
-    operation: `media.${field}`,
-    provider: PROVIDER,
-    route: ADAPTER,
-    message: `${model} ${message}`,
-});
 const validate = (request, model) => {
     const id = request.model.id;
     const images = request.images?.length ?? 0;
     if (request.n !== undefined && request.n > 1)
-        return Effect.fail(unsupported(id, "n", "generates one image per request; call it once per image"));
+        return Effect.fail(route.unsupported("media.n", `${id} generates one image per request; call it once per image`));
     if (request.size !== undefined && model.sizing !== "dimensions")
-        return Effect.fail(unsupported(id, "size", "does not take size (width and height)"));
+        return Effect.fail(route.unsupported("media.size", `${id} does not take size (width and height)`));
     if (request.aspectRatio !== undefined && model.sizing !== "aspectRatio")
-        return Effect.fail(unsupported(id, "aspectRatio", "does not take aspectRatio"));
+        return Effect.fail(route.unsupported("media.aspectRatio", `${id} does not take aspectRatio`));
     if (images > model.maxImages)
-        return Effect.fail(unsupported(id, "images", `takes at most ${model.maxImages} images`));
+        return Effect.fail(route.unsupported("media.images", `${id} takes at most ${model.maxImages} images`));
     if (request.mask !== undefined && !model.mask)
-        return Effect.fail(unsupported(id, "mask", "does not inpaint; use flux-pro-1.0-fill"));
+        return Effect.fail(route.unsupported("media.mask", `${id} does not inpaint; use flux-pro-1.0-fill`));
     return Effect.void;
 };
 const imageInput = (asset) => {
     const value = asset.inline()?.base64 ?? ProviderShared.mediaUrl(asset);
     if (value === undefined)
-        return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts inline images or https URLs`));
+        return Effect.fail(ProviderShared.invalidRequest(`${route.name} accepts inline images or https URLs`));
     return Effect.succeed(value);
 };
 const fromRequest = Effect.fn("BlackForestLabsImages.fromRequest")(function* (request) {
@@ -100,11 +92,11 @@ const fromRequest = Effect.fn("BlackForestLabsImages.fromRequest")(function* (re
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+const decodeStart = route.decodeStarted(StartResponse, (value) => ({
     token: { id: value.id, pollingURL: value.polling_url },
     snapshot: { id: value.id, status: "queued" },
 }));
-const decodeDocument = MediaProtocol.decodeJson(ADAPTER, NAME, Result);
+const decodeDocument = route.decodeJson(Result);
 const decodeStatus = Effect.fn("BlackForestLabsImages.decodeStatus")(function* (response, context) {
     const output = yield* decodeDocument(response);
     return { id: context.token.id, status: yield* MediaProtocol.status(STATUS, output.value.status, output) };
@@ -114,11 +106,11 @@ const decodeResult = Effect.fn("BlackForestLabsImages.decodeResult")(function* (
     const document = output.value;
     const status = yield* MediaProtocol.status(STATUS, document.status, output);
     if (isModerated(document.status))
-        return yield* output.contentPolicy(`${NAME} moderated the generation`);
+        return yield* output.contentPolicy(`${route.name} moderated the generation`);
     if (status === "failed" || status === "expired")
-        return yield* output.ended(status, `${NAME} generation ${context.token.id} ended with ${document.status}`);
+        return yield* output.ended(status, `${route.name} generation ${context.token.id} ended with ${document.status}`);
     if (status !== "completed" || document.result === undefined || document.result === null)
-        return yield* output.invalid(`${NAME} generation ${context.token.id} has no result`);
+        return yield* output.invalid(`${route.name} generation ${context.token.id} has no result`);
     const { sample, seed, prompt, ...rest } = document.result;
     return new ImageResponse({
         // `sample` is a signed URL that expires 10 minutes after the result is ready, so it is downloaded now.
@@ -132,21 +124,13 @@ const decodeResult = Effect.fn("BlackForestLabsImages.decodeResult")(function* (
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.queued({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.queued(route, {
     token: Token,
     start: { body: { from: fromRequest }, decode: decodeStart },
     status: { path: (token) => token.pollingURL, decode: decodeStatus },
     result: { path: (token) => token.pollingURL, decode: decodeResult },
 });
-export const model = (input) => ImageModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
-    protocol,
-    baseURL: DEFAULT_BASE_URL,
-    path: ({ request }) => `/v1/${request.model.id}`,
-}, input);
+export const model = (input) => ImageModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => `/v1/${request.model.id}` }, input);
 export const BlackForestLabsImages = {
     protocol,
     model,

package/dist/protocols/cartesia-speech.d.ts

@@ -1,12 +1,12 @@
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 import { SpeechModel, type SpeechRequestFor } from "../speech.js";
 import { SpeechStream } from "./utils/speech-stream.js";
 export declare const DEFAULT_BASE_URL = "https://api.cartesia.ai";
 export declare const API_VERSION = "2026-08-14";
 export declare const BYTES_PATH = "/tts/bytes";
 export declare const SSE_PATH = "/tts/sse";
-export type CartesiaSpeechString<Known extends string> = Known | (string & {});
 export type CartesiaEncoding = SpeechStream.PcmEncoding;
 export type CartesiaSpeechOptions = {
     readonly sampleRate?: 8000 | 16000 | 22050 | 24000 | 44100 | 48000;
@@ -14,7 +14,7 @@ export type CartesiaSpeechOptions = {
     readonly encoding?: CartesiaEncoding;
     readonly generation_config?: {
         readonly volume?: number;
-        readonly emotion?: CartesiaSpeechString<"neutral" | "calm" | "angry" | "content" | "sad" | "scared">;
+        readonly emotion?: OpenString<"neutral" | "calm" | "angry" | "content" | "sad" | "scared">;
     };
     readonly pronunciation_dict_id?: string;
 } & Record<string, unknown>;