@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/internal-providers/provider-bedrock/codec.js

@@ -0,0 +1,484 @@
+/**
+ * Bedrock Converse codec. Pure request/response translation between OpenAI
+ * Chat Completions JSON and Amazon Bedrock Converse, including streaming SSE.
+ * Model discovery and transport live in `bedrock-source.ts`.
+ */
+import { randomId } from "@velum-labs/routekit-runtime/timing";
+import { anthropicReasoningDetailsOf, anthropicReasoningExtension, reasoningIndex, reasoningSelectionOf, withoutRouteKitExtensions } from "@velum-labs/routekit-provider-core";
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function isOpusFiveModel(modelId) {
+    return /(?:^|\.)anthropic\.claude-opus-5$/.test(modelId);
+}
+function textParts(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .flatMap((part) => {
+        const item = record(part);
+        return typeof item?.text === "string" ? [item.text] : [];
+    })
+        .join("");
+}
+function imageBlock(part) {
+    const imageUrl = typeof part.image_url === "string" ? part.image_url : record(part.image_url)?.url;
+    if (typeof imageUrl !== "string")
+        return undefined;
+    const match = /^data:image\/(png|jpeg|gif|webp);base64,(.+)$/s.exec(imageUrl);
+    if (match === null)
+        return undefined;
+    return {
+        image: {
+            format: match[1],
+            source: { bytes: Uint8Array.from(Buffer.from(match[2], "base64")) }
+        }
+    };
+}
+function bedrockReasoningBlocks(details) {
+    return anthropicReasoningDetailsOf(details, "message")
+        .sort((left, right) => reasoningIndex(left) - reasoningIndex(right))
+        .map((detail) => {
+        const metadata = anthropicReasoningExtension(detail);
+        return metadata?.redacted === true
+            ? {
+                reasoningContent: {
+                    redactedContent: Uint8Array.from(Buffer.from(detail.encryptedContent ?? "", "base64"))
+                }
+            }
+            : {
+                reasoningContent: {
+                    reasoningText: {
+                        text: detail.text ?? "",
+                        ...(metadata?.signature !== undefined ? { signature: metadata.signature } : {})
+                    }
+                }
+            };
+    });
+}
+function messageContent(message) {
+    const blocks = message.role === "assistant" ? bedrockReasoningBlocks(message.reasoning_details) : [];
+    if (typeof message.content === "string") {
+        if (message.content.length > 0)
+            blocks.push({ text: message.content });
+    }
+    else if (Array.isArray(message.content)) {
+        for (const value of message.content) {
+            const part = record(value);
+            if (part === undefined)
+                continue;
+            if (part.type === "image_url") {
+                const image = imageBlock(part);
+                if (image !== undefined)
+                    blocks.push(image);
+            }
+            else if (typeof part.text === "string" && part.text.length > 0) {
+                blocks.push({ text: part.text });
+            }
+        }
+    }
+    for (const call of message.tool_calls ?? []) {
+        let input = {};
+        try {
+            input = JSON.parse(call.function?.arguments ?? "{}");
+        }
+        catch {
+            input = { raw: call.function?.arguments ?? "" };
+        }
+        blocks.push({
+            toolUse: {
+                toolUseId: call.id ?? randomId(12, "toolu_"),
+                name: call.function?.name ?? "tool",
+                input: input
+            }
+        });
+    }
+    return blocks;
+}
+function bedrockMessages(body) {
+    const systemText = (body.messages ?? [])
+        .filter((message) => message.role === "system")
+        .map((message) => textParts(message.content))
+        .filter((text) => text.length > 0);
+    const messages = [];
+    const sourceMessages = body.messages ?? [];
+    for (let index = 0; index < sourceMessages.length; index += 1) {
+        const message = sourceMessages[index];
+        if (message.role === "system")
+            continue;
+        if (message.role === "tool") {
+            const content = [];
+            let cursor = index;
+            while (cursor < sourceMessages.length && sourceMessages[cursor]?.role === "tool") {
+                const toolMessage = sourceMessages[cursor];
+                content.push({
+                    toolResult: {
+                        toolUseId: toolMessage.tool_call_id ?? "",
+                        content: [{ text: textParts(toolMessage.content) }]
+                    }
+                });
+                cursor += 1;
+            }
+            messages.push({ role: "user", content });
+            index = cursor - 1;
+            continue;
+        }
+        if (message.role !== "user" && message.role !== "assistant")
+            continue;
+        const content = messageContent(message);
+        if (content.length > 0)
+            messages.push({ role: message.role, content });
+    }
+    return {
+        ...(systemText.length > 0 ? { system: systemText.map((text) => ({ text })) } : {}),
+        messages
+    };
+}
+function bedrockTools(body) {
+    const tools = (body.tools ?? []).flatMap((tool) => {
+        const fn = tool.function;
+        if (tool.type !== "function" || typeof fn?.name !== "string")
+            return [];
+        return [
+            {
+                toolSpec: {
+                    name: fn.name,
+                    ...(typeof fn.description === "string" ? { description: fn.description } : {}),
+                    inputSchema: { json: (record(fn.parameters) ?? {}) }
+                }
+            }
+        ];
+    });
+    return tools.length > 0 ? tools : undefined;
+}
+function toolChoice(value) {
+    if (value === "required")
+        return { any: {} };
+    const name = record(record(value)?.function)?.name;
+    if (typeof name === "string")
+        return { tool: { name } };
+    return { auto: {} };
+}
+export function toBedrockConverseInput(body) {
+    const canonical = withoutRouteKitExtensions(body);
+    if (typeof canonical.model !== "string" || canonical.model.length === 0)
+        throw new Error("Bedrock chat requires a model");
+    const translated = bedrockMessages(canonical);
+    const tools = canonical.tool_choice === "none" ? undefined : bedrockTools(canonical);
+    const maxTokens = typeof canonical.max_completion_tokens === "number"
+        ? canonical.max_completion_tokens
+        : canonical.max_tokens;
+    const stops = typeof canonical.stop === "string"
+        ? [canonical.stop]
+        : Array.isArray(canonical.stop)
+            ? canonical.stop.filter((value) => typeof value === "string")
+            : undefined;
+    const selection = reasoningSelectionOf(body);
+    const thinking = selection.mode === "budget"
+        ? { thinking: { type: "enabled", budget_tokens: selection.budgetTokens } }
+        : isOpusFiveModel(canonical.model)
+            ? selection.mode === "effort"
+                ? { thinking: { type: "adaptive" }, output_config: { effort: selection.effort } }
+                : selection.mode === "adaptive"
+                    ? { thinking: { type: "adaptive" } }
+                    : selection.mode === "disabled"
+                        ? { thinking: { type: "disabled" } }
+                        : undefined
+            : undefined;
+    const additionalModelRequestFields = thinking !== undefined || typeof canonical.top_k === "number"
+        ? {
+            ...thinking,
+            ...(typeof canonical.top_k === "number" ? { top_k: canonical.top_k } : {})
+        }
+        : undefined;
+    return {
+        modelId: canonical.model,
+        ...translated,
+        ...(tools !== undefined
+            ? { toolConfig: { tools, toolChoice: toolChoice(canonical.tool_choice) } }
+            : {}),
+        ...(typeof maxTokens === "number" ||
+            typeof canonical.temperature === "number" ||
+            typeof canonical.top_p === "number" ||
+            stops !== undefined
+            ? {
+                inferenceConfig: {
+                    ...(typeof maxTokens === "number" ? { maxTokens } : {}),
+                    ...(typeof canonical.temperature === "number"
+                        ? { temperature: canonical.temperature }
+                        : {}),
+                    ...(typeof canonical.top_p === "number" ? { topP: canonical.top_p } : {}),
+                    ...(stops !== undefined ? { stopSequences: stops } : {})
+                }
+            }
+            : {}),
+        ...(additionalModelRequestFields !== undefined ? { additionalModelRequestFields } : {})
+    };
+}
+function finishReason(reason) {
+    switch (reason) {
+        case "max_tokens":
+            return "length";
+        case "tool_use":
+            return "tool_calls";
+        case "content_filtered":
+        case "guardrail_intervened":
+            return "content_filter";
+        default:
+            return "stop";
+    }
+}
+function usage(value) {
+    if (value === undefined)
+        return undefined;
+    const prompt = value.inputTokens ?? 0;
+    const completion = value.outputTokens ?? 0;
+    return {
+        prompt_tokens: prompt,
+        completion_tokens: completion,
+        total_tokens: value.totalTokens ?? prompt + completion
+    };
+}
+function outputMessage(output) {
+    const content = output.output?.message?.content ?? [];
+    let text = "";
+    let reasoning = "";
+    const reasoningDetails = [];
+    const toolCalls = [];
+    for (const [index, block] of content.entries()) {
+        if ("text" in block && typeof block.text === "string")
+            text += block.text;
+        if ("toolUse" in block && block.toolUse !== undefined)
+            toolCalls.push({
+                id: block.toolUse.toolUseId,
+                type: "function",
+                function: { name: block.toolUse.name, arguments: JSON.stringify(block.toolUse.input ?? {}) }
+            });
+        if ("reasoningContent" in block && block.reasoningContent !== undefined) {
+            if ("reasoningText" in block.reasoningContent &&
+                block.reasoningContent.reasoningText !== undefined) {
+                const reasoningText = block.reasoningContent.reasoningText;
+                reasoning += reasoningText.text ?? "";
+                reasoningDetails.push({
+                    text: reasoningText.text ?? "",
+                    extensions: [
+                        {
+                            namespace: "anthropic.reasoning",
+                            value: { index, signature: reasoningText.signature ?? "" }
+                        }
+                    ]
+                });
+            }
+            else if ("redactedContent" in block.reasoningContent &&
+                block.reasoningContent.redactedContent !== undefined) {
+                reasoningDetails.push({
+                    encryptedContent: Buffer.from(block.reasoningContent.redactedContent).toString("base64"),
+                    extensions: [
+                        {
+                            namespace: "anthropic.reasoning",
+                            value: { index, redacted: true }
+                        }
+                    ]
+                });
+            }
+        }
+    }
+    return {
+        role: "assistant",
+        content: text,
+        ...(reasoning.length > 0 ? { reasoning } : {}),
+        ...(reasoningDetails.length > 0 ? { reasoning_details: reasoningDetails } : {}),
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {})
+    };
+}
+export function fromBedrockConverseOutput(output, model) {
+    return {
+        id: output.$metadata.requestId ?? randomId(18, "chatcmpl_"),
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [
+            { index: 0, message: outputMessage(output), finish_reason: finishReason(output.stopReason) }
+        ],
+        ...(usage(output.usage) !== undefined ? { usage: usage(output.usage) } : {})
+    };
+}
+function streamError(event) {
+    for (const key of [
+        "internalServerException",
+        "modelStreamErrorException",
+        "validationException",
+        "throttlingException",
+        "serviceUnavailableException"
+    ]) {
+        const value = event[key];
+        if (value !== undefined)
+            return new Error(value.message ?? `Bedrock stream ${key}`);
+    }
+    return undefined;
+}
+function sse(data) {
+    return new TextEncoder().encode(`data: ${typeof data === "string" ? data : JSON.stringify(data)}\n\n`);
+}
+export function streamResponse(stream, model, signal) {
+    const id = randomId(18, "chatcmpl_");
+    const created = Math.floor(Date.now() / 1000);
+    const chunk = (delta, finishReasonValue = null, extra = {}) => ({
+        id,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [{ index: 0, delta, finish_reason: finishReasonValue }],
+        ...extra
+    });
+    const body = new ReadableStream({
+        async start(controller) {
+            const indexes = new Map();
+            const reasoningIndexes = new Set();
+            let nextTool = 0;
+            try {
+                controller.enqueue(sse(chunk({ role: "assistant" })));
+                for await (const event of stream) {
+                    if (signal?.aborted === true)
+                        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+                    const error = streamError(event);
+                    if (error !== undefined)
+                        throw error;
+                    if (event.contentBlockStart?.start?.toolUse !== undefined) {
+                        const sourceIndex = event.contentBlockStart.contentBlockIndex;
+                        const index = nextTool++;
+                        if (sourceIndex !== undefined)
+                            indexes.set(sourceIndex, index);
+                        const tool = event.contentBlockStart.start.toolUse;
+                        controller.enqueue(sse(chunk({
+                            tool_calls: [
+                                {
+                                    index,
+                                    id: tool.toolUseId,
+                                    type: "function",
+                                    function: { name: tool.name, arguments: "" }
+                                }
+                            ]
+                        })));
+                    }
+                    const delta = event.contentBlockDelta?.delta;
+                    if (delta !== undefined && "text" in delta && typeof delta.text === "string")
+                        controller.enqueue(sse(chunk({ content: delta.text })));
+                    if (delta !== undefined && "toolUse" in delta && delta.toolUse !== undefined) {
+                        const sourceIndex = event.contentBlockDelta?.contentBlockIndex;
+                        const index = sourceIndex === undefined ? 0 : (indexes.get(sourceIndex) ?? 0);
+                        controller.enqueue(sse(chunk({
+                            tool_calls: [{ index, function: { arguments: delta.toolUse.input ?? "" } }]
+                        })));
+                    }
+                    if (delta !== undefined &&
+                        "reasoningContent" in delta &&
+                        delta.reasoningContent !== undefined) {
+                        const reasoningIndex = event.contentBlockDelta?.contentBlockIndex ?? 0;
+                        const isThinkingDelta = ("text" in delta.reasoningContent &&
+                            typeof delta.reasoningContent.text === "string") ||
+                            ("signature" in delta.reasoningContent &&
+                                typeof delta.reasoningContent.signature === "string");
+                        if (isThinkingDelta && !reasoningIndexes.has(reasoningIndex)) {
+                            reasoningIndexes.add(reasoningIndex);
+                            controller.enqueue(sse(chunk({
+                                reasoning_details: [
+                                    {
+                                        type: "thinking",
+                                        index: reasoningIndex,
+                                        phase: "start"
+                                    }
+                                ]
+                            })));
+                        }
+                        if ("text" in delta.reasoningContent &&
+                            typeof delta.reasoningContent.text === "string") {
+                            controller.enqueue(sse(chunk({
+                                reasoning: delta.reasoningContent.text,
+                                reasoning_details: [
+                                    {
+                                        type: "thinking",
+                                        index: reasoningIndex,
+                                        phase: "delta",
+                                        thinking: delta.reasoningContent.text
+                                    }
+                                ]
+                            })));
+                        }
+                        else if ("signature" in delta.reasoningContent &&
+                            typeof delta.reasoningContent.signature === "string") {
+                            controller.enqueue(sse(chunk({
+                                reasoning_details: [
+                                    {
+                                        type: "thinking",
+                                        index: reasoningIndex,
+                                        phase: "signature",
+                                        signature: delta.reasoningContent.signature
+                                    }
+                                ]
+                            })));
+                        }
+                        else if ("redactedContent" in delta.reasoningContent &&
+                            delta.reasoningContent.redactedContent !== undefined) {
+                            controller.enqueue(sse(chunk({
+                                reasoning_details: [
+                                    {
+                                        type: "redacted_thinking",
+                                        index: reasoningIndex,
+                                        phase: "block",
+                                        data: Buffer.from(delta.reasoningContent.redactedContent).toString("base64")
+                                    }
+                                ]
+                            })));
+                        }
+                    }
+                    const stoppedIndex = event.contentBlockStop?.contentBlockIndex;
+                    if (stoppedIndex !== undefined && reasoningIndexes.has(stoppedIndex)) {
+                        controller.enqueue(sse(chunk({
+                            reasoning_details: [
+                                {
+                                    type: "thinking",
+                                    index: stoppedIndex,
+                                    phase: "stop"
+                                }
+                            ]
+                        })));
+                    }
+                    if (event.messageStop !== undefined)
+                        controller.enqueue(sse(chunk({}, finishReason(event.messageStop.stopReason))));
+                    if (event.metadata?.usage !== undefined)
+                        controller.enqueue(sse(chunk({}, null, { usage: usage(event.metadata.usage) })));
+                }
+                controller.enqueue(sse("[DONE]"));
+                controller.close();
+            }
+            catch (error) {
+                if (signal?.aborted !== true) {
+                    controller.enqueue(sse({
+                        error: {
+                            type: "provider_error",
+                            message: error instanceof Error ? error.message : String(error)
+                        }
+                    }));
+                    controller.enqueue(sse("[DONE]"));
+                }
+                controller.close();
+            }
+        }
+    });
+    return new Response(body, { headers: { "content-type": "text/event-stream; charset=utf-8" } });
+}
+export function errorResponse(error) {
+    const metadata = record(record(error)?.$metadata);
+    const status = typeof metadata?.httpStatusCode === "number" ? metadata.httpStatusCode : 502;
+    return Response.json({
+        error: {
+            type: "provider_error",
+            message: error instanceof Error ? error.message : String(error)
+        }
+    }, { status });
+}

