indusagi 0.12.19 → 0.12.21

package/dist/ai/providers/amazon-bedrock.js

@@ -16,6 +16,7 @@ import { transformMessages } from "./transform-messages.js";
  * emits standardized assistant events.
  */
 class BedrockStreamHandler extends BaseStreamHandler {
+    executeFn;
     constructor(executeFn) {
         super();
         this.executeFn = executeFn;
@@ -28,6 +29,9 @@ class BedrockStreamHandler extends BaseStreamHandler {
     }
 }
 export class BedrockRequestBuilder {
+    model;
+    context;
+    options;
     constructor(model, context, options) {
         this.model = model;
         this.context = context;
@@ -39,7 +43,7 @@ export class BedrockRequestBuilder {
             messages: convertMessages(this.context, this.model),
             system: buildSystemPrompt(this.context.systemPrompt, this.model),
             inferenceConfig: { maxTokens: this.options.maxTokens, temperature: this.options.temperature },
-            toolConfig: convertToolConfig(this.context.tools, this.options.toolChoice),
+            toolConfig: BedrockToolConfigFactory.fromToolsAndChoice(this.context.tools, this.options.toolChoice),
             additionalModelRequestFields: buildAdditionalModelRequestFields(this.model, this.options),
         };
     }
@@ -50,6 +54,7 @@ export const streamBedrock = (model, context, options = {}) => {
     const events = new StreamEventHelper(stream, output);
     const handler = new BedrockStreamHandler(async () => {
         const blocks = output.content;
+        const eventRouter = new BedrockStreamEventRouter(blocks, output, stream, model);
         const config = {
             region: options.region,
             profile: options.profile,
@@ -90,19 +95,19 @@ export const streamBedrock = (model, context, options = {}) => {
                     events.start();
                 }
                 else if (item.contentBlockStart) {
-                    handleContentBlockStart(item.contentBlockStart, blocks, output, stream);
+                    eventRouter.onBlockStart(item.contentBlockStart);
                 }
                 else if (item.contentBlockDelta) {
-                    handleContentBlockDelta(item.contentBlockDelta, blocks, output, stream);
+                    eventRouter.onBlockDelta(item.contentBlockDelta);
                 }
                 else if (item.contentBlockStop) {
-                    handleContentBlockStop(item.contentBlockStop, blocks, output, stream);
+                    eventRouter.onBlockStop(item.contentBlockStop);
                 }
                 else if (item.messageStop) {
                     output.stopReason = mapProviderStopReason(item.messageStop.stopReason, "bedrock");
                 }
                 else if (item.metadata) {
-                    handleMetadata(item.metadata, model, output);
+                    eventRouter.onMetadata(item.metadata);
                 }
                 else if (item.internalServerException) {
                     throw new Error(`Internal server error: ${item.internalServerException.message}`);
@@ -166,64 +171,88 @@ export const streamSimpleBedrock = (model, context, options) => {
         thinkingBudgets: options.thinkingBudgets,
     });
 };
-function handleContentBlockStart(event, blocks, output, stream) {
-    const index = event.contentBlockIndex;
-    const start = event.start;
-    if (start?.toolUse) {
-        const block = {
+class BedrockStreamEventRouter {
+    blocks;
+    output;
+    stream;
+    model;
+    constructor(blocks, output, stream, model) {
+        this.blocks = blocks;
+        this.output = output;
+        this.stream = stream;
+        this.model = model;
+    }
+    onBlockStart(event) {
+        const contentIndex = event.contentBlockIndex;
+        const start = event.start;
+        if (!start?.toolUse)
+            return;
+        const toolCallBlock = {
             type: "toolCall",
             id: start.toolUse.toolUseId || "",
             name: start.toolUse.name || "",
             arguments: {},
             partialJson: "",
-            index,
+            index: contentIndex,
         };
-        output.content.push(block);
-        stream.push({ type: "toolcall_start", contentIndex: blocks.length - 1, partial: output });
+        this.output.content.push(toolCallBlock);
+        this.stream.push({ type: "toolcall_start", contentIndex: this.blocks.length - 1, partial: this.output });
     }
-}
-function handleContentBlockDelta(event, blocks, output, stream) {
-    const contentBlockIndex = event.contentBlockIndex;
-    const delta = event.delta;
-    let index = blocks.findIndex((b) => b.index === contentBlockIndex);
-    let block = blocks[index];
-    if (delta?.text !== undefined) {
-        // If no text block exists yet, create one, as `handleContentBlockStart` is not sent for text blocks
-        if (!block) {
-            const newBlock = { type: "text", text: "", index: contentBlockIndex };
-            output.content.push(newBlock);
-            index = blocks.length - 1;
-            block = blocks[index];
-            stream.push({ type: "text_start", contentIndex: index, partial: output });
+    onBlockDelta(event) {
+        const contentIndex = event.contentBlockIndex;
+        const delta = event.delta;
+        let blockIndex = this.blocks.findIndex((b) => b.index === contentIndex);
+        let activeBlock = this.blocks[blockIndex];
+        if (delta?.text !== undefined) {
+            if (!activeBlock) {
+                const createdTextBlock = { type: "text", text: "", index: contentIndex };
+                this.output.content.push(createdTextBlock);
+                blockIndex = this.blocks.length - 1;
+                activeBlock = this.blocks[blockIndex];
+                this.stream.push({ type: "text_start", contentIndex: blockIndex, partial: this.output });
+            }
+            if (activeBlock.type === "text") {
+                activeBlock.text += delta.text;
+                this.stream.push({ type: "text_delta", contentIndex: blockIndex, delta: delta.text, partial: this.output });
+            }
+            return;
         }
-        if (block.type === "text") {
-            block.text += delta.text;
-            stream.push({ type: "text_delta", contentIndex: index, delta: delta.text, partial: output });
+        if (delta?.toolUse && activeBlock?.type === "toolCall") {
+            activeBlock.partialJson = (activeBlock.partialJson || "") + (delta.toolUse.input || "");
+            activeBlock.arguments = parseStreamingJson(activeBlock.partialJson);
+            this.stream.push({
+                type: "toolcall_delta",
+                contentIndex: blockIndex,
+                delta: delta.toolUse.input || "",
+                partial: this.output,
+            });
+            return;
         }
-    }
-    else if (delta?.toolUse && block?.type === "toolCall") {
-        block.partialJson = (block.partialJson || "") + (delta.toolUse.input || "");
-        block.arguments = parseStreamingJson(block.partialJson);
-        stream.push({ type: "toolcall_delta", contentIndex: index, delta: delta.toolUse.input || "", partial: output });
-    }
-    else if (delta?.reasoningContent) {
-        let thinkingBlock = block;
-        let thinkingIndex = index;
+        if (!delta?.reasoningContent) {
+            return;
+        }
+        let thinkingBlock = activeBlock;
+        let thinkingIndex = blockIndex;
         if (!thinkingBlock) {
-            const newBlock = { type: "thinking", thinking: "", thinkingSignature: "", index: contentBlockIndex };
-            output.content.push(newBlock);
-            thinkingIndex = blocks.length - 1;
-            thinkingBlock = blocks[thinkingIndex];
-            stream.push({ type: "thinking_start", contentIndex: thinkingIndex, partial: output });
+            const createdThinkingBlock = {
+                type: "thinking",
+                thinking: "",
+                thinkingSignature: "",
+                index: contentIndex,
+            };
+            this.output.content.push(createdThinkingBlock);
+            thinkingIndex = this.blocks.length - 1;
+            thinkingBlock = this.blocks[thinkingIndex];
+            this.stream.push({ type: "thinking_start", contentIndex: thinkingIndex, partial: this.output });
         }
         if (thinkingBlock?.type === "thinking") {
             if (delta.reasoningContent.text) {
                 thinkingBlock.thinking += delta.reasoningContent.text;
-                stream.push({
+                this.stream.push({
                     type: "thinking_delta",
                     contentIndex: thinkingIndex,
                     delta: delta.reasoningContent.text,
-                    partial: output,
+                    partial: this.output,
                 });
             }
             if (delta.reasoningContent.signature) {
@@ -232,45 +261,50 @@ function handleContentBlockDelta(event, blocks, output, stream) {
             }
         }
     }
-}
-function normalizeBedrockUsage(event) {
-    return {
-        input: event.usage?.inputTokens || 0,
-        output: event.usage?.outputTokens || 0,
-        cacheRead: event.usage?.cacheReadInputTokens || 0,
-        cacheWrite: event.usage?.cacheWriteInputTokens || 0,
-        totalTokens: event.usage?.totalTokens || (event.usage?.inputTokens || 0) + (event.usage?.outputTokens || 0),
-    };
-}
-function handleMetadata(event, model, output) {
-    if (event.usage) {
-        const normalized = normalizeBedrockUsage(event);
-        output.usage.input = normalized.input;
-        output.usage.output = normalized.output;
-        output.usage.cacheRead = normalized.cacheRead;
-        output.usage.cacheWrite = normalized.cacheWrite;
-        output.usage.totalTokens = normalized.totalTokens;
-        calculateCost(model, output.usage);
+    onMetadata(event) {
+        if (!event.usage)
+            return;
+        const usage = this.normalizeUsage(event);
+        this.output.usage.input = usage.input;
+        this.output.usage.output = usage.output;
+        this.output.usage.cacheRead = usage.cacheRead;
+        this.output.usage.cacheWrite = usage.cacheWrite;
+        this.output.usage.totalTokens = usage.totalTokens;
+        calculateCost(this.model, this.output.usage);
     }
-}
-function handleContentBlockStop(event, blocks, output, stream) {
-    const index = blocks.findIndex((b) => b.index === event.contentBlockIndex);
-    const block = blocks[index];
-    if (!block)
-        return;
-    delete block.index;
-    switch (block.type) {
-        case "text":
-            stream.push({ type: "text_end", contentIndex: index, content: block.text, partial: output });
-            break;
-        case "thinking":
-            stream.push({ type: "thinking_end", contentIndex: index, content: block.thinking, partial: output });
-            break;
-        case "toolCall":
-            block.arguments = parseStreamingJson(block.partialJson);
-            delete block.partialJson;
-            stream.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: output });
-            break;
+    onBlockStop(event) {
+        const index = this.blocks.findIndex((candidate) => candidate.index === event.contentBlockIndex);
+        const block = this.blocks[index];
+        if (!block)
+            return;
+        delete block.index;
+        switch (block.type) {
+            case "text":
+                this.stream.push({ type: "text_end", contentIndex: index, content: block.text, partial: this.output });
+                break;
+            case "thinking":
+                this.stream.push({
+                    type: "thinking_end",
+                    contentIndex: index,
+                    content: block.thinking,
+                    partial: this.output,
+                });
+                break;
+            case "toolCall":
+                block.arguments = parseStreamingJson(block.partialJson);
+                delete block.partialJson;
+                this.stream.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: this.output });
+                break;
+        }
+    }
+    normalizeUsage(event) {
+        return {
+            input: event.usage?.inputTokens || 0,
+            output: event.usage?.outputTokens || 0,
+            cacheRead: event.usage?.cacheReadInputTokens || 0,
+            cacheWrite: event.usage?.cacheWriteInputTokens || 0,
+            totalTokens: event.usage?.totalTokens || (event.usage?.inputTokens || 0) + (event.usage?.outputTokens || 0),
+        };
     }
 }
 /**
@@ -314,159 +348,183 @@ function normalizeToolCallId(id) {
     const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
     return sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
 }
-function convertMessages(context, model) {
-    const result = [];
-    const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
-    for (let i = 0; i < transformedMessages.length; i++) {
-        const m = transformedMessages[i];
-        switch (m.role) {
-            case "user":
-                result.push({
-                    role: ConversationRole.USER,
-                    content: typeof m.content === "string"
-                        ? [{ text: sanitizeSurrogates(m.content) }]
-                        : m.content.map((c) => {
-                            switch (c.type) {
-                                case "text":
-                                    return { text: sanitizeSurrogates(c.text) };
-                                case "image":
-                                    return { image: createImageBlock(c.mimeType, c.data) };
-                                default:
-                                    throw new Error("Unknown user content type");
-                            }
-                        }),
-                });
-                break;
-            case "assistant": {
-                // Skip assistant messages with empty content (e.g., from aborted requests)
-                // Bedrock rejects messages with empty content arrays
-                if (m.content.length === 0) {
-                    continue;
-                }
-                const contentBlocks = [];
-                for (const c of m.content) {
-                    switch (c.type) {
-                        case "text":
-                            // Skip empty text blocks
-                            if (c.text.trim().length === 0)
-                                continue;
-                            contentBlocks.push({ text: sanitizeSurrogates(c.text) });
-                            break;
-                        case "toolCall":
-                            contentBlocks.push({
-                                toolUse: { toolUseId: c.id, name: c.name, input: c.arguments },
-                            });
-                            break;
-                        case "thinking":
-                            // Skip empty thinking blocks
-                            if (c.thinking.trim().length === 0)
-                                continue;
-                            // Only Anthropic models support the signature field in reasoningText.
-                            // For other models, we omit the signature to avoid errors like:
-                            // "This model doesn't support the reasoningContent.reasoningText.signature field"
-                            if (supportsThinkingSignature(model)) {
-                                contentBlocks.push({
-                                    reasoningContent: {
-                                        reasoningText: { text: sanitizeSurrogates(c.thinking), signature: c.thinkingSignature },
-                                    },
-                                });
-                            }
-                            else {
-                                contentBlocks.push({
-                                    reasoningContent: {
-                                        reasoningText: { text: sanitizeSurrogates(c.thinking) },
-                                    },
-                                });
-                            }
-                            break;
-                        default:
-                            throw new Error("Unknown assistant content type");
-                    }
+class BedrockMessageComposer {
+    model;
+    constructor(model) {
+        this.model = model;
+    }
+    compose(context) {
+        const composedMessages = [];
+        const normalizedMessages = transformMessages(context.messages, this.model, normalizeToolCallId);
+        for (let messageIndex = 0; messageIndex < normalizedMessages.length; messageIndex++) {
+            const message = normalizedMessages[messageIndex];
+            switch (message.role) {
+                case "user":
+                    composedMessages.push(this.fromUser(message));
+                    break;
+                case "assistant": {
+                    const assistant = this.fromAssistant(message);
+                    if (assistant)
+                        composedMessages.push(assistant);
+                    break;
                 }
-                // Skip if all content blocks were filtered out
-                if (contentBlocks.length === 0) {
-                    continue;
+                case "toolResult": {
+                    const merged = this.fromToolResults(normalizedMessages, messageIndex);
+                    composedMessages.push(merged.message);
+                    messageIndex = merged.nextIndex;
+                    break;
                 }
-                result.push({
-                    role: ConversationRole.ASSISTANT,
-                    content: contentBlocks,
-                });
-                break;
+                default:
+                    throw new Error("Unknown message role");
             }
-            case "toolResult": {
-                // Collect all consecutive toolResult messages into a single user message
-                // Bedrock requires all tool results to be in one message
-                const toolResults = [];
-                // Add current tool result with all content blocks combined
-                toolResults.push({
-                    toolResult: {
-                        toolUseId: m.toolCallId,
-                        content: m.content.map((c) => c.type === "image"
-                            ? { image: createImageBlock(c.mimeType, c.data) }
-                            : { text: sanitizeSurrogates(c.text) }),
-                        status: m.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS,
-                    },
-                });
-                // Look ahead for consecutive toolResult messages
-                let j = i + 1;
-                while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                    const nextMsg = transformedMessages[j];
-                    toolResults.push({
-                        toolResult: {
-                            toolUseId: nextMsg.toolCallId,
-                            content: nextMsg.content.map((c) => c.type === "image"
-                                ? { image: createImageBlock(c.mimeType, c.data) }
-                                : { text: sanitizeSurrogates(c.text) }),
-                            status: nextMsg.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS,
-                        },
-                    });
-                    j++;
+        }
+        this.attachCachePoint(composedMessages);
+        return composedMessages;
+    }
+    fromUser(message) {
+        const userContent = typeof message.content === "string"
+            ? [{ text: sanitizeSurrogates(message.content) }]
+            : message.content.map((entry) => {
+                switch (entry.type) {
+                    case "text":
+                        return { text: sanitizeSurrogates(entry.text) };
+                    case "image":
+                        return { image: createImageBlock(entry.mimeType, entry.data) };
+                    default:
+                        throw new Error("Unknown user content type");
                 }
-                // Skip the messages we've already processed
-                i = j - 1;
-                result.push({
-                    role: ConversationRole.USER,
-                    content: toolResults,
-                });
-                break;
+            });
+        return {
+            role: ConversationRole.USER,
+            content: userContent,
+        };
+    }
+    fromAssistant(message) {
+        if (message.content.length === 0) {
+            return undefined;
+        }
+        const assistantBlocks = [];
+        for (const block of message.content) {
+            switch (block.type) {
+                case "text":
+                    if (block.text.trim().length === 0)
+                        continue;
+                    assistantBlocks.push({ text: sanitizeSurrogates(block.text) });
+                    break;
+                case "toolCall":
+                    assistantBlocks.push({
+                        toolUse: { toolUseId: block.id, name: block.name, input: block.arguments },
+                    });
+                    break;
+                case "thinking":
+                    if (block.thinking.trim().length === 0)
+                        continue;
+                    assistantBlocks.push(this.buildThinkingBlock(block.thinking, block.thinkingSignature));
+                    break;
+                default:
+                    throw new Error("Unknown assistant content type");
             }
-            default:
-                throw new Error("Unknown message role");
         }
+        if (assistantBlocks.length === 0) {
+            return undefined;
+        }
+        return {
+            role: ConversationRole.ASSISTANT,
+            content: assistantBlocks,
+        };
+    }
+    fromToolResults(messages, startIndex) {
+        const groupedResults = [];
+        const first = messages[startIndex];
+        groupedResults.push({
+            toolResult: {
+                toolUseId: first.toolCallId,
+                content: this.mapToolResultContent(first),
+                status: first.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS,
+            },
+        });
+        let cursor = startIndex + 1;
+        while (cursor < messages.length && messages[cursor].role === "toolResult") {
+            const next = messages[cursor];
+            groupedResults.push({
+                toolResult: {
+                    toolUseId: next.toolCallId,
+                    content: this.mapToolResultContent(next),
+                    status: next.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS,
+                },
+            });
+            cursor++;
+        }
+        return {
+            message: { role: ConversationRole.USER, content: groupedResults },
+            nextIndex: cursor - 1,
+        };
+    }
+    attachCachePoint(messages) {
+        if (!supportsPromptCaching(this.model) || messages.length === 0) {
+            return;
+        }
+        const last = messages[messages.length - 1];
+        if (last.role === ConversationRole.USER && last.content) {
+            last.content.push({ cachePoint: { type: CachePointType.DEFAULT } });
+        }
+    }
+    mapToolResultContent(message) {
+        return message.content.map((contentBlock) => contentBlock.type === "image"
+            ? { image: createImageBlock(contentBlock.mimeType, contentBlock.data) }
+            : { text: sanitizeSurrogates(contentBlock.text) });
     }
-    // Add cache point to the last user message for supported Claude models
-    if (supportsPromptCaching(model) && result.length > 0) {
-        const lastMessage = result[result.length - 1];
-        if (lastMessage.role === ConversationRole.USER && lastMessage.content) {
-            lastMessage.content.push({ cachePoint: { type: CachePointType.DEFAULT } });
+    buildThinkingBlock(thinkingText, thinkingSignature) {
+        if (supportsThinkingSignature(this.model)) {
+            return {
+                reasoningContent: {
+                    reasoningText: { text: sanitizeSurrogates(thinkingText), signature: thinkingSignature },
+                },
+            };
         }
+        return {
+            reasoningContent: {
+                reasoningText: { text: sanitizeSurrogates(thinkingText) },
+            },
+        };
     }
-    return result;
 }
-function convertToolConfig(tools, toolChoice) {
-    if (!tools?.length || toolChoice === "none")
-        return undefined;
-    const bedrockTools = tools.map((tool) => ({
-        toolSpec: {
-            name: tool.name,
-            description: tool.description,
-            inputSchema: { json: tool.parameters },
-        },
-    }));
-    let bedrockToolChoice;
-    switch (toolChoice) {
-        case "auto":
-            bedrockToolChoice = { auto: {} };
-            break;
-        case "any":
-            bedrockToolChoice = { any: {} };
-            break;
-        default:
-            if (toolChoice?.type === "tool") {
-                bedrockToolChoice = { tool: { name: toolChoice.name } };
-            }
+class BedrockToolConfigFactory {
+    static fromToolsAndChoice(tools, toolChoice) {
+        if (!tools?.length || toolChoice === "none")
+            return undefined;
+        const bedrockTools = tools.map((tool) => ({
+            toolSpec: {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: { json: tool.parameters },
+            },
+        }));
+        const resolvedToolChoice = BedrockToolConfigFactory.resolveToolChoice(toolChoice);
+        return { tools: bedrockTools, toolChoice: resolvedToolChoice };
     }
-    return { tools: bedrockTools, toolChoice: bedrockToolChoice };
+    static resolveToolChoice(toolChoice) {
+        switch (toolChoice) {
+            case "auto":
+                return { auto: {} };
+            case "any":
+                return { any: {} };
+            case "none":
+            case undefined:
+                return undefined;
+            default:
+                if (typeof toolChoice === "object" && toolChoice.type === "tool") {
+                    return { tool: { name: toolChoice.name } };
+                }
+                return undefined;
+        }
+    }
+}
+function convertMessages(context, model) {
+    return new BedrockMessageComposer(model).compose(context);
+}
+function convertToolConfig(tools, toolChoice) {
+    return BedrockToolConfigFactory.fromToolsAndChoice(tools, toolChoice);
 }
 function mapStopReason(reason) {
     switch (reason) {
@@ -482,34 +540,47 @@ function mapStopReason(reason) {
             return "error";
     }
 }
-function buildAdditionalModelRequestFields(model, options) {
+const CLAUDE_THINKING_BUDGETS = {
+    minimal: 1024,
+    low: 2048,
+    medium: 8192,
+    high: 16384,
+    xhigh: 16384,
+};
+function resolveThinkingPayload(model, options) {
     if (!options.reasoning || !model.reasoning) {
         return undefined;
     }
-    if (model.id.includes("anthropic.claude")) {
-        const defaultBudgets = {
-            minimal: 1024,
-            low: 2048,
-            medium: 8192,
-            high: 16384,
-            xhigh: 16384, // Claude doesn't support xhigh, clamp to high
-        };
-        // Custom budgets override defaults (xhigh not in ThinkingBudgets, use high)
-        const level = mapThinkingLevel(options.reasoning, "clamp-xhigh");
-        const budget = options.thinkingBudgets?.[level] ?? defaultBudgets[options.reasoning];
-        const result = {
-            thinking: {
-                type: "enabled",
-                budget_tokens: budget,
-            },
-        };
-        if (options.interleavedThinking) {
-            result.anthropic_beta = ["interleaved-thinking-2025-05-14"];
-        }
-        return result;
+    if (!model.id.includes("anthropic.claude")) {
+        return undefined;
+    }
+    const normalizedLevel = mapThinkingLevel(options.reasoning, "clamp-xhigh");
+    const budget = options.thinkingBudgets?.[normalizedLevel] ?? CLAUDE_THINKING_BUDGETS[options.reasoning];
+    return {
+        type: "enabled",
+        budget_tokens: budget,
+    };
+}
+function resolveClaudeBetaFlags(options) {
+    if (options.interleavedThinking) {
+        return ["interleaved-thinking-2025-05-14"];
     }
     return undefined;
 }
+function buildAdditionalModelRequestFields(model, options) {
+    const thinkingPayload = resolveThinkingPayload(model, options);
+    if (!thinkingPayload) {
+        return undefined;
+    }
+    const fields = {
+        thinking: thinkingPayload,
+    };
+    const betaFlags = resolveClaudeBetaFlags(options);
+    if (betaFlags) {
+        fields.anthropic_beta = betaFlags;
+    }
+    return fields;
+}
 function createImageBlock(mimeType, data) {
     let format;
     switch (mimeType) {