@opencode-ai/ai 0.0.0-bootstrap.0 → 0.0.0-next-15618

package/dist/protocols/shared.d.ts

@@ -0,0 +1,192 @@
+import { Buffer } from "node:buffer";
+import { Effect, Schema, Stream } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { LLMError, type ContentPart, type LLMRequest, type ToolFileContent, type ToolResultPart } from "../schema";
+import { isRecord } from "../utils/record";
+export { isRecord };
+export declare const Json: Schema.fromJsonString<Schema.Unknown>;
+export declare const decodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => unknown;
+export declare const encodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string;
+export declare const JsonObject: Schema.$Record<Schema.String, Schema.Unknown>;
+export declare const optionalArray: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.$Array<S>>;
+export declare const optionalNull: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.NullOr<S>>;
+/**
+ * Streaming tool-call accumulator. Adapters that build a tool call across
+ * multiple `tool-input-delta` chunks store the partial JSON input string here
+ * and finalize it with `parseToolInput` once the call completes.
+ */
+export interface ToolAccumulator {
+    readonly id: string;
+    readonly name: string;
+    readonly input: string;
+}
+/**
+ * `Usage.totalTokens` policy shared by every route. Honors a provider-
+ * supplied total; otherwise falls back to `inputTokens + outputTokens` only
+ * when at least one is defined. Returns `undefined` when neither input nor
+ * output is known so routes don't publish a misleading `0`.
+ *
+ * Under the additive `LLM.Usage` contract, `inputTokens` and `outputTokens`
+ * are the non-cached input and visible output only. The provider-supplied
+ * `total` is the source of truth when present; the computed fallback
+ * under-counts cache and reasoning by design and exists mainly so
+ * Anthropic-style providers (which don't surface a total) still get a
+ * sensible aggregate on the input + output axes.
+ */
+export declare const totalTokens: (inputTokens: number | undefined, outputTokens: number | undefined, total: number | undefined) => number | undefined;
+/**
+ * Subtract `subtrahend` from `total`, clamping to zero if the provider
+ * reports a non-sensical breakdown (e.g. `cached_tokens > prompt_tokens`).
+ * Used by protocol mappers when deriving a non-overlapping breakdown field
+ * from a provider's inclusive total — `nonCachedInputTokens` from
+ * `inputTokens - cacheReadInputTokens - cacheWriteInputTokens`.
+ *
+ * If `total` is `undefined`, returns `undefined` (we don't fabricate
+ * counts). If `subtrahend` is `undefined`, returns `total` unchanged. The
+ * provider-native breakdown stays available on `Usage.native` for debugging.
+ */
+export declare const subtractTokens: (total: number | undefined, subtrahend: number | undefined) => number | undefined;
+/**
+ * Sum a list of optional token counts, returning `undefined` only when
+ * every value is `undefined` (so we don't fabricate a `0`). Used by
+ * protocol mappers to derive the inclusive `inputTokens` total from a
+ * provider that natively reports a non-overlapping breakdown
+ * (e.g. Anthropic, whose `input_tokens` is already non-cached only).
+ */
+export declare const sumTokens: (...values: ReadonlyArray<number | undefined>) => number | undefined;
+export declare const eventError: (route: string, message: string, raw?: string) => LLMError;
+export declare const parseJson: (route: string, input: string, message: string) => Effect.Effect<unknown, LLMError, never>;
+/**
+ * Join the `text` field of a list of parts with newlines. Used by routes
+ * that flatten system / message content arrays into a single provider string
+ * (OpenAI Chat `system` content, OpenAI Responses `system` content, Gemini
+ * `systemInstruction.parts[].text`).
+ */
+export declare const joinText: (parts: ReadonlyArray<{
+    readonly text: string;
+}>) => string;
+/**
+ * Stable fallback representation for chronological `Message.system(...)`
+ * updates on routes that do not support that privileged role natively. The
+ * wrapper remains visibly lower-authority user text, preserves the original
+ * temporal position, and XML-escapes content so it cannot close the wrapper.
+ */
+export declare const wrapSystemUpdate: (parts: ReadonlyArray<{
+    readonly text: string;
+}>) => string;
+/**
+ * Chronological system updates deliberately accept text only. Do not insert
+ * raw retrieved, tool, or web content into privileged updates: keep untrusted
+ * data in ordinary user/tool messages instead.
+ */
+export declare const systemUpdateText: (route: string, message: import("..").Message) => Effect.Effect<{
+    readonly type: "text";
+    readonly text: string;
+    readonly cache?: import("..").CacheHint | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+}[], LLMError, never>;
+/** Lower an unsupported privileged update into visible, in-order user text. */
+export declare const wrappedSystemUpdate: (route: string, message: import("..").Message) => Effect.Effect<{
+    type: "text";
+    text: string;
+    cache: import("..").CacheHint | undefined;
+}, LLMError, never>;
+/**
+ * Parse the streamed JSON input of a tool call. Treats an empty string as
+ * `"{}"` — providers occasionally finish a tool call without ever emitting
+ * input deltas (e.g. zero-arg tools). The error message is uniform across
+ * routes: `Invalid JSON input for <route> tool call <name>`.
+ */
+export declare const parseToolInput: (route: string, name: string, raw: string) => Effect.Effect<unknown, LLMError, never>;
+export declare const IMAGE_MIMES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
+export declare const VIDEO_MIMES: readonly ["video/mp4", "video/webm", "video/quicktime"];
+export declare const AUDIO_MIMES: readonly ["audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac"];
+export declare const MEDIA_MIMES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp", "video/mp4", "video/webm", "video/quicktime", "audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac"];
+export declare const MAX_MEDIA_ENCODED_BYTES: number;
+export declare const MAX_MEDIA_DECODED_BYTES: number;
+export interface ValidatedMedia {
+    readonly mime: string;
+    readonly base64: string;
+    readonly dataUrl: string;
+    readonly bytes: Uint8Array;
+}
+export declare const validateMedia: (route: string, part: {
+    readonly type: "media";
+    readonly mediaType: string;
+    readonly data: string | Uint8Array<ArrayBufferLike>;
+    readonly filename?: string | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+}, supportedMimes: ReadonlySet<string>) => Effect.Effect<{
+    mime: string;
+    base64: string;
+    dataUrl: string;
+    bytes: Buffer<ArrayBuffer>;
+}, LLMError, never>;
+export declare const validateToolFile: (route: string, part: ToolFileContent, supportedMimes: ReadonlySet<string>) => Effect.Effect<{
+    mime: string;
+    base64: string;
+    dataUrl: string;
+    bytes: Buffer<ArrayBuffer>;
+}, LLMError, never>;
+export declare const trimBaseUrl: (value: string) => string;
+export declare const toolResultText: (part: ToolResultPart) => string;
+export declare const errorText: (error: unknown) => string;
+/**
+ * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
+ * decoder, and drops empty / `[DONE]` keep-alive events so the downstream
+ * `decodeChunk` sees one JSON string per element. The SSE channel emits a
+ * `Retry` control event on its error channel; we drop it here (we don't
+ * implement client-driven retries) so the public error channel stays
+ * `LLMError`.
+ */
+export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, LLMError>) => Stream.Stream<string, LLMError>;
+/**
+ * Canonical invalid-request constructor. Lift one-line `const invalid =
+ * (message) => invalidRequest(message)` aliases out of every
+ * route so the error constructor lives in one place. If we ever extend
+ * `InvalidRequestReason` with route context or trace metadata, the change
+ * lands here.
+ */
+export declare const invalidRequest: (message: string) => LLMError;
+export declare const matchToolChoice: <Auto, None, Required, Tool>(route: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>, cases: {
+    readonly auto: () => Auto;
+    readonly none: () => None;
+    readonly required: () => Required;
+    readonly tool: (name: string) => Tool;
+}) => Effect.Effect<Auto | None | Required | Tool, LLMError, never>;
+type ContentType = ContentPart["type"];
+export declare const supportsContent: <const Type extends ContentType>(part: ContentPart, types: ReadonlyArray<Type>) => part is Extract<ContentPart, {
+    readonly type: Type;
+}>;
+export declare const unsupportedContent: (route: string, role: LLMRequest["messages"][number]["role"], types: ReadonlyArray<ContentType>) => LLMError;
+/**
+ * Build a `validate` step from a Schema decoder. Replaces the per-route
+ * lambda body `(payload) => decode(payload).pipe(Effect.mapError((e) =>
+ * invalid(e.message)))`. Any decode error is translated into
+ * `LLMError` carrying the original parse-error message.
+ */
+export declare const validateWith: <A, I, E extends {
+    readonly message: string;
+}>(decode: (input: I) => Effect.Effect<A, E>) => (payload: I) => Effect.Effect<A, LLMError, never>;
+/**
+ * Build an HTTP POST with a JSON body. Sets `content-type: application/json`
+ * automatically after caller-supplied headers so routes cannot accidentally
+ * send JSON with a stale content type. The body is passed pre-encoded so
+ * routes can choose between
+ * `Schema.encodeSync(payload)` and `ProviderShared.encodeJson(payload)`.
+ */
+export declare const jsonPost: (input: {
+    readonly url: string;
+    readonly body: string;
+    readonly headers?: Headers.Input;
+}) => HttpClientRequest.HttpClientRequest;
+export * as ProviderShared from "./shared";

