@slopus/rig 0.0.1

package/dist/providers/codex.d.ts

@@ -0,0 +1,12 @@
+import { type SimpleStreamOptions } from "@mariozechner/pi-ai";
+import { type Provider } from "./types.js";
+export interface CodexProviderOptions {
+    apiKey?: string;
+    resolveApiKey?: () => string | undefined;
+    useLocalCodexAuth?: boolean;
+    codexAuthPath?: string;
+    transport?: SimpleStreamOptions["transport"];
+}
+export declare function createCodexProvider(options?: CodexProviderOptions): Provider;
+export type CodexProvider = ReturnType<typeof createCodexProvider>;
+//# sourceMappingURL=codex.d.ts.map

package/dist/providers/codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../sources/providers/codex.ts"],"names":[],"mappings":"AAIA,OAAO,EAKH,KAAK,mBAAmB,EAC3B,MAAM,qBAAqB,CAAC;AAQ7B,OAAO,EAAkB,KAAK,QAAQ,EAAsB,MAAM,YAAY,CAAC;AAQ/E,MAAM,WAAW,oBAAoB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACzC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;CAChD;AAED,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,oBAAyB,GAAG,QAAQ,CA6BhF;AAiED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/providers/codex.js

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { clampThinkingLevel, getModels, } from "@mariozechner/pi-ai";
+import { streamSimpleOpenAICodexResponses } from "@mariozechner/pi-ai/openai-codex-responses";
+import { applyCodexImageDetailsToPayload } from "./applyCodexImageDetailsToPayload.js";
+import { classifyCodexErrorCode } from "./classifyCodexErrorCode.js";
+import { collectImageDetails } from "./collectImageDetails.js";
+import { modelOpenaiGpt54, modelOpenaiGpt55 } from "./models.js";
+import { toPiContext, wrapPiStream } from "./pi-bridge.js";
+import { defineProvider } from "./types.js";
+const CODEX_PROVIDER_ID = "openai-codex";
+function toPiCodexModelId(id) {
+    return id.startsWith("openai/") ? id.slice("openai/".length) : id;
+}
+export function createCodexProvider(options = {}) {
+    const piModelById = new Map(getModels(CODEX_PROVIDER_ID).map((model) => [model.id, model]));
+    const resolveApiKey = buildApiKeyResolver(options);
+    return defineProvider({
+        id: "codex",
+        models: [modelOpenaiGpt55, modelOpenaiGpt54],
+        stream(model, context, streamOptions) {
+            const piModel = piModelById.get(toPiCodexModelId(model.id));
+            if (!piModel) {
+                throw new Error(`Unknown codex model: ${model.id}`);
+            }
+            return wrapPiStream(streamSimpleOpenAICodexResponses(piModel, toPiContext(context), toPiStreamOptions(piModel, streamOptions, resolveApiKey(), options.transport, collectImageDetails(context))), { classifyError: classifyCodexErrorCode });
+        },
+    });
+}
+function buildApiKeyResolver(options) {
+    if (options.apiKey) {
+        return () => options.apiKey;
+    }
+    if (options.resolveApiKey) {
+        return options.resolveApiKey;
+    }
+    if (options.useLocalCodexAuth === false) {
+        return () => undefined;
+    }
+    return () => readLocalCodexAccessToken(options.codexAuthPath);
+}
+function readLocalCodexAccessToken(authPath) {
+    const file = authPath ?? path.join(homedir(), ".codex", "auth.json");
+    if (!existsSync(file)) {
+        return undefined;
+    }
+    try {
+        const data = JSON.parse(readFileSync(file, "utf8"));
+        const token = data.tokens?.access_token;
+        return typeof token === "string" && token.length > 0 ? token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function toPiStreamOptions(piModel, options, apiKey, transport, imageDetails) {
+    const piOptions = {
+        ...(options?.signal !== undefined ? { signal: options.signal } : {}),
+        ...(options?.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
+        ...(apiKey !== undefined ? { apiKey } : {}),
+        ...(transport !== undefined ? { transport } : {}),
+        ...(imageDetails.includes("original")
+            ? {
+                onPayload: (payload) => applyCodexImageDetailsToPayload(payload, imageDetails),
+            }
+            : {}),
+    };
+    if (options?.thinking !== undefined && options.thinking !== "off") {
+        const level = clampThinkingLevel(piModel, options.thinking);
+        if (level !== "off") {
+            piOptions.reasoning = level;
+        }
+    }
+    return piOptions;
+}

package/dist/providers/collectImageDetails.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "./types.js";
+export declare function collectImageDetails(context: Context): Array<"high" | "original">;
+//# sourceMappingURL=collectImageDetails.d.ts.map

package/dist/providers/collectImageDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectImageDetails.d.ts","sourceRoot":"","sources":["../../sources/providers/collectImageDetails.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC,CAahF"}

package/dist/providers/collectImageDetails.js

@@ -0,0 +1,14 @@
+export function collectImageDetails(context) {
+    const details = [];
+    for (const message of context.messages) {
+        if (message.role === "assistant" || typeof message.content === "string") {
+            continue;
+        }
+        for (const content of message.content) {
+            if (content.type === "image") {
+                details.push(content.detail ?? "high");
+            }
+        }
+    }
+    return details;
+}

package/dist/providers/createBedrockMantleStream.d.ts

@@ -0,0 +1,13 @@
+import type { BedrockModelRoute } from "./bedrock-model-routes.js";
+import { type BedrockOpenAIClient } from "./createBedrockOpenAIClient.js";
+import { createInferenceStream } from "./createInferenceStream.js";
+import type { Context, StreamOptions } from "./types.js";
+export declare function createBedrockMantleStream(options: {
+    bearerToken: string;
+    client?: BedrockOpenAIClient;
+    context: Context;
+    modelRoute: BedrockModelRoute;
+    region: string;
+    streamOptions?: StreamOptions;
+}): ReturnType<typeof createInferenceStream>;
+//# sourceMappingURL=createBedrockMantleStream.d.ts.map

package/dist/providers/createBedrockMantleStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBedrockMantleStream.d.ts","sourceRoot":"","sources":["../../sources/providers/createBedrockMantleStream.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAEH,KAAK,mBAAmB,EAC3B,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAKnE,OAAO,KAAK,EAGR,OAAO,EAEP,aAAa,EAChB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,aAAa,CAAC;CACjC,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAkS3C"}

package/dist/providers/createBedrockMantleStream.js

@@ -0,0 +1,234 @@
+import { applyBedrockOpenAIResponse } from "./applyBedrockOpenAIResponse.js";
+import { createBedrockOpenAIClient, } from "./createBedrockOpenAIClient.js";
+import { createBedrockOpenAIRequest } from "./createBedrockOpenAIRequest.js";
+import { createInferenceStream } from "./createInferenceStream.js";
+import { finishBedrockOpenAIOutputItem } from "./finishBedrockOpenAIOutputItem.js";
+import { parseOpenAIToolArguments } from "./parseOpenAIToolArguments.js";
+import { replaceAssistantContent } from "./replaceAssistantContent.js";
+import { toBedrockAssistantContent } from "./toBedrockAssistantContent.js";
+export function createBedrockMantleStream(options) {
+    const client = options.client ??
+        createBedrockOpenAIClient({
+            bearerToken: options.bearerToken,
+            region: options.region,
+        });
+    const run = async function* () {
+        const partial = {
+            role: "assistant",
+            content: [],
+            api: "openai-responses",
+            provider: "bedrock",
+            model: options.modelRoute.model.id,
+            usage: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                totalTokens: 0,
+                cost: {
+                    input: 0,
+                    output: 0,
+                    cacheRead: 0,
+                    cacheWrite: 0,
+                    total: 0,
+                },
+            },
+            stopReason: "stop",
+            timestamp: Date.now(),
+        };
+        const activeItems = new Map();
+        yield { type: "start", partial };
+        try {
+            const responseStream = await client.responses.create(createBedrockOpenAIRequest({
+                context: options.context,
+                modelRoute: options.modelRoute,
+                ...(options.streamOptions !== undefined
+                    ? { streamOptions: options.streamOptions }
+                    : {}),
+            }), ...(options.streamOptions?.signal !== undefined
+                ? [{ signal: options.streamOptions.signal }]
+                : []));
+            for await (const event of responseStream) {
+                if (event.type === "response.created") {
+                    partial.responseId = event.response.id;
+                    partial.responseModel = event.response.model;
+                    continue;
+                }
+                if (event.type === "response.output_item.added") {
+                    const contentIndex = partial.content.length;
+                    const content = toBedrockAssistantContent(event.item);
+                    if (content === undefined) {
+                        continue;
+                    }
+                    partial.content = [...partial.content, content];
+                    const activeItem = {
+                        contentIndex,
+                        type: event.item.type === "reasoning"
+                            ? "reasoning"
+                            : event.item.type === "message"
+                                ? "message"
+                                : "toolCall",
+                        ...(event.item.type === "function_call"
+                            ? { argumentsJson: event.item.arguments }
+                            : {}),
+                    };
+                    activeItems.set(event.output_index, activeItem);
+                    if (content.type === "thinking") {
+                        yield { type: "thinking_start", contentIndex, partial };
+                    }
+                    else if (content.type === "text") {
+                        yield { type: "text_start", contentIndex, partial };
+                    }
+                    else {
+                        yield { type: "toolcall_start", contentIndex, partial };
+                    }
+                    continue;
+                }
+                if (event.type === "response.reasoning_summary_text.delta" ||
+                    event.type === "response.reasoning_text.delta") {
+                    const activeItem = activeItems.get(event.output_index);
+                    const content = activeItem === undefined
+                        ? undefined
+                        : partial.content[activeItem.contentIndex];
+                    if (activeItem?.type !== "reasoning" || content?.type !== "thinking") {
+                        continue;
+                    }
+                    partial.content = replaceAssistantContent(partial.content, activeItem.contentIndex, {
+                        ...content,
+                        thinking: content.thinking + event.delta,
+                    });
+                    yield {
+                        type: "thinking_delta",
+                        contentIndex: activeItem.contentIndex,
+                        delta: event.delta,
+                        partial,
+                    };
+                    continue;
+                }
+                if (event.type === "response.reasoning_summary_part.done") {
+                    const activeItem = activeItems.get(event.output_index);
+                    const content = activeItem === undefined
+                        ? undefined
+                        : partial.content[activeItem.contentIndex];
+                    if (activeItem?.type !== "reasoning" || content?.type !== "thinking") {
+                        continue;
+                    }
+                    partial.content = replaceAssistantContent(partial.content, activeItem.contentIndex, {
+                        ...content,
+                        thinking: `${content.thinking}\n\n`,
+                    });
+                    yield {
+                        type: "thinking_delta",
+                        contentIndex: activeItem.contentIndex,
+                        delta: "\n\n",
+                        partial,
+                    };
+                    continue;
+                }
+                if (event.type === "response.output_text.delta" ||
+                    event.type === "response.refusal.delta") {
+                    const activeItem = activeItems.get(event.output_index);
+                    const content = activeItem === undefined
+                        ? undefined
+                        : partial.content[activeItem.contentIndex];
+                    if (activeItem?.type !== "message" || content?.type !== "text") {
+                        continue;
+                    }
+                    partial.content = replaceAssistantContent(partial.content, activeItem.contentIndex, {
+                        ...content,
+                        text: content.text + event.delta,
+                    });
+                    yield {
+                        type: "text_delta",
+                        contentIndex: activeItem.contentIndex,
+                        delta: event.delta,
+                        partial,
+                    };
+                    continue;
+                }
+                if (event.type === "response.function_call_arguments.delta") {
+                    const activeItem = activeItems.get(event.output_index);
+                    const content = activeItem === undefined
+                        ? undefined
+                        : partial.content[activeItem.contentIndex];
+                    if (activeItem?.type !== "toolCall" || content?.type !== "toolCall") {
+                        continue;
+                    }
+                    activeItem.argumentsJson = (activeItem.argumentsJson ?? "") + event.delta;
+                    partial.content = replaceAssistantContent(partial.content, activeItem.contentIndex, {
+                        ...content,
+                        arguments: parseOpenAIToolArguments(activeItem.argumentsJson),
+                    });
+                    yield {
+                        type: "toolcall_delta",
+                        contentIndex: activeItem.contentIndex,
+                        delta: event.delta,
+                        partial,
+                    };
+                    continue;
+                }
+                if (event.type === "response.function_call_arguments.done") {
+                    const activeItem = activeItems.get(event.output_index);
+                    const content = activeItem === undefined
+                        ? undefined
+                        : partial.content[activeItem.contentIndex];
+                    if (activeItem?.type !== "toolCall" || content?.type !== "toolCall") {
+                        continue;
+                    }
+                    activeItem.argumentsJson = event.arguments;
+                    partial.content = replaceAssistantContent(partial.content, activeItem.contentIndex, {
+                        ...content,
+                        arguments: parseOpenAIToolArguments(event.arguments),
+                    });
+                    continue;
+                }
+                if (event.type === "response.output_item.done") {
+                    const activeItem = activeItems.get(event.output_index);
+                    if (activeItem === undefined) {
+                        continue;
+                    }
+                    const finishedEvent = finishBedrockOpenAIOutputItem(partial, activeItem, event.item);
+                    activeItems.delete(event.output_index);
+                    if (finishedEvent !== undefined) {
+                        yield finishedEvent;
+                    }
+                    continue;
+                }
+                if (event.type === "response.completed" || event.type === "response.incomplete") {
+                    applyBedrockOpenAIResponse(partial, event.response);
+                    yield {
+                        type: "done",
+                        reason: partial.stopReason,
+                        message: partial,
+                    };
+                    return partial;
+                }
+                if (event.type === "error") {
+                    throw new Error(event.code === null ? event.message : `${event.code}: ${event.message}`);
+                }
+                if (event.type === "response.failed") {
+                    throw new Error(event.response.error?.message ??
+                        event.response.incomplete_details?.reason ??
+                        "Amazon Bedrock failed to generate a response.");
+                }
+            }
+            partial.stopReason = partial.content.some((content) => content.type === "toolCall")
+                ? "toolUse"
+                : "stop";
+            yield { type: "done", reason: partial.stopReason, message: partial };
+            return partial;
+        }
+        catch (error) {
+            const aborted = options.streamOptions?.signal?.aborted === true;
+            partial.stopReason = aborted ? "aborted" : "error";
+            partial.errorMessage = error instanceof Error ? error.message : String(error);
+            yield {
+                type: "error",
+                reason: partial.stopReason,
+                error: partial,
+            };
+            return partial;
+        }
+    };
+    return createInferenceStream(run);
+}

package/dist/providers/createBedrockOpenAIClient.d.ts

@@ -0,0 +1,7 @@
+import { BedrockOpenAI } from "openai";
+export type BedrockOpenAIClient = Pick<BedrockOpenAI, "responses">;
+export declare function createBedrockOpenAIClient(options: {
+    bearerToken: string;
+    region: string;
+}): BedrockOpenAI;
+//# sourceMappingURL=createBedrockOpenAIClient.d.ts.map

package/dist/providers/createBedrockOpenAIClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBedrockOpenAIClient.d.ts","sourceRoot":"","sources":["../../sources/providers/createBedrockOpenAIClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAEvC,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;AAEnE,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAClB,GAAG,aAAa,CAKhB"}

package/dist/providers/createBedrockOpenAIClient.js

@@ -0,0 +1,7 @@
+import { BedrockOpenAI } from "openai";
+export function createBedrockOpenAIClient(options) {
+    return new BedrockOpenAI({
+        apiKey: options.bearerToken,
+        awsRegion: options.region,
+    });
+}

package/dist/providers/createBedrockOpenAIRequest.d.ts

@@ -0,0 +1,9 @@
+import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+import type { BedrockModelRoute } from "./bedrock-model-routes.js";
+import type { Context, StreamOptions } from "./types.js";
+export declare function createBedrockOpenAIRequest(options: {
+    context: Context;
+    modelRoute: BedrockModelRoute;
+    streamOptions?: StreamOptions;
+}): ResponseCreateParamsStreaming;
+//# sourceMappingURL=createBedrockOpenAIRequest.d.ts.map

package/dist/providers/createBedrockOpenAIRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBedrockOpenAIRequest.d.ts","sourceRoot":"","sources":["../../sources/providers/createBedrockOpenAIRequest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAE7F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAInE,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEzD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE;IAChD,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,CAAC,EAAE,aAAa,CAAC;CACjC,GAAG,6BAA6B,CA2BhC"}

package/dist/providers/createBedrockOpenAIRequest.js

@@ -0,0 +1,30 @@
+import { toOpenAIResponseInput } from "./toOpenAIResponseInput.js";
+import { toOpenAIResponseTools } from "./toOpenAIResponseTools.js";
+import { toOpenAIReasoningEffort } from "./toOpenAIReasoningEffort.js";
+export function createBedrockOpenAIRequest(options) {
+    const effort = options.streamOptions?.thinking ?? options.modelRoute.model.defaultThinkingLevel;
+    const reasoningEffort = toOpenAIReasoningEffort(effort);
+    const tools = options.context.tools ?? [];
+    return {
+        model: options.modelRoute.mantleApiModelId ?? options.modelRoute.apiModelId,
+        input: toOpenAIResponseInput(options.context),
+        stream: true,
+        store: false,
+        max_output_tokens: options.modelRoute.maxTokens,
+        ...(options.context.systemPrompt !== undefined
+            ? { instructions: options.context.systemPrompt }
+            : {}),
+        ...(tools.length > 0 ? { tools: toOpenAIResponseTools(tools) } : {}),
+        ...(reasoningEffort !== undefined
+            ? {
+                reasoning: {
+                    effort: reasoningEffort,
+                    ...(reasoningEffort === "none" ? {} : { summary: "auto" }),
+                },
+                ...(reasoningEffort === "none"
+                    ? {}
+                    : { include: ["reasoning.encrypted_content"] }),
+            }
+            : {}),
+    };
+}

package/dist/providers/createBedrockRuntimeStream.d.ts

@@ -0,0 +1,14 @@
+import { type AssistantMessageEventStream } from "@mariozechner/pi-ai";
+import { bedrockProviderModule } from "@mariozechner/pi-ai/bedrock-provider";
+import type { BedrockModelRoute } from "./bedrock-model-routes.js";
+import type { Context, StreamOptions } from "./types.js";
+export type PiBedrockRuntimeStream = typeof bedrockProviderModule.streamBedrock;
+export declare function createBedrockRuntimeStream(options: {
+    bearerToken: string;
+    context: Context;
+    modelRoute: BedrockModelRoute;
+    region: string;
+    stream?: PiBedrockRuntimeStream;
+    streamOptions?: StreamOptions;
+}): AssistantMessageEventStream;
+//# sourceMappingURL=createBedrockRuntimeStream.d.ts.map

package/dist/providers/createBedrockRuntimeStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBedrockRuntimeStream.d.ts","sourceRoot":"","sources":["../../sources/providers/createBedrockRuntimeStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,2BAA2B,EAAuB,MAAM,qBAAqB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAE7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAOnE,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEzD,MAAM,MAAM,sBAAsB,GAAG,OAAO,qBAAqB,CAAC,aAAa,CAAC;AAEhF,wBAAgB,0BAA0B,CAAC,OAAO,EAAE;IAChD,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,sBAAsB,CAAC;IAChC,aAAa,CAAC,EAAE,aAAa,CAAC;CACjC,GAAG,2BAA2B,CAsC9B"}

package/dist/providers/createBedrockRuntimeStream.js

@@ -0,0 +1,41 @@
+import {} from "@mariozechner/pi-ai";
+import { bedrockProviderModule } from "@mariozechner/pi-ai/bedrock-provider";
+import { applyBedrockAdaptiveThinking } from "./applyBedrockAdaptiveThinking.js";
+import { applyBedrockGlmThinking } from "./applyBedrockGlmThinking.js";
+import { applyBedrockKimiThinking } from "./applyBedrockKimiThinking.js";
+import { createPiBedrockRuntimeModel } from "./createPiBedrockRuntimeModel.js";
+import { toPiContext } from "./pi-bridge.js";
+import { toPiReasoningLevel } from "./toPiReasoningLevel.js";
+export function createBedrockRuntimeStream(options) {
+    const stream = options.stream ?? bedrockProviderModule.streamBedrock;
+    const model = createPiBedrockRuntimeModel(options.modelRoute, options.region);
+    const effort = options.streamOptions?.thinking ?? options.modelRoute.model.defaultThinkingLevel;
+    const streamOptions = {
+        bearerToken: options.bearerToken,
+        region: options.region,
+        maxTokens: Math.min(options.modelRoute.maxTokens, 32_000),
+        ...(options.streamOptions?.signal !== undefined
+            ? { signal: options.streamOptions.signal }
+            : {}),
+        ...(options.streamOptions?.sessionId !== undefined
+            ? { sessionId: options.streamOptions.sessionId }
+            : {}),
+    };
+    if (options.modelRoute.reasoningMode === "adaptive" && effort !== "off") {
+        streamOptions.onPayload = (payload) => applyBedrockAdaptiveThinking(payload, effort);
+    }
+    else if (options.modelRoute.reasoningMode === "kimi-toggle") {
+        streamOptions.onPayload = (payload) => applyBedrockKimiThinking(payload, effort);
+    }
+    else if (options.modelRoute.reasoningMode === "glm-effort" ||
+        options.modelRoute.reasoningMode === "glm-toggle") {
+        streamOptions.onPayload = (payload) => applyBedrockGlmThinking(payload, effort, options.modelRoute.reasoningMode === "glm-effort");
+    }
+    else {
+        const reasoning = toPiReasoningLevel(effort);
+        if (reasoning !== undefined) {
+            streamOptions.reasoning = reasoning;
+        }
+    }
+    return stream(model, toPiContext(options.context), streamOptions);
+}

package/dist/providers/createInferenceStream.d.ts

@@ -0,0 +1,3 @@
+import type { AssistantMessage, AssistantMessageEvent, InferenceStream } from "./types.js";
+export declare function createInferenceStream(run: () => AsyncGenerator<AssistantMessageEvent, AssistantMessage>): InferenceStream;
+//# sourceMappingURL=createInferenceStream.d.ts.map

package/dist/providers/createInferenceStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createInferenceStream.d.ts","sourceRoot":"","sources":["../../sources/providers/createInferenceStream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE3F,wBAAgB,qBAAqB,CACjC,GAAG,EAAE,MAAM,cAAc,CAAC,qBAAqB,EAAE,gBAAgB,CAAC,GACnE,eAAe,CA6CjB"}

package/dist/providers/createInferenceStream.js

@@ -0,0 +1,45 @@
+export function createInferenceStream(run) {
+    let resolveResult;
+    let rejectResult;
+    const resultPromise = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+    });
+    let started = false;
+    const drain = async () => {
+        try {
+            const generator = run();
+            let next = await generator.next();
+            while (!next.done) {
+                next = await generator.next();
+            }
+            resolveResult(next.value);
+        }
+        catch (error) {
+            rejectResult(error);
+        }
+    };
+    return {
+        async *[Symbol.asyncIterator]() {
+            if (started) {
+                throw new Error("Inference streams can only be consumed once.");
+            }
+            started = true;
+            try {
+                const result = yield* run();
+                resolveResult(result);
+            }
+            catch (error) {
+                rejectResult(error);
+                throw error;
+            }
+        },
+        result: async () => {
+            if (!started) {
+                started = true;
+                void drain();
+            }
+            return resultPromise;
+        },
+    };
+}