package/dist/internal-providers/provider-bedrock/connection-settings.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Accept only the HTTPS S3 object URL forms documented for CloudFormation
+ * Quick Create. Website, accelerate, service-lookalike, bucket-root, signed,
+ * and credential-bearing URLs are intentionally rejected.
+ */
+export declare function isBedrockRoleTemplateUrl(value: string): boolean;

package/dist/internal-providers/provider-bedrock/connection-settings.js

@@ -0,0 +1,41 @@
+const awsRegionPattern = "[a-z]{2}(?:-[a-z]+)+-\\d";
+const bucketPattern = "[a-z0-9](?:[a-z0-9-]{1,61}[a-z0-9])";
+const bucketNamePattern = new RegExp(`^${bucketPattern}$`, "u");
+const virtualHostedS3Pattern = new RegExp(`^${bucketPattern}\\.s3\\.${awsRegionPattern}\\.amazonaws\\.com$`, "u");
+const pathStyleS3Pattern = new RegExp(`^s3[.-]${awsRegionPattern}\\.amazonaws\\.com$`, "u");
+function hasTemplateObjectPath(url, pathStyle) {
+    const pathSegments = url.pathname.split("/").filter((segment) => segment !== "");
+    if (!pathStyle)
+        return pathSegments.length >= 1;
+    return (pathSegments.length >= 2 &&
+        bucketNamePattern.test(pathSegments[0] ?? ""));
+}
+/**
+ * Accept only the HTTPS S3 object URL forms documented for CloudFormation
+ * Quick Create. Website, accelerate, service-lookalike, bucket-root, signed,
+ * and credential-bearing URLs are intentionally rejected.
+ */
+export function isBedrockRoleTemplateUrl(value) {
+    try {
+        const authority = /^https:\/\/([^/?#]+)(?:[/?#]|$)/iu.exec(value)?.[1];
+        if (authority === undefined || authority.includes(":") || authority.includes("@")) {
+            return false;
+        }
+        const url = new URL(value);
+        if (url.protocol !== "https:" ||
+            url.port !== "" ||
+            url.username !== "" ||
+            url.password !== "" ||
+            url.search !== "" ||
+            url.hash !== "") {
+            return false;
+        }
+        const hostname = url.hostname.toLowerCase();
+        const pathStyle = pathStyleS3Pattern.test(hostname);
+        return ((pathStyle || virtualHostedS3Pattern.test(hostname)) &&
+            hasTemplateObjectPath(url, pathStyle));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/internal-providers/provider-bedrock/connection.d.ts

@@ -0,0 +1,17 @@
+import { fromNodeProviderChain, fromTemporaryCredentials } from "@aws-sdk/credential-providers";
+import { Effect } from "effect";
+import { type ProviderCredentialAdapter, type ProviderEnrollmentAdapter } from "@velum-labs/routekit-provider-core";
+export declare const bedrockRoleEnrollment: ProviderEnrollmentAdapter;
+type CredentialDependencies = Readonly<{
+    nodeProviderChain: typeof fromNodeProviderChain;
+    temporaryCredentials: typeof fromTemporaryCredentials;
+}>;
+export declare function makeBedrockRoleCredentials(dependencies?: CredentialDependencies): ProviderCredentialAdapter;
+export declare const bedrockRoleCredentials: Readonly<{
+    resolve: (binding: import("@velum-labs/routekit-provider-core").ProviderCredentialBinding, context: Readonly<{
+        sourceId: string;
+        credentials?: import("@velum-labs/routekit-provider-core").ProviderCredentialAccess;
+        resources?: Readonly<Record<string, unknown>>;
+    }>) => Effect.Effect<import("@velum-labs/routekit-provider-core").ProviderCredentialRuntime, Error, import("@velum-labs/routekit-runtime/effect").RouteKitPlatform>;
+}>;
+export {};