@fractaal/pi-ai 0.86.9 → 1.6.0

package/dist/api/bedrock-converse-stream.js

@@ -7,15 +7,16 @@ import { appendAssistantMessageDiagnostic } from "../utils/diagnostics.js";
 import { normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
-import { parseStreamingJson } from "../utils/json-parse.js";
+import { getClientVersion } from "../utils/identity.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { ToolCallArgumentsStream } from "../utils/streaming-json.js";
 import { getSystemMessageText } from "../utils/text.js";
 import { collapseSystemMessages, getCurrentTools, getInitialSystemMessage, withoutInitialSystemMessage, } from "../utils/transcript.js";
-import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
+import { getJsonSchemaToolParameters, isStrictToolLimitErrorMessage, prefersJsonSchemaStrictSampling, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext, clampReasoning, } from "./simple-options.js";
-import { transformMessages } from "./transform-messages.js";
+import { splitErrorToolResultImages, transformMessages } from "./transform-messages.js";
 const EMPTY_TEXT_PLACEHOLDER = "<empty>";
 const THINKING_BINDING_CONTROLS_BETA = "thinking-binding-controls-2026-08-01";
 /** Matches the placeholder the Anthropic API path uses for redacted thinking. */
@@ -42,7 +43,7 @@ export const stream = (model, context, options = {}) => {
             stopReason: "pending",
             timestamp: Date.now(),
         };
-        const blocks = output.content;
+        const openBlocks = new Map();
         // A profile explicitly configured through pi's auth flow (the `profile`
         // option or scoped `AWS_PROFILE` on the stored credential's env) must win
         // over ambient AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY. The SDK default
@@ -51,6 +52,7 @@ export const stream = (model, context, options = {}) => {
         const optionsProfile = options.profile || options.env?.AWS_PROFILE;
         const config = {
             profile: optionsProfile || getProviderEnvValue("AWS_PROFILE", options.env),
+            customUserAgent: bedrockUserAgent(options.identity),
         };
         const configuredRegion = getConfiguredBedrockRegion(options);
         const hasAmbientConfiguredProfile = Boolean(getProviderEnvValue("AWS_PROFILE"));
@@ -143,24 +145,49 @@ export const stream = (model, context, options = {}) => {
             const inferenceMaxTokens = options.maxTokens ?? (isAnthropicClaudeModel(model) ? model.maxTokens : undefined);
             const initialSystemMessage = getInitialSystemMessage(normalizedContext.messages);
             const initialSystemPrompt = initialSystemMessage ? getSystemMessageText(initialSystemMessage) : undefined;
-            let commandInput = {
-                modelId: model.id,
-                messages: convertMessages(normalizedContext, model, cacheRetention, options.env),
-                system: buildSystemPrompt(initialSystemPrompt, model, cacheRetention, options.env),
-                inferenceConfig: {
-                    ...(inferenceMaxTokens !== undefined && { maxTokens: inferenceMaxTokens }),
-                    ...(options.temperature !== undefined && { temperature: options.temperature }),
-                },
-                toolConfig: convertToolConfig(getCurrentTools(normalizedContext.messages), options.toolChoice, supportsStrictMode),
-                additionalModelRequestFields: buildAdditionalModelRequestFields(model, options),
-                ...(options.requestMetadata !== undefined && { requestMetadata: options.requestMetadata }),
-            };
-            const nextCommandInput = await options?.onPayload?.(commandInput, model);
-            if (nextCommandInput !== undefined) {
-                commandInput = nextCommandInput;
+            let disablePreferredStrictTools = false;
+            let response;
+            for (;;) {
+                const tools = convertToolConfig(getCurrentTools(normalizedContext.messages), options.toolChoice, supportsStrictMode, disablePreferredStrictTools);
+                let commandInput = {
+                    modelId: model.id,
+                    messages: convertMessages(normalizedContext, model, cacheRetention, options.env),
+                    system: buildSystemPrompt(initialSystemPrompt, model, cacheRetention, options.env),
+                    inferenceConfig: {
+                        ...(inferenceMaxTokens !== undefined && { maxTokens: inferenceMaxTokens }),
+                        ...(options.temperature !== undefined && { temperature: options.temperature }),
+                    },
+                    toolConfig: tools.toolConfig,
+                    additionalModelRequestFields: buildAdditionalModelRequestFields(model, options),
+                    ...(options.requestMetadata !== undefined && { requestMetadata: options.requestMetadata }),
+                };
+                const nextCommandInput = await options?.onPayload?.(commandInput, model);
+                if (nextCommandInput !== undefined) {
+                    commandInput = nextCommandInput;
+                }
+                try {
+                    response = await client.send(new ConverseStreamCommand(commandInput), { abortSignal: options.signal });
+                    break;
+                }
+                catch (error) {
+                    // Bedrock checks the tool schemas before it starts the stream, so a retry never repeats streamed output.
+                    if (options.signal?.aborted ||
+                        disablePreferredStrictTools ||
+                        !tools.hasPreferredStrictTools ||
+                        !(error instanceof BedrockRuntimeServiceException) ||
+                        error.name !== "ValidationException" ||
+                        !isStrictToolLimitErrorMessage(error.message)) {
+                        throw error;
+                    }
+                    disablePreferredStrictTools = true;
+                    appendAssistantMessageDiagnostic(output, {
+                        type: "bedrock_strict_tools_fallback",
+                        timestamp: Date.now(),
+                        error: { message: error.message },
+                        details: { reason: "strict_tool_limits_exceeded" },
+                    });
+                }
             }
-            const command = new ConverseStreamCommand(commandInput);
-            const response = await client.send(command, { abortSignal: options.signal });
             responseRequestId = normalizeDiagnosticValue(response.$metadata.requestId);
             if (!observedRawResponse && response.$metadata.httpStatusCode !== undefined) {
                 const responseHeaders = {};
@@ -178,13 +205,13 @@ export const stream = (model, context, options = {}) => {
                     stream.push({ type: "start", partial: output });
                 }
                 else if (item.contentBlockStart) {
-                    handleContentBlockStart(item.contentBlockStart, blocks, output, stream);
+                    handleContentBlockStart(item.contentBlockStart, openBlocks, output, stream);
                 }
                 else if (item.contentBlockDelta) {
-                    handleContentBlockDelta(item.contentBlockDelta, blocks, output, stream);
+                    handleContentBlockDelta(item.contentBlockDelta, openBlocks, output, stream);
                 }
                 else if (item.contentBlockStop) {
-                    handleContentBlockStop(item.contentBlockStop, blocks, output, stream);
+                    handleContentBlockStop(item.contentBlockStop, openBlocks, output, stream);
                 }
                 else if (item.messageStop) {
                     output.rawStopReason = item.messageStop.stopReason;
@@ -223,15 +250,12 @@ export const stream = (model, context, options = {}) => {
                 throw new Error(output.errorMessage || "An unknown error occurred");
             }
             // A stream can settle without stopping every block, so finalize here too.
-            for (const block of output.content)
-                finalizeStreamingBlock(block);
+            flushOpenBlocks(openBlocks, output);
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
         catch (error) {
-            for (const block of output.content) {
-                finalizeStreamingBlock(block);
-            }
+            flushOpenBlocks(openBlocks, output);
             output.stopReason = options.signal?.aborted ? "aborted" : "error";
             output.errorMessage = formatBedrockError(error);
             if (output.stopReason === "error") {
@@ -337,6 +361,16 @@ function isReservedHeader(key) {
     const lower = key.toLowerCase();
     return lower.startsWith("x-amz-") || RESERVED_HEADER_EXACT.has(lower);
 }
+/**
+ * The client identity as AWS SDK user agent pairs. The SDK appends them to its own `User-Agent` and escapes characters
+ * that are not valid in a user agent token, so the detailed form is reduced to name and version.
+ */
+function bedrockUserAgent(identity) {
+    const mode = identity?.userAgent ?? "detailed";
+    if (typeof mode === "object")
+        return mode.custom;
+    return mode === "short" ? [["pi"]] : [["pi", getClientVersion(identity)]];
+}
 /**
  * Attach caller-supplied headers to the outgoing Bedrock request via a Smithy
  * `build`-step middleware. The `build` step runs after request serialisation but
@@ -424,59 +458,60 @@ export const streamSimple = (model, context, options) => {
         thinkingBudgets: options.thinkingBudgets,
     });
 };
-function handleContentBlockStart(event, blocks, output, stream) {
-    const index = event.contentBlockIndex;
+function handleContentBlockStart(event, openBlocks, output, stream) {
     const start = event.start;
     if (start?.toolUse) {
-        const block = {
+        output.content.push({
             type: "toolCall",
             id: start.toolUse.toolUseId || "",
             name: start.toolUse.name || "",
             arguments: {},
-            partialJson: "",
-            index,
-        };
-        output.content.push(block);
-        stream.push({ type: "toolcall_start", contentIndex: blocks.length - 1, partial: output });
+        });
+        const contentIndex = output.content.length - 1;
+        openBlocks.set(event.contentBlockIndex, { contentIndex, arguments: new ToolCallArgumentsStream() });
+        stream.push({ type: "toolcall_start", contentIndex, partial: output });
     }
 }
-function handleContentBlockDelta(event, blocks, output, stream) {
+function handleContentBlockDelta(event, openBlocks, output, stream) {
     const contentBlockIndex = event.contentBlockIndex;
     const delta = event.delta;
-    let index = blocks.findIndex((b) => b.index === contentBlockIndex);
-    let block = blocks[index];
+    let open = openBlocks.get(contentBlockIndex);
+    let block = open === undefined ? undefined : output.content[open.contentIndex];
     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 });
+        if (!open) {
+            output.content.push({ type: "text", text: "" });
+            open = { contentIndex: output.content.length - 1 };
+            openBlocks.set(contentBlockIndex, open);
+            block = output.content[open.contentIndex];
+            stream.push({ type: "text_start", contentIndex: open.contentIndex, partial: output });
         }
-        if (block.type === "text") {
+        if (block?.type === "text") {
             block.text += delta.text;
-            stream.push({ type: "text_delta", contentIndex: index, delta: delta.text, partial: output });
+            stream.push({ type: "text_delta", contentIndex: open.contentIndex, delta: delta.text, partial: output });
         }
     }
-    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?.toolUse && block?.type === "toolCall" && open?.arguments !== undefined) {
+        block.arguments = open.arguments.append(delta.toolUse.input || "");
+        stream.push({
+            type: "toolcall_delta",
+            contentIndex: open.contentIndex,
+            delta: delta.toolUse.input || "",
+            partial: output,
+        });
     }
     else if (delta?.reasoningContent) {
-        let thinkingBlock = block;
-        let thinkingIndex = index;
-        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 });
+        if (!open) {
+            output.content.push({ type: "thinking", thinking: "", thinkingSignature: "" });
+            open = { contentIndex: output.content.length - 1 };
+            openBlocks.set(contentBlockIndex, open);
+            block = output.content[open.contentIndex];
+            stream.push({ type: "thinking_start", contentIndex: open.contentIndex, partial: output });
         }
-        if (thinkingBlock?.type === "thinking") {
+        if (block?.type === "thinking") {
+            const thinkingIndex = open.contentIndex;
             if (delta.reasoningContent.text) {
-                thinkingBlock.thinking += delta.reasoningContent.text;
+                block.thinking += delta.reasoningContent.text;
                 stream.push({
                     type: "thinking_delta",
                     contentIndex: thinkingIndex,
@@ -486,18 +521,17 @@ function handleContentBlockDelta(event, blocks, output, stream) {
             }
             // `thinkingSignature` holds either an Anthropic signature or an opaque redacted
             // payload, never both: mixing them would corrupt whichever arrived first.
-            if (delta.reasoningContent.signature && !thinkingBlock.redacted) {
-                thinkingBlock.thinkingSignature =
-                    (thinkingBlock.thinkingSignature || "") + delta.reasoningContent.signature;
+            if (delta.reasoningContent.signature && !block.redacted) {
+                block.thinkingSignature = (block.thinkingSignature || "") + delta.reasoningContent.signature;
             }
             if (delta.reasoningContent.redactedContent?.length) {
                 // Encrypted reasoning from non-Anthropic models on Bedrock (e.g. OpenAI GPT-5.6).
                 // The payload is opaque, so keep it verbatim in `thinkingSignature` the way the
                 // Anthropic path stores redacted thinking, and replay it on the next turn.
-                if (!thinkingBlock.redacted) {
-                    thinkingBlock.redacted = true;
-                    thinkingBlock.thinkingSignature = "";
-                    thinkingBlock.thinking += REDACTED_THINKING_PLACEHOLDER;
+                if (!block.redacted) {
+                    block.redacted = true;
+                    block.thinkingSignature = "";
+                    block.thinking += REDACTED_THINKING_PLACEHOLDER;
                     stream.push({
                         type: "thinking_delta",
                         contentIndex: thinkingIndex,
@@ -505,32 +539,29 @@ function handleContentBlockDelta(event, blocks, output, stream) {
                         partial: output,
                     });
                 }
-                thinkingBlock.redactedChunks ??= [];
-                thinkingBlock.redactedChunks.push(delta.reasoningContent.redactedContent);
+                open.redactedChunks ??= [];
+                open.redactedChunks.push(delta.reasoningContent.redactedContent);
             }
         }
     }
 }
 /**
- * Encodes buffered encrypted reasoning into `thinkingSignature` and drops the scratch
- * buffer, which must never reach a persisted message: `Uint8Array` serializes to an
- * index-keyed object roughly ten times the size of the base64 payload.
+ * Encodes buffered encrypted reasoning into `thinkingSignature`. The chunks stay in the stream state, never on the
+ * block: `Uint8Array` is not JSON and serializes to an index-keyed object roughly ten times the size of the base64
+ * payload.
  */
-function flushRedactedContent(block) {
-    if (block.type !== "thinking" || !block.redactedChunks)
+function flushRedactedContent(open, output) {
+    const block = output.content[open.contentIndex];
+    if (block?.type !== "thinking" || !open.redactedChunks)
         return;
-    block.thinkingSignature = bytesToBase64(block.redactedChunks);
-    delete block.redactedChunks;
+    block.thinkingSignature = bytesToBase64(open.redactedChunks);
+    open.redactedChunks = undefined;
 }
-/**
- * Strips every streaming scratch field. Runs from the terminal paths as well as
- * `contentBlockStop`, because a stream can settle without stopping each block.
- */
-function finalizeStreamingBlock(block) {
-    delete block.index;
-    // partialJson is only a streaming scratch buffer; never persist it.
-    delete block.partialJson;
-    flushRedactedContent(block);
+/** Ends the stream state of blocks a stream settled without stopping. */
+function flushOpenBlocks(openBlocks, output) {
+    for (const open of openBlocks.values())
+        flushRedactedContent(open, output);
+    openBlocks.clear();
 }
 function handleMetadata(event, model, output) {
     if (event.usage) {
@@ -543,25 +574,24 @@ function handleMetadata(event, model, output) {
         calculateCost(model, output.usage);
     }
 }
-function handleContentBlockStop(event, blocks, output, stream) {
-    const index = blocks.findIndex((b) => b.index === event.contentBlockIndex);
-    const block = blocks[index];
-    if (!block)
+function handleContentBlockStop(event, openBlocks, output, stream) {
+    const open = openBlocks.get(event.contentBlockIndex);
+    if (!open)
         return;
-    delete block.index;
+    openBlocks.delete(event.contentBlockIndex);
+    const index = open.contentIndex;
+    const block = output.content[index];
     switch (block.type) {
         case "text":
             stream.push({ type: "text_end", contentIndex: index, content: block.text, partial: output });
             break;
         case "thinking":
-            flushRedactedContent(block);
+            flushRedactedContent(open, output);
             stream.push({ type: "thinking_end", contentIndex: index, content: block.thinking, partial: output });
             break;
         case "toolCall":
-            block.arguments = parseStreamingJson(block.partialJson);
-            // Finalize in-place and strip the scratch buffer so replay only
-            // carries parsed arguments.
-            delete block.partialJson;
+            if (open.arguments !== undefined)
+                Object.assign(block, open.arguments.finish());
             stream.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: output });
             break;
     }
@@ -586,6 +616,7 @@ function supportsAdaptiveThinking(modelId, modelName) {
         s.includes("opus-5") ||
         s.includes("sonnet-4-6") ||
         s.includes("sonnet-5") ||
+        s.includes("haiku-5") ||
         s.includes("fable-5"));
 }
 function supportsNativeXhighEffort(model) {
@@ -594,6 +625,7 @@ function supportsNativeXhighEffort(model) {
         s.includes("opus-4-8") ||
         s.includes("opus-5") ||
         s.includes("sonnet-5") ||
+        s.includes("haiku-5") ||
         s.includes("fable-5"));
 }
 /**
@@ -606,6 +638,7 @@ function supportsThinkingBlockBinding(model) {
         s.includes("opus-4-8") ||
         s.includes("opus-5") ||
         s.includes("sonnet-5") ||
+        s.includes("haiku-5") ||
         s.includes("fable-5"));
 }
 function mapThinkingLevelToEffort(model, level) {
@@ -675,8 +708,8 @@ function supportsPromptCaching(model, env) {
             return true;
         return false;
     }
-    // Claude 5 models (fable-5, opus-5, sonnet-5)
-    if (candidates.some((s) => s.includes("fable-5") || s.includes("opus-5") || s.includes("sonnet-5")))
+    // Claude 5 models (fable-5, opus-5, sonnet-5, haiku-5)
+    if (candidates.some((s) => s.includes("fable-5") || s.includes("opus-5") || s.includes("sonnet-5") || s.includes("haiku-5")))
         return true;
     // Claude 4.x models (opus-4, sonnet-4, haiku-4)
     if (candidates.some((s) => s.includes("-4-")))
@@ -867,30 +900,28 @@ function convertMessages(context, model, cacheRetention, env) {
                 // 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: convertToolResultContent(m.content),
-                        status: m.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS,
-                    },
-                });
-                // Look ahead for consecutive toolResult messages
-                let j = i + 1;
+                // Claude rejects error tool results that contain anything but text, so for Claude their
+                // images follow all tool results of the turn (#10794). Other models keep them in place.
+                const errorImages = [];
+                let j = i;
                 while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                    const nextMsg = transformedMessages[j];
+                    const toolMsg = transformedMessages[j];
+                    const split = isAnthropicClaudeModel(model) ? splitErrorToolResultImages(toolMsg) : undefined;
                     toolResults.push({
                         toolResult: {
-                            toolUseId: nextMsg.toolCallId,
-                            content: convertToolResultContent(nextMsg.content),
-                            status: nextMsg.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS,
+                            toolUseId: toolMsg.toolCallId,
+                            content: convertToolResultContent(split?.content ?? toolMsg.content),
+                            status: toolMsg.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS,
                         },
                     });
+                    if (split) {
+                        errorImages.push({ text: split.caption }, ...split.images.map((image) => ({ image: createImageBlock(image.mimeType, image.data) })));
+                    }
                     j++;
                 }
                 // Skip the messages we've already processed
                 i = j - 1;
-                result.push({ role: ConversationRole.USER, content: toolResults });
+                result.push({ role: ConversationRole.USER, content: [...toolResults, ...errorImages] });
                 break;
             }
             default:
@@ -911,13 +942,17 @@ function convertMessages(context, model, cacheRetention, env) {
     }
     return result;
 }
-function convertToolConfig(tools, toolChoice, supportsStrictMode) {
-    if (!tools?.length)
-        return undefined;
-    if (toolChoice === "none")
-        return undefined;
+function convertToolConfig(tools, toolChoice, supportsStrictMode, disablePreferredStrictTools) {
+    if (!tools?.length || toolChoice === "none")
+        return { toolConfig: undefined, hasPreferredStrictTools: false };
+    let hasPreferredStrictTools = false;
     const bedrockTools = tools.map((tool) => {
-        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
+        const preferred = prefersJsonSchemaStrictSampling(tool);
+        const strict = disablePreferredStrictTools && preferred
+            ? undefined
+            : resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
+        if (strict === true && preferred)
+            hasPreferredStrictTools = true;
         return {
             toolSpec: {
                 name: tool.name,
@@ -940,7 +975,7 @@ function convertToolConfig(tools, toolChoice, supportsStrictMode) {
                 bedrockToolChoice = { tool: { name: toolChoice.name } };
             }
     }
-    return { tools: bedrockTools, toolChoice: bedrockToolChoice };
+    return { toolConfig: { tools: bedrockTools, toolChoice: bedrockToolChoice }, hasPreferredStrictTools };
 }
 function mapStopReason(reason) {
     switch (reason) {
@@ -1053,8 +1088,36 @@ function buildAdditionalModelRequestFields(model, options) {
         }
         return result;
     }
+    const candidates = getModelMatchCandidates(model.id, model.name);
+    if (candidates.some((s) => s.includes("gpt-oss"))) {
+        return { reasoning_effort: OPENAI_GPT_OSS_EFFORT[options.reasoning] };
+    }
+    if (candidates.some((s) => s.includes("gpt-"))) {
+        const mapped = model.thinkingLevelMap?.[options.reasoning];
+        return {
+            reasoning: { effort: typeof mapped === "string" ? mapped : OPENAI_GPT_EFFORT[options.reasoning] },
+        };
+    }
     return undefined;
 }
+/** OpenAI GPT models (GPT-5.x, GPT-6) take a nested `reasoning.effort` and reject `minimal`. */
+const OPENAI_GPT_EFFORT = {
+    minimal: "low",
+    low: "low",
+    medium: "medium",
+    high: "high",
+    xhigh: "xhigh",
+    max: "max",
+};
+/** gpt-oss takes a flat `reasoning_effort` and only accepts low, medium and high. */
+const OPENAI_GPT_OSS_EFFORT = {
+    minimal: "low",
+    low: "low",
+    medium: "medium",
+    high: "high",
+    xhigh: "high",
+    max: "high",
+};
 function createImageBlock(mimeType, data) {
     let format;
     switch (mimeType) {