package/dist/providers/createPiBedrockRuntimeModel.d.ts

@@ -0,0 +1,4 @@
+import type { Model as PiModel } from "@mariozechner/pi-ai";
+import type { BedrockModelRoute } from "./bedrock-model-routes.js";
+export declare function createPiBedrockRuntimeModel(route: BedrockModelRoute, region: string): PiModel<"bedrock-converse-stream">;
+//# sourceMappingURL=createPiBedrockRuntimeModel.d.ts.map

package/dist/providers/createPiBedrockRuntimeModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPiBedrockRuntimeModel.d.ts","sourceRoot":"","sources":["../../sources/providers/createPiBedrockRuntimeModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,IAAI,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,wBAAgB,2BAA2B,CACvC,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,MAAM,GACf,OAAO,CAAC,yBAAyB,CAAC,CAkBpC"}

package/dist/providers/createPiBedrockRuntimeModel.js

@@ -0,0 +1,20 @@
+import { resolveBedrockRuntimeModelId } from "./resolveBedrockRuntimeModelId.js";
+export function createPiBedrockRuntimeModel(route, region) {
+    return {
+        id: resolveBedrockRuntimeModelId(route, region),
+        name: route.model.name,
+        api: "bedrock-converse-stream",
+        provider: "bedrock",
+        baseUrl: `https://bedrock-runtime.${region}.amazonaws.com`,
+        reasoning: route.reasoningMode !== "unsupported",
+        input: [...route.input],
+        cost: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+        },
+        contextWindow: route.contextWindow,
+        maxTokens: route.maxTokens,
+    };
+}

