@opencode-ai/ai 0.0.0-beta-17492

package/dist/protocols/openai-responses.js

@@ -0,0 +1,208 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Headers } from "effect/unstable/http";
+import { Route } from "../route/client.js";
+import { Auth } from "../route/auth.js";
+import { Endpoint } from "../route/endpoint.js";
+import { Protocol } from "../route/protocol.js";
+import { HttpTransport } from "../route/transport/index.js";
+import { LLMEvent, LLMRequest } from "../schema/index.js";
+import { OpenResponses } from "./open-responses.js";
+import { optionalArray, ProviderShared } from "./shared.js";
+import { Lifecycle } from "./utils/lifecycle.js";
+import { OpenAIImage } from "./utils/openai-image.js";
+import { ToolSchemaProjection } from "./utils/tool-schema.js";
+import { OpenResponsesChannel } from "./open-responses-channel.js";
+import { OpenAIResponsesChannel } from "./openai-responses-channel.js";
+const ADAPTER = "openai-responses";
+const NAME = "OpenAI Responses";
+const WEBSOCKET_PROTOCOL_HEADER = "responses_websockets=2026-02-06";
+const WEBSOCKET_ROTATE_AFTER_MS = 55 * 60 * 1000;
+export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export const PATH = OpenResponses.PATH;
+const OpenAIResponsesImageGenerationTool = Schema.Struct({
+    type: Schema.tag("image_generation"),
+    action: Schema.optional(Schema.Literals(["auto", "generate", "edit"])),
+    background: Schema.optional(Schema.Literals(["auto", "opaque", "transparent"])),
+    input_fidelity: Schema.optional(Schema.Literals(["low", "high"])),
+    output_compression: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 }))),
+    output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
+    partial_images: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+    quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
+    size: Schema.optional(OpenAIImage.Size),
+});
+const OpenAIResponsesTools = Schema.Union([OpenResponses.Tool, OpenAIResponsesImageGenerationTool]);
+const OpenAIResponsesToolChoice = Schema.Union([
+    OpenResponses.ToolChoice,
+    Schema.Struct({ type: Schema.tag("image_generation") }),
+]);
+const OpenAIResponsesInputItem = Schema.Union([
+    Schema.Struct({
+        role: Schema.tag("assistant"),
+        content: Schema.Array(Schema.Struct({ type: Schema.tag("output_text"), text: Schema.String })),
+        phase: Schema.optionalKey(Schema.NullOr(OpenResponses.MessagePhase)),
+    }),
+    OpenResponses.InputItem,
+]);
+const OpenAIResponsesCoreFields = {
+    ...OpenResponses.coreFields,
+    input: Schema.Array(OpenAIResponsesInputItem),
+    tools: optionalArray(OpenAIResponsesTools),
+    tool_choice: Schema.optional(OpenAIResponsesToolChoice),
+};
+const OpenAIResponsesBody = Schema.Struct({
+    ...OpenAIResponsesCoreFields,
+    stream: Schema.Literal(true),
+});
+const extension = {
+    id: ADAPTER,
+    name: NAME,
+    messagePhase: (value) => (value === null ? null : undefined),
+    lowerMedia: ({ part, media, request }) => {
+        if (request.model.provider !== "xai" || media.mime !== "application/pdf")
+            return undefined;
+        return {
+            type: "input_file",
+            filename: part.filename ?? "document.pdf",
+            file_data: media.base64,
+            mime_type: media.mime,
+        };
+    },
+};
+const nativeImageToolInput = (tool) => {
+    const native = tool.native?.openai;
+    return ProviderShared.isRecord(native) && native.type === "image_generation" ? native : undefined;
+};
+const nativeImageTool = (tool) => {
+    const native = nativeImageToolInput(tool);
+    return Schema.is(OpenAIResponsesImageGenerationTool)(native) ? native : undefined;
+};
+const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool, inputSchema) {
+    const native = nativeImageToolInput(tool);
+    if (native !== undefined) {
+        if (Schema.is(OpenAIResponsesImageGenerationTool)(native))
+            return native;
+        return yield* ProviderShared.invalidRequest("OpenAI Responses image generation tool options are invalid");
+    }
+    return yield* OpenResponses.lowerTool(NAME, tool, inputSchema);
+});
+const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice(NAME, toolChoice, {
+    auto: () => "auto",
+    none: () => "none",
+    required: () => "required",
+    tool: (name) => tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined)
+        ? { type: "image_generation" }
+        : { type: "function", name },
+});
+const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request) {
+    const body = yield* OpenResponses.fromRequestWithExtension(LLMRequest.update(request, { tools: [], toolChoice: undefined }), extension);
+    const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
+    return {
+        ...body,
+        tools: request.tools.length === 0
+            ? undefined
+            : yield* Effect.forEach(request.tools, (tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
+        tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined,
+    };
+});
+const HOSTED_TOOLS = {
+    web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
+    web_search_preview_call: { name: "web_search_preview", input: (item) => item.action ?? {} },
+    file_search_call: { name: "file_search", input: (item) => ({ queries: item.queries ?? [] }) },
+    code_interpreter_call: {
+        name: "code_interpreter",
+        input: (item) => ({ code: item.code, container_id: item.container_id }),
+    },
+    computer_use_call: { name: "computer_use", input: (item) => item.action ?? {} },
+    image_generation_call: { name: "image_generation", input: () => ({}) },
+    mcp_call: {
+        name: "mcp",
+        input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
+    },
+    local_shell_call: { name: "local_shell", input: (item) => item.action ?? {} },
+};
+const isHostedToolItem = (item) => item.type in HOSTED_TOOLS && typeof item.id === "string" && item.id.length > 0;
+const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item) {
+    const isError = item.error !== undefined && item.error !== null;
+    if (item.type === "image_generation_call" && item.result) {
+        yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")));
+        const format = item.output_format ?? "png";
+        return {
+            type: "content",
+            value: [
+                {
+                    type: "file",
+                    uri: `data:image/${format};base64,${item.result}`,
+                    mime: `image/${format}`,
+                },
+            ],
+        };
+    }
+    return isError ? { type: "error", value: item.error } : { type: "json", value: item };
+});
+const onHostedToolDone = Effect.fn("OpenAIResponses.onHostedToolDone")(function* (state, item) {
+    const tool = HOSTED_TOOLS[item.type];
+    const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id });
+    const events = [];
+    const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
+    events.push(LLMEvent.toolCall({
+        id: item.id,
+        name: tool.name,
+        input: tool.input(item),
+        providerExecuted: true,
+        providerMetadata,
+    }), LLMEvent.toolResult({
+        id: item.id,
+        name: tool.name,
+        result: yield* hostedToolResult(item),
+        providerExecuted: true,
+        providerMetadata,
+    }));
+    return [{ ...state, lifecycle }, events];
+});
+const step = (state, event) => {
+    if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
+        return event.item_id
+            ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
+            : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
+    if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
+        return event.item_id
+            ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
+            : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
+    if (event.type === "response.output_item.done" && event.item && isHostedToolItem(event.item))
+        return onHostedToolDone(state, event.item);
+    return OpenResponses.step(state, event);
+};
+export const protocol = Protocol.make({
+    id: ADAPTER,
+    body: {
+        schema: OpenAIResponsesBody,
+        from: fromRequest,
+    },
+    stream: {
+        event: OpenResponses.protocol.stream.event,
+        initial: (request) => OpenResponses.initial(request, extension),
+        step,
+        terminal: OpenResponses.terminal,
+    },
+});
+const endpoint = Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL });
+const auth = Auth.none;
+export const httpTransport = HttpTransport.sseJson.with();
+export const transport = OpenResponsesChannel.transport({
+    id: ADAPTER,
+    name: NAME,
+    rotateAfterMs: WEBSOCKET_ROTATE_AFTER_MS,
+    headers: (headers) => Headers.set(headers, "openai-beta", headers["openai-beta"] ?? WEBSOCKET_PROTOCOL_HEADER),
+    driver: (input) => OpenAIResponsesChannel.driver({ id: ADAPTER, name: NAME, ...input }),
+});
+export const route = Route.make({
+    id: ADAPTER,
+    provider: "openai",
+    providerMetadataKey: "openai",
+    protocol,
+    endpoint,
+    auth,
+    transport,
+    defaults: { providerOptions: { openai: { store: false } } },
+});
+export * as OpenAIResponses from "./openai-responses.js";