package/dist/protocols/shared.js

@@ -0,0 +1,236 @@
+import { Buffer } from "node:buffer";
+import { Effect, Schema, Stream } from "effect";
+import * as Sse from "effect/unstable/encoding/Sse";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { InvalidProviderOutputReason, InvalidRequestReason, LLMError, } from "../schema";
+import { isRecord } from "../utils/record";
+export { isRecord };
+export const Json = Schema.fromJsonString(Schema.Unknown);
+export const decodeJson = Schema.decodeUnknownSync(Json);
+export const encodeJson = Schema.encodeSync(Json);
+const isJson = Schema.is(Schema.Json);
+export const JsonObject = Schema.Record(Schema.String, Schema.Unknown);
+export const optionalArray = (schema) => Schema.optional(Schema.Array(schema));
+export const optionalNull = (schema) => Schema.optional(Schema.NullOr(schema));
+/**
+ * `Usage.totalTokens` policy shared by every route. Honors a provider-
+ * supplied total; otherwise falls back to `inputTokens + outputTokens` only
+ * when at least one is defined. Returns `undefined` when neither input nor
+ * output is known so routes don't publish a misleading `0`.
+ *
+ * Under the additive `LLM.Usage` contract, `inputTokens` and `outputTokens`
+ * are the non-cached input and visible output only. The provider-supplied
+ * `total` is the source of truth when present; the computed fallback
+ * under-counts cache and reasoning by design and exists mainly so
+ * Anthropic-style providers (which don't surface a total) still get a
+ * sensible aggregate on the input + output axes.
+ */
+export const totalTokens = (inputTokens, outputTokens, total) => {
+    if (total !== undefined)
+        return total;
+    if (inputTokens === undefined && outputTokens === undefined)
+        return undefined;
+    return (inputTokens ?? 0) + (outputTokens ?? 0);
+};
+/**
+ * Subtract `subtrahend` from `total`, clamping to zero if the provider
+ * reports a non-sensical breakdown (e.g. `cached_tokens > prompt_tokens`).
+ * Used by protocol mappers when deriving a non-overlapping breakdown field
+ * from a provider's inclusive total — `nonCachedInputTokens` from
+ * `inputTokens - cacheReadInputTokens - cacheWriteInputTokens`.
+ *
+ * If `total` is `undefined`, returns `undefined` (we don't fabricate
+ * counts). If `subtrahend` is `undefined`, returns `total` unchanged. The
+ * provider-native breakdown stays available on `Usage.native` for debugging.
+ */
+export const subtractTokens = (total, subtrahend) => {
+    if (total === undefined)
+        return undefined;
+    if (subtrahend === undefined)
+        return total;
+    return Math.max(0, total - subtrahend);
+};
+/**
+ * Sum a list of optional token counts, returning `undefined` only when
+ * every value is `undefined` (so we don't fabricate a `0`). Used by
+ * protocol mappers to derive the inclusive `inputTokens` total from a
+ * provider that natively reports a non-overlapping breakdown
+ * (e.g. Anthropic, whose `input_tokens` is already non-cached only).
+ */
+export const sumTokens = (...values) => {
+    if (values.every((value) => value === undefined))
+        return undefined;
+    return values.reduce((acc, value) => acc + (value ?? 0), 0);
+};
+export const eventError = (route, message, raw) => new LLMError({
+    module: "ProviderShared",
+    method: "stream",
+    reason: new InvalidProviderOutputReason({ route, message, raw }),
+});
+export const parseJson = (route, input, message) => Effect.try({
+    try: () => decodeJson(input),
+    catch: () => eventError(route, message, input),
+});
+/**
+ * Join the `text` field of a list of parts with newlines. Used by routes
+ * that flatten system / message content arrays into a single provider string
+ * (OpenAI Chat `system` content, OpenAI Responses `system` content, Gemini
+ * `systemInstruction.parts[].text`).
+ */
+export const joinText = (parts) => parts.map((part) => part.text).join("\n");
+const escapeSystemUpdateText = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+/**
+ * Stable fallback representation for chronological `Message.system(...)`
+ * updates on routes that do not support that privileged role natively. The
+ * wrapper remains visibly lower-authority user text, preserves the original
+ * temporal position, and XML-escapes content so it cannot close the wrapper.
+ */
+export const wrapSystemUpdate = (parts) => `<system-update>\n${escapeSystemUpdateText(joinText(parts))}\n</system-update>`;
+/**
+ * Chronological system updates deliberately accept text only. Do not insert
+ * raw retrieved, tool, or web content into privileged updates: keep untrusted
+ * data in ordinary user/tool messages instead.
+ */
+export const systemUpdateText = Effect.fn("ProviderShared.systemUpdateText")(function* (route, message) {
+    const content = [];
+    for (const part of message.content) {
+        if (!supportsContent(part, ["text"]))
+            return yield* unsupportedContent(route, "system", ["text"]);
+        content.push(part);
+    }
+    return content;
+});
+/** Lower an unsupported privileged update into visible, in-order user text. */
+export const wrappedSystemUpdate = Effect.fn("ProviderShared.wrappedSystemUpdate")(function* (route, message) {
+    const content = yield* systemUpdateText(route, message);
+    return { type: "text", text: wrapSystemUpdate(content), cache: content.at(-1)?.cache };
+});
+/**
+ * Parse the streamed JSON input of a tool call. Treats an empty string as
+ * `"{}"` — providers occasionally finish a tool call without ever emitting
+ * input deltas (e.g. zero-arg tools). The error message is uniform across
+ * routes: `Invalid JSON input for <route> tool call <name>`.
+ */
+export const parseToolInput = (route, name, raw) => parseJson(route, raw || "{}", `Invalid JSON input for ${route} tool call ${name}`);
+export const IMAGE_MIMES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+export const VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
+export const AUDIO_MIMES = ["audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac"];
+export const MEDIA_MIMES = [...IMAGE_MIMES, ...VIDEO_MIMES, ...AUDIO_MIMES];
+export const MAX_MEDIA_ENCODED_BYTES = 28 * 1024 * 1024;
+export const MAX_MEDIA_DECODED_BYTES = 20 * 1024 * 1024;
+const base64Pattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+export const validateMedia = Effect.fn("ProviderShared.validateMedia")(function* (route, part, supportedMimes) {
+    const mime = part.mediaType.toLowerCase();
+    if (!supportedMimes.has(mime))
+        return yield* invalidRequest(`${route} does not support media type ${part.mediaType}`);
+    let base64;
+    if (typeof part.data !== "string") {
+        if (part.data.byteLength > MAX_MEDIA_DECODED_BYTES)
+            return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_DECODED_BYTES} byte decoded limit`);
+        base64 = Buffer.from(part.data).toString("base64");
+    }
+    else if (part.data.startsWith("data:")) {
+        const match = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/s.exec(part.data);
+        if (!match)
+            return yield* invalidRequest(`${route} media data URL must contain valid base64`);
+        if (match[1].toLowerCase() !== mime)
+            return yield* invalidRequest(`${route} media type ${part.mediaType} does not match data URL type ${match[1]}`);
+        base64 = match[2];
+    }
+    else {
+        base64 = part.data;
+    }
+    if (Buffer.byteLength(base64, "utf8") > MAX_MEDIA_ENCODED_BYTES)
+        return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_ENCODED_BYTES} byte encoded limit`);
+    if (!base64 || base64.length % 4 !== 0 || !base64Pattern.test(base64))
+        return yield* invalidRequest(`${route} media must contain valid base64`);
+    const bytes = Buffer.from(base64, "base64");
+    if (bytes.byteLength > MAX_MEDIA_DECODED_BYTES)
+        return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_DECODED_BYTES} byte decoded limit`);
+    if (bytes.toString("base64") !== base64)
+        return yield* invalidRequest(`${route} media must contain canonical base64`);
+    return { mime, base64, dataUrl: `data:${mime};base64,${base64}`, bytes };
+});
+export const validateToolFile = (route, part, supportedMimes) => validateMedia(route, { type: "media", mediaType: part.mime, data: part.uri, filename: part.name }, supportedMimes);
+export const trimBaseUrl = (value) => value.replace(/\/+$/, "");
+export const toolResultText = (part) => {
+    if (part.result.type === "text")
+        return String(part.result.value);
+    if (part.result.type === "error") {
+        const value = part.result.value;
+        const prototype = typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value);
+        const structured = Array.isArray(value) || prototype === Object.prototype || prototype === null;
+        return structured && isJson(value) ? encodeJson(value) : String(value);
+    }
+    return encodeJson(part.result.value);
+};
+export const errorText = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint")
+        return String(error);
+    if (error === null)
+        return "null";
+    if (error === undefined)
+        return "undefined";
+    return "Unknown stream error";
+};
+/**
+ * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
+ * decoder, and drops empty / `[DONE]` keep-alive events so the downstream
+ * `decodeChunk` sees one JSON string per element. The SSE channel emits a
+ * `Retry` control event on its error channel; we drop it here (we don't
+ * implement client-driven retries) so the public error channel stays
+ * `LLMError`.
+ */
+export const sseFraming = (bytes) => bytes.pipe(Stream.decodeText(), Stream.pipeThroughChannel(Sse.decode()), Stream.catchTag("Retry", () => Stream.empty), Stream.filter((event) => event.data.length > 0 && event.data !== "[DONE]"), Stream.map((event) => event.data));
+/**
+ * Canonical invalid-request constructor. Lift one-line `const invalid =
+ * (message) => invalidRequest(message)` aliases out of every
+ * route so the error constructor lives in one place. If we ever extend
+ * `InvalidRequestReason` with route context or trace metadata, the change
+ * lands here.
+ */
+export const invalidRequest = (message) => new LLMError({
+    module: "ProviderShared",
+    method: "request",
+    reason: new InvalidRequestReason({ message }),
+});
+export const matchToolChoice = (route, toolChoice, cases) => Effect.gen(function* () {
+    if (toolChoice.type === "auto")
+        return cases.auto();
+    if (toolChoice.type === "none")
+        return cases.none();
+    if (toolChoice.type === "required")
+        return cases.required();
+    if (!toolChoice.name)
+        return yield* invalidRequest(`${route} tool choice requires a tool name`);
+    return cases.tool(toolChoice.name);
+});
+const formatContentTypes = (types) => {
+    if (types.length <= 1)
+        return types[0] ?? "";
+    if (types.length === 2)
+        return `${types[0]} and ${types[1]}`;
+    return `${types.slice(0, -1).join(", ")}, and ${types.at(-1)}`;
+};
+export const supportsContent = (part, types) => types.includes(part.type);
+export const unsupportedContent = (route, role, types) => invalidRequest(`${route} ${role} messages only support ${formatContentTypes(types)} content for now`);
+/**
+ * Build a `validate` step from a Schema decoder. Replaces the per-route
+ * lambda body `(payload) => decode(payload).pipe(Effect.mapError((e) =>
+ * invalid(e.message)))`. Any decode error is translated into
+ * `LLMError` carrying the original parse-error message.
+ */
+export const validateWith = (decode) => (payload) => decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message)));
+/**
+ * Build an HTTP POST with a JSON body. Sets `content-type: application/json`
+ * automatically after caller-supplied headers so routes cannot accidentally
+ * send JSON with a stale content type. The body is passed pre-encoded so
+ * routes can choose between
+ * `Schema.encodeSync(payload)` and `ProviderShared.encodeJson(payload)`.
+ */
+export const jsonPost = (input) => HttpClientRequest.post(input.url).pipe(HttpClientRequest.setHeaders(Headers.set(Headers.fromInput(input.headers), "content-type", "application/json")), HttpClientRequest.bodyText(input.body, "application/json"));
+export * as ProviderShared from "./shared";

package/dist/protocols/utils/bedrock-auth.d.ts

@@ -0,0 +1,18 @@
+import { Auth } from "../../route/auth";
+/**
+ * AWS credentials for SigV4 signing. Bedrock also supports Bearer API key auth,
+ * which provider facades configure as route auth instead of SigV4. STS-vended
+ * credentials should be refreshed by the consumer (rebuild the model) before
+ * they expire; the route does not refresh.
+ */
+export interface Credentials {
+    readonly region: string;
+    readonly accessKeyId: string;
+    readonly secretAccessKey: string;
+    readonly sessionToken?: string;
+}
+/** Sign the exact JSON bytes with SigV4 using credentials configured on the route. */
+export declare const sigV4: (credentials: Credentials | undefined) => Auth.Definition;
+/** Bedrock route auth defaults to SigV4 and expects credentials from route configuration. */
+export declare const auth: Auth.Definition;
+export * as BedrockAuth from "./bedrock-auth";

package/dist/protocols/utils/bedrock-auth.js

@@ -0,0 +1,41 @@
+import { AwsV4Signer } from "aws4fetch";
+import { Effect } from "effect";
+import { Headers } from "effect/unstable/http";
+import { Auth } from "../../route/auth";
+import { ProviderShared } from "../shared";
+const signRequest = (input) => Effect.tryPromise({
+    try: async () => {
+        const signed = await new AwsV4Signer({
+            url: input.url,
+            method: "POST",
+            headers: Object.entries(input.headers),
+            body: input.body,
+            region: input.credentials.region,
+            accessKeyId: input.credentials.accessKeyId,
+            secretAccessKey: input.credentials.secretAccessKey,
+            sessionToken: input.credentials.sessionToken,
+            service: "bedrock",
+        }).sign();
+        return Object.fromEntries(signed.headers.entries());
+    },
+    catch: (error) => ProviderShared.invalidRequest(`Bedrock Converse SigV4 signing failed: ${error instanceof Error ? error.message : String(error)}`),
+});
+/** Sign the exact JSON bytes with SigV4 using credentials configured on the route. */
+export const sigV4 = (credentials) => Auth.custom((input) => {
+    return Effect.gen(function* () {
+        if (!credentials) {
+            return yield* ProviderShared.invalidRequest("Bedrock Converse requires either route bearer auth or AWS credentials configured on the route");
+        }
+        const headersForSigning = Headers.set(input.headers, "content-type", "application/json");
+        const signed = yield* signRequest({
+            url: input.url,
+            body: input.body,
+            headers: headersForSigning,
+            credentials,
+        });
+        return Headers.setAll(headersForSigning, signed);
+    });
+});
+/** Bedrock route auth defaults to SigV4 and expects credentials from route configuration. */
+export const auth = sigV4(undefined);
+export * as BedrockAuth from "./bedrock-auth";

package/dist/protocols/utils/bedrock-cache.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+import type { CacheHint } from "../../schema";
+import { type Breakpoints } from "./cache";
+export declare const CachePointBlock: Schema.Struct<{
+    readonly cachePoint: Schema.Struct<{
+        readonly type: Schema.tag<"default">;
+        readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
+    }>;
+}>;
+export type CachePointBlock = Schema.Schema.Type<typeof CachePointBlock>;
+export declare const BEDROCK_BREAKPOINT_CAP = 4;
+export type { Breakpoints } from "./cache";
+export declare const breakpoints: () => Breakpoints;
+export declare const block: (breakpoints: Breakpoints, cache: CacheHint | undefined) => CachePointBlock | undefined;
+export * as BedrockCache from "./bedrock-cache";

package/dist/protocols/utils/bedrock-cache.js

@@ -0,0 +1,29 @@
+import { Schema } from "effect";
+import { newBreakpoints, ttlBucket } from "./cache";
+// Bedrock cache markers are positional: emit a `cachePoint` block immediately
+// after the content the caller wants treated as a cacheable prefix. Bedrock
+// accepts optional `ttl: "5m" | "1h"` on cachePoint, mirroring Anthropic.
+export const CachePointBlock = Schema.Struct({
+    cachePoint: Schema.Struct({
+        type: Schema.tag("default"),
+        ttl: Schema.optional(Schema.Literals(["5m", "1h"])),
+    }),
+});
+// Bedrock-Claude enforces the same 4-breakpoint cap as the Anthropic Messages
+// API. Callers pass a shared counter through every `block()` call site so the
+// budget is respected across `system`, `messages`, and `tools`.
+export const BEDROCK_BREAKPOINT_CAP = 4;
+export const breakpoints = () => newBreakpoints(BEDROCK_BREAKPOINT_CAP);
+const DEFAULT_5M = { cachePoint: { type: "default" } };
+const DEFAULT_1H = { cachePoint: { type: "default", ttl: "1h" } };
+export const block = (breakpoints, cache) => {
+    if (cache?.type !== "ephemeral" && cache?.type !== "persistent")
+        return undefined;
+    if (breakpoints.remaining <= 0) {
+        breakpoints.dropped += 1;
+        return undefined;
+    }
+    breakpoints.remaining -= 1;
+    return ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M;
+};
+export * as BedrockCache from "./bedrock-cache";

package/dist/protocols/utils/bedrock-media.d.ts

@@ -0,0 +1,49 @@
+import { Effect, Schema } from "effect";
+export declare const ImageFormat: Schema.Literals<readonly ["png", "jpeg", "gif", "webp"]>;
+export type ImageFormat = Schema.Schema.Type<typeof ImageFormat>;
+export declare const ImageBlock: Schema.Struct<{
+    readonly image: Schema.Struct<{
+        readonly format: Schema.Literals<readonly ["png", "jpeg", "gif", "webp"]>;
+        readonly source: Schema.Struct<{
+            readonly bytes: Schema.String;
+        }>;
+    }>;
+}>;
+export type ImageBlock = Schema.Schema.Type<typeof ImageBlock>;
+export declare const DocumentFormat: Schema.Literals<readonly ["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"]>;
+export type DocumentFormat = Schema.Schema.Type<typeof DocumentFormat>;
+export declare const DocumentBlock: Schema.Struct<{
+    readonly document: Schema.Struct<{
+        readonly format: Schema.Literals<readonly ["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"]>;
+        readonly name: Schema.String;
+        readonly source: Schema.Struct<{
+            readonly bytes: Schema.String;
+        }>;
+    }>;
+}>;
+export type DocumentBlock = Schema.Schema.Type<typeof DocumentBlock>;
+export declare const lower: (part: {
+    readonly type: "media";
+    readonly mediaType: string;
+    readonly data: string | Uint8Array<ArrayBufferLike>;
+    readonly filename?: string | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+}) => Effect.Effect<{
+    readonly document: {
+        readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+        readonly name: string;
+        readonly source: {
+            readonly bytes: string;
+        };
+    };
+} | {
+    image: {
+        format: "png" | "jpeg" | "gif" | "webp";
+        source: {
+            bytes: string;
+        };
+    };
+}, import("../..").LLMError, never>;
+export * as BedrockMedia from "./bedrock-media";

package/dist/protocols/utils/bedrock-media.js

@@ -0,0 +1,68 @@
+import { Effect, Schema } from "effect";
+import { ProviderShared } from "../shared";
+// Bedrock Converse accepts image `format` as the file extension and
+// `source.bytes` as base64 in the JSON wire format.
+export const ImageFormat = Schema.Literals(["png", "jpeg", "gif", "webp"]);
+export const ImageBlock = Schema.Struct({
+    image: Schema.Struct({
+        format: ImageFormat,
+        source: Schema.Struct({ bytes: Schema.String }),
+    }),
+});
+// Bedrock document blocks require a user-facing name so the model can refer to
+// the uploaded document.
+export const DocumentFormat = Schema.Literals(["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"]);
+export const DocumentBlock = Schema.Struct({
+    document: Schema.Struct({
+        format: DocumentFormat,
+        name: Schema.String,
+        source: Schema.Struct({ bytes: Schema.String }),
+    }),
+});
+const IMAGE_FORMATS = {
+    "image/png": "png",
+    "image/jpeg": "jpeg",
+    "image/jpg": "jpeg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+};
+const DOCUMENT_FORMATS = {
+    "application/pdf": "pdf",
+    "text/csv": "csv",
+    "application/msword": "doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+    "application/vnd.ms-excel": "xls",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+    "text/html": "html",
+    "text/plain": "txt",
+    "text/markdown": "md",
+};
+const documentBlock = (part, format, bytes) => ({
+    document: {
+        format,
+        name: part.filename ?? `document.${format}`,
+        source: { bytes },
+    },
+});
+// Route by MIME. Known image/document formats lower into a typed block; anything
+// else fails with a clear error instead of silently degrading to a malformed
+// document block. Image MIME types not in `IMAGE_FORMATS` (e.g. `image/svg+xml`)
+// get an image-specific error so the caller knows it's a format-support issue,
+// not a kind-detection issue.
+export const lower = Effect.fn("BedrockMedia.lower")(function* (part) {
+    const mime = part.mediaType.toLowerCase();
+    const imageFormat = IMAGE_FORMATS[mime];
+    if (imageFormat) {
+        const media = yield* ProviderShared.validateMedia("Bedrock Converse", part, new Set(Object.keys(IMAGE_FORMATS)));
+        return { image: { format: imageFormat, source: { bytes: media.base64 } } };
+    }
+    if (mime.startsWith("image/"))
+        return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.mediaType}`);
+    const documentFormat = DOCUMENT_FORMATS[mime];
+    if (documentFormat) {
+        const media = yield* ProviderShared.validateMedia("Bedrock Converse", part, new Set(Object.keys(DOCUMENT_FORMATS)));
+        return documentBlock(part, documentFormat, media.base64);
+    }
+    return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`);
+});
+export * as BedrockMedia from "./bedrock-media";

package/dist/protocols/utils/cache.d.ts

@@ -0,0 +1,6 @@
+export interface Breakpoints {
+    remaining: number;
+    dropped: number;
+}
+export declare const newBreakpoints: (cap: number) => Breakpoints;
+export declare const ttlBucket: (ttlSeconds: number | undefined) => "1h" | undefined;