package/dist/providers/finishBedrockOpenAIOutputItem.d.ts

@@ -0,0 +1,5 @@
+import type { ResponseOutputItem } from "openai/resources/responses/responses.js";
+import type { ActiveBedrockOpenAIOutputItem } from "./bedrock-openai-types.js";
+import type { AssistantMessage, AssistantMessageEvent } from "./types.js";
+export declare function finishBedrockOpenAIOutputItem(partial: AssistantMessage, activeItem: ActiveBedrockOpenAIOutputItem, item: ResponseOutputItem): AssistantMessageEvent | undefined;
+//# sourceMappingURL=finishBedrockOpenAIOutputItem.d.ts.map

package/dist/providers/finishBedrockOpenAIOutputItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finishBedrockOpenAIOutputItem.d.ts","sourceRoot":"","sources":["../../sources/providers/finishBedrockOpenAIOutputItem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAElF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAC;AAG/E,OAAO,KAAK,EACR,gBAAgB,EAChB,qBAAqB,EAIxB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,6BAA6B,CACzC,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,6BAA6B,EACzC,IAAI,EAAE,kBAAkB,GACzB,qBAAqB,GAAG,SAAS,CAiEnC"}

package/dist/providers/finishBedrockOpenAIOutputItem.js

@@ -0,0 +1,53 @@
+import { parseOpenAIToolArguments } from "./parseOpenAIToolArguments.js";
+import { replaceAssistantContent } from "./replaceAssistantContent.js";
+export function finishBedrockOpenAIOutputItem(partial, activeItem, item) {
+    const content = partial.content[activeItem.contentIndex];
+    if (item.type === "reasoning" && content?.type === "thinking") {
+        const summary = item.summary.map((part) => part.text).join("\n\n");
+        const reasoning = item.content?.map((part) => part.text).join("\n\n") ?? "";
+        const finished = {
+            ...content,
+            thinking: summary || reasoning || content.thinking.trimEnd(),
+            encrypted: JSON.stringify(item),
+        };
+        partial.content = replaceAssistantContent(partial.content, activeItem.contentIndex, finished);
+        return {
+            type: "thinking_end",
+            contentIndex: activeItem.contentIndex,
+            content: finished.thinking,
+            partial,
+        };
+    }
+    if (item.type === "message" && content?.type === "text") {
+        const finished = {
+            ...content,
+            text: item.content
+                .map((part) => (part.type === "output_text" ? part.text : part.refusal))
+                .join(""),
+            textSignature: item.id,
+        };
+        partial.content = replaceAssistantContent(partial.content, activeItem.contentIndex, finished);
+        return {
+            type: "text_end",
+            contentIndex: activeItem.contentIndex,
+            content: finished.text,
+            partial,
+        };
+    }
+    if (item.type === "function_call" && content?.type === "toolCall") {
+        const finished = {
+            ...content,
+            id: item.id === undefined ? item.call_id : `${item.call_id}|${item.id}`,
+            name: item.name,
+            arguments: parseOpenAIToolArguments(item.arguments),
+        };
+        partial.content = replaceAssistantContent(partial.content, activeItem.contentIndex, finished);
+        return {
+            type: "toolcall_end",
+            contentIndex: activeItem.contentIndex,
+            toolCall: finished,
+            partial,
+        };
+    }
+    return undefined;
+}