@opencode/ai 2.0.14 → 2.0.16

package/dist/promise.js

@@ -0,0 +1,81 @@
+import { Effect, Layer, ManagedRuntime, Stream } from "effect";
+import { Image, ImageModel, ImageRequest } from "./image.js";
+import { ImageClient } from "./image-client.js";
+import { LLM } from "./index.js";
+import { LLMClient } from "./route/client.js";
+import { RequestExecutor } from "./route/executor.js";
+import { LanguageModel, LLMRequest } from "./schema/index.js";
+import { Speech, SpeechModel, SpeechRequest } from "./speech.js";
+import { SpeechClient } from "./speech-client.js";
+import { Transcription, TranscriptionModel, TranscriptionRequest, } from "./transcription.js";
+import { TranscriptionClient } from "./transcription-client.js";
+import { Video, VideoModel, VideoRequest } from "./video.js";
+import { VideoClient } from "./video-client.js";
+const abortEffect = (signal) => signal === undefined
+    ? Effect.never
+    : Effect.callback((resume) => {
+        if (signal.aborted) {
+            resume(Effect.void);
+            return;
+        }
+        const onAbort = () => resume(Effect.void);
+        signal.addEventListener("abort", onAbort, { once: true });
+        return Effect.sync(() => signal.removeEventListener("abort", onAbort));
+    });
+export const make = (options = {}) => {
+    const runtime = ManagedRuntime.make(Layer.mergeAll(LLMClient.layer, ImageClient.layer, VideoClient.layer, SpeechClient.layer, TranscriptionClient.layer).pipe(Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer)));
+    /** Run any package Effect (for example `asset.bytes()`) inside this runtime. */
+    const run = (effect, options) => runtime.runPromise(effect, { signal: options?.signal });
+    const iterate = (stream, options) => Stream.toAsyncIterable(Stream.unwrap(runtime.contextEffect.pipe(Effect.map((context) => stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context))))));
+    const handle = (generation) => ({
+        ...generation.snapshot,
+        token: generation.token,
+        await: (options) => run(generation.await({ poll: options?.poll }), options),
+        refresh: (options) => run(generation.refresh(), options).then(handle),
+        cancel: (options) => run(generation.cancel(), options),
+    });
+    // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
+    const llmRequest = (input) => (input instanceof LLMRequest ? input : LLM.request(input));
+    const imageRequest = (input) => input instanceof ImageRequest ? input : Image.request(input);
+    const videoRequest = (input) => input instanceof VideoRequest ? input : Video.request(input);
+    const speechRequest = (input) => input instanceof SpeechRequest ? input : Speech.request(input);
+    const transcriptionRequest = (input) => input instanceof TranscriptionRequest ? input : Transcription.request(input);
+    return {
+        run,
+        llm: {
+            request: LLM.request,
+            generate: (input, options) => run(LLM.generate(llmRequest(input)), options),
+            stream: (input, options) => iterate(LLM.stream(llmRequest(input)), options),
+        },
+        image: {
+            request: Image.request,
+            generate: (input, options) => run(Image.generate(imageRequest(input), { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Image.stream(imageRequest(input), { poll: options?.poll }), options),
+            start: (input, options) => run(Image.start(imageRequest(input)), options).then(handle),
+            resume: (model, token, options) => run(Image.resume(model, token), options).then(handle),
+        },
+        video: {
+            request: Video.request,
+            start: (input, options) => run(Video.start(videoRequest(input)), options).then(handle),
+            generate: (input, options) => run(Video.generate(videoRequest(input), { poll: options?.poll }), options),
+            resume: (model, token, options) => run(Video.resume(model, token), options).then(handle),
+            stream: (input, options) => iterate(Video.stream(videoRequest(input), { poll: options?.poll }), options),
+        },
+        speech: {
+            request: Speech.request,
+            generate: (input, options) => run(Speech.generate(speechRequest(input)), options),
+            stream: (input, options) => iterate(Speech.stream(speechRequest(input)), options),
+        },
+        transcription: {
+            request: Transcription.request,
+            generate: (input, options) => run(Transcription.generate(transcriptionRequest(input), { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Transcription.stream(transcriptionRequest(input), { poll: options?.poll }), options),
+            start: (input, options) => run(Transcription.start(transcriptionRequest(input)), options).then(handle),
+            resume: (model, token, options) => run(Transcription.resume(model, token), options).then(handle),
+        },
+        dispose: () => runtime.dispose(),
+    };
+};
+/** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
+export const ai = make();
+export * as AI from "./promise.js";

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-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.js

@@ -537,7 +537,7 @@ const citationsFromMetadata = (metadata) => {
 };
 const isHttpUrl = (value) => /^https?:\/\//i.test(value.trim());
 const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, breakpoints) {
-    const mime = part.mediaType.toLowerCase();
+    const mime = part.media.mediaType.toLowerCase();
     const cacheControlValue = breakpoints ? cacheControl(breakpoints, part.cache) : undefined;
     const fileId = fileIdFromMetadata(part.metadata);
     // SDK file sources: FileImageSource:2350 / FileDocumentSource:2344 {type:"file", file_id}
@@ -564,9 +564,9 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
                 : { citations: citationsFromMetadata(part.metadata) }),
         };
     }
-    const rawString = typeof part.data === "string" ? part.data.trim() : undefined;
+    const rawString = ProviderShared.mediaUrl(part.media)?.trim();
     // SDK URL sources: URLImageSource:3817 / URLPDFSource:3823 {type:"url", url}
-    if (rawString && isHttpUrl(rawString) && !rawString.startsWith("data:")) {
+    if (rawString && isHttpUrl(rawString)) {
         if (mime.startsWith("image/"))
             return {
                 type: "image",
@@ -590,19 +590,10 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
                     : { citations: citationsFromMetadata(part.metadata) }),
             };
     }
+    const media = yield* ProviderShared.requireInlineMedia("Anthropic Messages", part.media);
     // SDK PlainTextSource:2716 {type:"text", media_type:"text/plain", data}
     if (mime === "text/plain") {
-        const textData = typeof part.data !== "string"
-            ? Buffer.from(part.data).toString("utf8")
-            : part.data.startsWith("data:")
-                ? (() => {
-                    const comma = part.data.indexOf(",");
-                    const payload = comma >= 0 ? part.data.slice(comma + 1) : part.data;
-                    return part.data.includes(";base64")
-                        ? Buffer.from(payload, "base64").toString("utf8")
-                        : decodeURIComponent(payload);
-                })()
-                : part.data;
+        const textData = Buffer.from(media.base64, "base64").toString("utf8");
         return {
             type: "document",
             source: { type: "text", media_type: "text/plain", data: textData },
@@ -616,7 +607,6 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
                 : { citations: citationsFromMetadata(part.metadata) }),
         };
     }
-    const media = ProviderShared.normalizeMedia(part);
     if (media.mime === "application/pdf")
         return {
             type: "document",
@@ -635,7 +625,7 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
                 : { citations: citationsFromMetadata(part.metadata) }),
         };
     if (!media.mime.startsWith("image/"))
-        return yield* invalid(`Anthropic Messages does not support media type ${part.mediaType}`);
+        return yield* invalid(`Anthropic Messages does not support media type ${part.media.mediaType}`);
     return {
         type: "image",
         source: {
@@ -654,7 +644,7 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
 const lowerToolResultContentItem = Effect.fnUntraced(function* (item) {
     if (item.type === "text")
         return { type: "text", text: item.text };
-    return yield* lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name });
+    return yield* lowerMedia(ProviderShared.toolFileMedia(item));
 });
 const lowerToolResultContent = Effect.fnUntraced(function* (part) {
     // Text / json / error results stay as a string for backward compatibility
@@ -907,7 +897,6 @@ 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.
@@ -915,7 +904,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     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)));
+        : flattened.tools.map((tool) => lowerTool(breakpoints, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model)));
     // 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);

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

@@ -0,0 +1,40 @@
+import { Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.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<"universal-3-5-pro" | "universal-2" | (string & {})>;
+} & 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,138 @@
+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 { 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");
+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 = MediaProtocol.decodeJson(ADAPTER, NAME, 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 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);
+    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, require speaker labels.
+        speaker_labels: request.diarize === true || request.timestamps === "segment" ? true : undefined,
+        speakers_expected: request.speakers,
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeTranscript = MediaProtocol.decodeJson(ADAPTER, NAME, 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", `${NAME} transcription failed${error === undefined ? "" : `: ${error}`}`);
+    if (status !== "completed")
+        return yield* output.invalid(`${NAME} transcript ${context.token.transcriptID} has not finished`);
+    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({
+    id: ADAPTER,
+    name: NAME,
+    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 AssemblyAITranscription = {
+    protocol,
+    model,
+};

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

@@ -157,7 +157,7 @@ export declare const protocol: Protocol<{
             };
         } | {
             readonly document: {
-                readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+                readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
                 readonly name: string;
                 readonly source: {
                     readonly bytes: string;
@@ -176,7 +176,7 @@ export declare const protocol: Protocol<{
                     };
                 } | {
                     readonly document: {
-                        readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+                        readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
                         readonly name: string;
                         readonly source: {
                             readonly bytes: string;
@@ -386,7 +386,7 @@ export declare const route: Route<{
             };
         } | {
             readonly document: {
-                readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+                readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
                 readonly name: string;
                 readonly source: {
                     readonly bytes: string;
@@ -405,7 +405,7 @@ export declare const route: Route<{
                     };
                 } | {
                     readonly document: {
-                        readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+                        readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
                         readonly name: string;
                         readonly source: {
                             readonly bytes: string;

package/dist/protocols/bedrock-converse.js

@@ -13,6 +13,7 @@ import { Lifecycle } from "./utils/lifecycle.js";
 import { MistralToolID } from "./utils/mistral-tool-id.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
+import { concatBytes } from "../utils/bytes.js";
 const ADAPTER = "bedrock-converse";
 // =============================================================================
 // Request Body Schema
@@ -162,10 +163,10 @@ const lowerToolSpec = (tool, inputSchema) => ({
         inputSchema: { json: inputSchema },
     },
 });
-const lowerTools = (compatibility, breakpoints, tools) => {
+const lowerTools = (model, breakpoints, tools) => {
     const result = [];
     for (const tool of tools) {
-        result.push(lowerToolSpec(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility)));
+        result.push(lowerToolSpec(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, model)));
         const cachePoint = BedrockCache.block(breakpoints, tool.cache);
         if (cachePoint)
             result.push(cachePoint);
@@ -221,12 +222,7 @@ const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent
             content.push({ text: item.text });
             continue;
         }
-        const media = yield* BedrockMedia.lower({
-            type: "media",
-            mediaType: item.mime,
-            data: item.uri,
-            filename: item.name,
-        }, documentNames);
+        const media = yield* BedrockMedia.lower(ProviderShared.toolFileMedia(item), documentNames);
         content.push(...media);
     }
     return content;
@@ -353,7 +349,7 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request)
         if (flattened.tools.length === 0)
             return undefined;
         return {
-            tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, flattened.tools),
+            tools: lowerTools(request.model, breakpoints, flattened.tools),
             // Converse has no native "none". Keep definitions stable for prompt
             // caching and omit only the unsupported choice.
             toolChoice,
@@ -418,14 +414,7 @@ const mapUsage = (usage, providerMetadataKey) => {
         providerMetadata: { [providerMetadataKey]: usage },
     });
 };
-const encodeRedactedContent = (chunks) => {
-    const bytes = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
-    chunks.reduce((offset, chunk) => {
-        bytes.set(chunk, offset);
-        return offset + chunk.length;
-    }, 0);
-    return Encoding.encodeBase64(bytes);
-};
+const encodeRedactedContent = (chunks) => Encoding.encodeBase64(concatBytes(chunks));
 const step = (state, event) => Effect.gen(function* () {
     if (event.contentBlockStart?.start?.toolUse) {
         const index = event.contentBlockStart.contentBlockIndex;

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

@@ -0,0 +1,32 @@
+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";
+export declare const DEFAULT_BASE_URL = "https://api.bfl.ai";
+export type BlackForestLabsImageOptions = {
+    readonly safety_tolerance?: number;
+    readonly prompt_upsampling?: boolean;
+    readonly disable_pup?: boolean;
+    readonly raw?: boolean;
+    readonly guidance?: number;
+    readonly steps?: number;
+} & Record<string, unknown>;
+export type Request = ImageRequestFor<BlackForestLabsImageOptions>;
+/** Regional clusters answer on different hosts, so the returned `polling_url` is followed verbatim. */
+export declare const Token: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly pollingURL: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, ImageResponse, {
+    readonly id: string;
+    readonly pollingURL: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<BlackForestLabsImageOptions>;
+export declare const BlackForestLabsImages: {
+    readonly protocol: MediaProtocol.Queued<Request, ImageResponse, {
+        readonly id: string;
+        readonly pollingURL: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<BlackForestLabsImageOptions>;
+};