package/dist/protocols/shared.d.ts

@@ -0,0 +1,194 @@
+import { Buffer } from "node:buffer";
+import { Tool } from "@opencode-ai/schema/tool";
+import { Effect, Schema, Stream } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { AIError, type ContentPart, type LLMRequest, type ToolResultPart } from "../schema/index.js";
+import { isRecord } from "../utils/record.js";
+export { isRecord };
+export declare const Json: Schema.fromJsonString<Schema.Unknown>;
+export declare const decodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => unknown;
+export declare const encodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string;
+export 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 `AI.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) => AIError;
+export declare const parseJson: (route: string, input: string, message: string) => Effect.Effect<unknown, AIError, 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("../schema/messages.js").Message) => Effect.Effect<{
+    readonly type: "text";
+    readonly text: string;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly cache?: import("../schema/options.js").CacheHint | undefined;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+}[], AIError, never>;
+/** Lower an unsupported privileged update into visible, in-order user text. */
+export declare const wrappedSystemUpdate: (route: string, message: import("../schema/messages.js").Message) => Effect.Effect<{
+    type: "text";
+    text: string;
+    cache: import("../schema/options.js").CacheHint | undefined;
+}, AIError, 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, AIError, 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 PDF_MIMES: readonly ["application/pdf"];
+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", "application/pdf"];
+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 data: string | Uint8Array<ArrayBufferLike>;
+    readonly type: "media";
+    readonly mediaType: string;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly filename?: string | undefined;
+}, supportedMimes: ReadonlySet<string>) => Effect.Effect<{
+    mime: string;
+    base64: string;
+    dataUrl: string;
+    bytes: Buffer<ArrayBuffer>;
+}, AIError, never>;
+export declare const validateToolFile: (route: string, part: Tool.FileContent, supportedMimes: ReadonlySet<string>) => Effect.Effect<{
+    mime: string;
+    base64: string;
+    dataUrl: string;
+    bytes: Buffer<ArrayBuffer>;
+}, AIError, 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
+ * `AIError`.
+ */
+export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>) => Stream.Stream<string, AIError>;
+/**
+ * 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) => AIError;
+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, AIError, 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>) => AIError;
+/**
+ * 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
+ * `AIError` 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, AIError, 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.js";

package/dist/protocols/shared.js

@@ -0,0 +1,238 @@
+import { Buffer } from "node:buffer";
+import { Tool } from "@opencode-ai/schema/tool";
+import { Effect, Schema, Stream } from "effect";
+import * as Sse from "effect/unstable/encoding/Sse";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { InvalidProviderOutputReason, InvalidRequestReason, AIError, } from "../schema/index.js";
+import { isRecord } from "../utils/record.js";
+export { isRecord };
+export const Json = Schema.fromJsonString(Schema.Unknown);
+export const decodeJson = Schema.decodeUnknownSync(Json);
+export const encodeJson = Schema.encodeSync(Json);
+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 `AI.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 AIError({
+    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 PDF_MIMES = ["application/pdf"];
+export const MEDIA_MIMES = [...IMAGE_MIMES, ...VIDEO_MIMES, ...AUDIO_MIMES, ...PDF_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
+ * `AIError`.
+ */
+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 AIError({
+    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
+ * `AIError` 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.js";

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

@@ -0,0 +1,21 @@
+import { Auth } from "../../route/auth.js";
+/**
+ * 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, options?: {
+    readonly service?: string;
+    readonly name?: string;
+}) => 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.js";