@opencode/ai 2.0.15 → 2.0.17

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

@@ -50,6 +50,12 @@ export declare const protocol: Protocol<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -65,6 +71,12 @@ export declare const protocol: Protocol<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;

package/dist/protocols/alibaba-chat.js

@@ -55,7 +55,10 @@ export const protocol = Protocol.make({
             return {
                 ...(yield* OpenAIChat.protocol.body.from(req)),
                 enable_thinking: opts.enableThinking,
-                thinking_budget: opts.thinkingBudget,
+                // Alibaba also rejects an explicit budget that is not below `max_completion_tokens`.
+                thinking_budget: opts.thinkingBudget === undefined
+                    ? undefined
+                    : ProviderShared.fitThinkingBudget(opts.thinkingBudget, req.generation?.maxTokens),
                 preserve_thinking: opts.preserveThinking,
                 clear_thinking: opts.clearThinking,
                 thinking: opts.thinking,

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/alibaba-messages.js

@@ -22,15 +22,17 @@ export const protocol = Protocol.make({
         from: Effect.fn("AlibabaMessages.fromRequest")(function* (req) {
             const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {});
             // Model Studio accepts enabled thinking without Anthropic's mandatory token budget.
+            const body = yield* AnthropicMessages.protocol.body.from(LLMRequest.update(req, {
+                providerOptions: { ...req.providerOptions, thinking: undefined },
+            }));
+            const budget = opts.thinking?.budgetTokens ?? opts.thinking?.budget_tokens;
             return {
-                ...(yield* AnthropicMessages.protocol.body.from(LLMRequest.update(req, {
-                    providerOptions: { ...req.providerOptions, thinking: undefined },
-                }))),
+                ...body,
                 thinking: opts.thinking === undefined
                     ? undefined
                     : {
                         type: opts.thinking.type,
-                        budget_tokens: opts.thinking.budgetTokens ?? opts.thinking.budget_tokens,
+                        budget_tokens: budget === undefined ? undefined : ProviderShared.fitThinkingBudget(budget, body.max_tokens),
                     },
             };
         }),

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

@@ -77,8 +77,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -114,8 +114,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";

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/anthropic-messages.js

@@ -14,12 +14,12 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { effortUpdate, resolveEffortUpdates } from "../effort-updates.js";
 import * as Cache from "./utils/cache.js";
 import { Lifecycle } from "./utils/lifecycle.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "anthropic-messages";
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 export const PATH = "/messages";
 export const DEFAULT_MAX_TOKENS = 32_000;
+const MIN_THINKING_BUDGET = 1_024;
 const DEFAULT_EFFORT = "high";
 const SSE_EVENTS = new Set([
     "message",
@@ -407,10 +407,10 @@ const redactedDataFromMetadata = (metadata, key) => {
         return undefined;
     return typeof provider.redactedData === "string" ? provider.redactedData : undefined;
 };
-const lowerTool = (breakpoints, tool, inputSchema) => ({
+const lowerTool = (breakpoints, tool) => ({
     name: tool.name,
     description: tool.description,
-    input_schema: inputSchema,
+    input_schema: tool.inputSchema,
     cache_control: cacheControl(breakpoints, tool.cache),
 });
 const lowerToolChoice = (toolChoice) => ProviderShared.matchToolChoice("Anthropic Messages", toolChoice, {
@@ -890,6 +890,13 @@ const applyThinkingBindingDefault = (model, thinking) => {
         },
     };
 };
+// Anthropic also requires an explicit thinking budget below `max_tokens` and at or above its minimum.
+const fitThinking = (thinking, maxTokens) => thinking?.type === "enabled"
+    ? {
+        ...thinking,
+        budget_tokens: ProviderShared.fitThinkingBudget(thinking.budget_tokens, maxTokens, MIN_THINKING_BUDGET),
+    }
+    : thinking;
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
     const options = yield* decodeOptions(request.providerOptions ?? {});
     const management = options.contextManagement;
@@ -897,15 +904,12 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     const format = outputConfig?.format ?? undefined;
     const updates = resolveEffortUpdates(request, options.effort ?? outputConfig?.effort ?? undefined);
     const generation = request.generation;
-    const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     // Allocate the 4-breakpoint budget in invalidation order: tools → system →
     // messages. Tools live highest in the cache hierarchy, so when callers
     // over-mark we keep their tool hints and shed the message-tail ones first.
     const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP);
     const flattened = ProviderShared.flattenToolRequest(updates.request);
-    const tools = flattened.tools.length === 0
-        ? undefined
-        : flattened.tools.map((tool) => lowerTool(breakpoints, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)));
+    const tools = flattened.tools.length === 0 ? undefined : flattened.tools.map((tool) => lowerTool(breakpoints, tool));
     // Anthropic rejects tool_choice when tools are absent; "none" is only meaningful with tools present.
     const toolChoice = tools === undefined || !request.toolChoice ? undefined : yield* lowerToolChoice(request.toolChoice);
     const systemParts = request.system.filter((part) => part.text.length > 0);
@@ -921,6 +925,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
         yield* Effect.logWarning(`Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`);
     }
     const output_config = updates.effort === undefined && format === undefined ? undefined : { effort: updates.effort, format };
+    const maxTokens = generation?.maxTokens ?? DEFAULT_MAX_TOKENS;
     const body = {
         model: request.model.id,
         system,
@@ -928,12 +933,12 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
         tools,
         tool_choice: toolChoice,
         stream: true,
-        max_tokens: generation?.maxTokens ?? DEFAULT_MAX_TOKENS,
+        max_tokens: maxTokens,
         temperature: generation?.temperature,
         top_p: generation?.topP,
         top_k: generation?.topK,
         stop_sequences: generation?.stop,
-        thinking: applyThinkingBindingDefault(request.model, options.thinking),
+        thinking: applyThinkingBindingDefault(request.model, fitThinking(options.thinking, maxTokens)),
         output_config,
         // top-level passthrough per SDK MessageCreateParamsBase:4638,4643,4649,4654,4670
         cache_control: options.cache_control ?? options.cacheControl,

package/dist/protocols/assemblyai-transcription.d.ts

@@ -0,0 +1,41 @@
+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";
+export declare const UPLOAD_PATH = "/v2/upload";
+export type AssemblyAITranscriptionOptions = {
+    readonly keyterms_prompt?: ReadonlyArray<string>;
+    readonly punctuate?: boolean;
+    readonly format_text?: boolean;
+    readonly disfluencies?: boolean;
+    readonly filter_profanity?: boolean;
+    readonly temperature?: number;
+    readonly speaker_options?: {
+        readonly min_speakers_expected?: number;
+        readonly max_speakers_expected?: number;
+    };
+    readonly language_detection_options?: {
+        readonly expected_languages?: ReadonlyArray<string>;
+        readonly fallback_language?: string;
+        readonly code_switching?: boolean;
+    };
+    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<{
+    readonly transcriptID: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, TranscriptionResponse, {
+    readonly transcriptID: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<AssemblyAITranscriptionOptions>;
+export declare const AssemblyAITranscription: {
+    readonly protocol: MediaProtocol.Queued<Request, TranscriptionResponse, {
+        readonly transcriptID: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => TranscriptionModel<AssemblyAITranscriptionOptions>;
+};

package/dist/protocols/assemblyai-transcription.js

@@ -0,0 +1,136 @@
+import { Effect, Schema } from "effect";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.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 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";
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+export const Token = Schema.Struct({ transcriptID: Schema.String });
+const Upload = Schema.Struct({ upload_url: Schema.String });
+/** Word and utterance times are milliseconds. */
+const Transcript = Schema.Struct({
+    id: Schema.String,
+    status: Schema.String,
+    text: optionalNull(Schema.String),
+    words: optionalNull(Schema.Array(Schema.Struct({
+        text: Schema.String,
+        start: Schema.Number,
+        end: Schema.Number,
+        confidence: optionalNull(Schema.Number),
+        speaker: optionalNull(Schema.String),
+    }))),
+    utterances: optionalNull(Schema.Array(Schema.Struct({
+        text: Schema.String,
+        start: Schema.Number,
+        end: Schema.Number,
+        speaker: optionalNull(Schema.String),
+    }))),
+    language_code: optionalNull(Schema.String),
+    audio_duration: optionalNull(Schema.Number),
+    speech_model_used: optionalNull(Schema.String),
+    error: optionalNull(Schema.String),
+});
+const STATUS = {
+    queued: "queued",
+    processing: "running",
+    completed: "completed",
+    error: "failed",
+};
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+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(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, route.provider, route.name);
+    return MediaProtocol.json(mergeJsonRecords({
+        audio_url: audio.value,
+        speech_models: [request.model.id],
+        language_code: request.language,
+        language_detection: request.language === undefined ? true : undefined,
+        prompt: request.prompt,
+        // Turn-level `utterances`, the only segments AssemblyAI returns, and `speakers_expected` require speaker labels.
+        speaker_labels: request.diarize === true || request.timestamps === "segment" || request.speakers !== undefined
+            ? true
+            : undefined,
+        speakers_expected: request.speakers,
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+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);
+    return { token: { transcriptID: output.value.id }, snapshot: { id: output.value.id, status } };
+});
+const decodeStatus = Effect.fn("AssemblyAITranscription.decodeStatus")(function* (response, context) {
+    const output = yield* decodeTranscript(response);
+    const status = yield* MediaProtocol.status(STATUS, output.value.status, output);
+    return { id: context.token.transcriptID, status };
+});
+const seconds = (milliseconds) => milliseconds / 1000;
+const decodeResult = Effect.fn("AssemblyAITranscription.decodeResult")(function* (response, context) {
+    const output = yield* decodeTranscript(response);
+    const transcript = output.value;
+    const status = yield* MediaProtocol.status(STATUS, transcript.status, output);
+    const error = transcript.error ?? undefined;
+    if (status === "failed")
+        return yield* output.ended("failed", `${route.name} transcription failed${error === undefined ? "" : `: ${error}`}`);
+    if (status !== "completed")
+        return yield* output.pending(context.token.transcriptID);
+    const duration = transcript.audio_duration ?? undefined;
+    return new TranscriptionResponse({
+        text: transcript.text ?? "",
+        segments: transcript.utterances?.map((utterance) => ({
+            text: utterance.text,
+            startSeconds: seconds(utterance.start),
+            endSeconds: seconds(utterance.end),
+            speaker: utterance.speaker ?? undefined,
+        })),
+        words: transcript.words?.map((word) => ({
+            text: word.text,
+            startSeconds: seconds(word.start),
+            endSeconds: seconds(word.end),
+            speaker: word.speaker ?? undefined,
+            confidence: word.confidence ?? undefined,
+        })),
+        language: transcript.language_code?.toLowerCase(),
+        durationSeconds: duration,
+        usage: duration === undefined ? undefined : { type: "seconds", seconds: duration },
+        providerMetadata: {
+            assemblyai: { transcriptId: transcript.id, speechModel: transcript.speech_model_used ?? undefined },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+const transcriptPath = (token) => `${PATH}/${token.transcriptID}`;
+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({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const AssemblyAITranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/bedrock-converse.d.ts

@@ -126,6 +126,13 @@ declare const BedrockConverseBody: Schema.Struct<{
     additionalModelRequestFields: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>;
 export type BedrockConverseBody = Schema.Schema.Type<typeof BedrockConverseBody>;
+declare const Options: Schema.Struct<{
+    readonly thinking: Schema.optional<Schema.Struct<{
+        readonly type: Schema.Literal<"enabled">;
+        readonly budgetTokens: Schema.Number;
+    }>>;
+}>;
+export type OptionsInput = typeof Options.Type;
 interface ParserState {
     readonly providerMetadataKey: string;
     readonly tools: ToolStream.State<number>;