@fractaal/pi-ai 0.85.4 → 0.86.2

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

@@ -3,6 +3,7 @@ import { NodeHttpHandler } from "@smithy/node-http-handler";
 import { HttpProxyAgent } from "http-proxy-agent";
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { calculateCost } from "../models.js";
+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";
@@ -10,12 +11,19 @@ import { parseStreamingJson } from "../utils/json-parse.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
+import { getSystemMessageText } from "../utils/text.js";
+import { collapseSystemMessages, getCurrentTools, getInitialSystemMessage, withoutInitialSystemMessage, } from "../utils/transcript.js";
+import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext, clampReasoning, } from "./simple-options.js";
 import { 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. */
+const REDACTED_THINKING_PLACEHOLDER = "[Reasoning redacted]";
 export const stream = (model, context, options = {}) => {
     const stream = new AssistantMessageEventStream();
+    // Bedrock has no mid-conversation system messages; fold them into the leading prompt.
+    const normalizedContext = collapseSystemMessages(context);
     (async () => {
         const output = {
             role: "assistant",
@@ -115,23 +123,35 @@ export const stream = (model, context, options = {}) => {
             config.token = { token: bearerToken };
             config.authSchemePreference = ["httpBearerAuth"];
         }
+        // Kept outside the try so the catch can still correlate a mid-stream failure:
+        // exceptions delivered as stream events carry no HTTP metadata of their own.
+        let responseRequestId;
         try {
+            const supportsStrictMode = model.compat?.supportsStrictMode ?? false;
             const client = new BedrockRuntimeClient(config);
+            let observedRawResponse = false;
+            if (options.onResponse) {
+                addResponseHeadersMiddleware(client, options.onResponse, model, () => {
+                    observedRawResponse = true;
+                });
+            }
             const customHeaders = providerHeadersToRecord(options.headers);
             if (customHeaders) {
                 addCustomHeadersMiddleware(client, customHeaders);
             }
             const cacheRetention = resolveCacheRetention(options.cacheRetention, options.env);
             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(context, model, cacheRetention, options.env),
-                system: buildSystemPrompt(context.systemPrompt, model, cacheRetention, options.env),
+                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(context.tools, options.toolChoice, model.compat?.supportsStrictMode ?? false),
+                toolConfig: convertToolConfig(getCurrentTools(normalizedContext.messages), options.toolChoice, supportsStrictMode),
                 additionalModelRequestFields: buildAdditionalModelRequestFields(model, options),
                 ...(options.requestMetadata !== undefined && { requestMetadata: options.requestMetadata }),
             };
@@ -141,7 +161,8 @@ export const stream = (model, context, options = {}) => {
             }
             const command = new ConverseStreamCommand(commandInput);
             const response = await client.send(command, { abortSignal: options.signal });
-            if (response.$metadata.httpStatusCode !== undefined) {
+            responseRequestId = normalizeDiagnosticValue(response.$metadata.requestId);
+            if (!observedRawResponse && response.$metadata.httpStatusCode !== undefined) {
                 const responseHeaders = {};
                 if (response.$metadata.requestId) {
                     responseHeaders["x-amzn-requestid"] = response.$metadata.requestId;
@@ -149,6 +170,7 @@ export const stream = (model, context, options = {}) => {
                 await options?.onResponse?.({ status: response.$metadata.httpStatusCode, headers: responseHeaders }, model);
             }
             for await (const item of response.stream) {
+                await options.onProviderStreamEvent?.(item, model);
                 if (item.messageStart) {
                     if (item.messageStart.role !== ConversationRole.ASSISTANT) {
                         throw new Error("Unexpected assistant message start but got user message start instead");
@@ -200,17 +222,21 @@ export const stream = (model, context, options = {}) => {
             if (output.stopReason === "error" || output.stopReason === "aborted") {
                 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);
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
         catch (error) {
             for (const block of output.content) {
-                delete block.index;
-                // partialJson is only a streaming scratch buffer; never persist it.
-                delete block.partialJson;
+                finalizeStreamingBlock(block);
             }
             output.stopReason = options.signal?.aborted ? "aborted" : "error";
             output.errorMessage = formatBedrockError(error);
+            if (output.stopReason === "error") {
+                appendBedrockFailureDiagnostic(output, error, responseRequestId);
+            }
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -260,6 +286,46 @@ function formatBedrockError(error) {
     }
     return `${core}${dataRetentionHint}`;
 }
+/** Over-long header values are dropped rather than truncated: a truncated request id is not a request id. */
+const MAX_BEDROCK_DIAGNOSTIC_VALUE_CHARS = 200;
+function normalizeDiagnosticValue(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed.length === 0 || trimmed.length > MAX_BEDROCK_DIAGNOSTIC_VALUE_CHARS)
+        return undefined;
+    return trimmed;
+}
+/**
+ * The SDK puts the modeled code on `error.name` for service exceptions and unmodeled stream errors alike, so
+ * do not narrow to `BedrockRuntimeServiceException`. Modeled Bedrock errors all end in `Exception`, unlike
+ * transport names such as `TimeoutError`.
+ */
+function extractBedrockErrorCode(error) {
+    if (!(error instanceof Error) || !error.name.endsWith("Exception"))
+        return undefined;
+    return normalizeDiagnosticValue(error.name);
+}
+/**
+ * Structured metadata alongside `errorMessage`, which stays byte-identical because `isRetryableAssistantError`
+ * matches against it. Unknown fields are omitted, never guessed: a modeled mid-stream exception reaches us as
+ * a bare object literal, leaving only `fallbackRequestId`. `details` only, as the throw is not always `Error`.
+ */
+function appendBedrockFailureDiagnostic(output, error, fallbackRequestId) {
+    const metadata = error?.$metadata;
+    const details = {};
+    if (typeof metadata?.httpStatusCode === "number")
+        details.status = metadata.httpStatusCode;
+    const errorCode = extractBedrockErrorCode(error);
+    if (errorCode !== undefined)
+        details.errorCode = errorCode;
+    const requestId = normalizeDiagnosticValue(metadata?.requestId) ?? fallbackRequestId;
+    if (requestId !== undefined)
+        details.requestId = requestId;
+    if (Object.keys(details).length === 0)
+        return;
+    appendAssistantMessageDiagnostic(output, { type: "bedrock_response_failure", timestamp: Date.now(), details });
+}
 /**
  * Header keys that must never be overwritten by caller-supplied headers.
  * `host` and `x-amz-*` participate in the SigV4 canonical request; `authorization`
@@ -293,8 +359,40 @@ function addCustomHeadersMiddleware(client, headers) {
     };
     client.middlewareStack.add(middleware, { step: "build", name: "pi-ai-custom-headers", priority: "low" });
 }
+function isSmithyHttpResponse(response) {
+    if (!response || typeof response !== "object")
+        return false;
+    const candidate = response;
+    return typeof candidate.statusCode === "number" && !!candidate.headers && typeof candidate.headers === "object";
+}
+function toProviderResponse(response) {
+    if (!isSmithyHttpResponse(response))
+        return undefined;
+    return { status: response.statusCode, headers: { ...response.headers } };
+}
+/**
+ * Bedrock's modeled `$metadata` only preserves selected HTTP metadata (for example
+ * requestId), so custom gateway headers are otherwise lost before callers see
+ * `onResponse`. Capture the raw Smithy HTTP response at the deserialize step,
+ * after the SDK receives the response but before the event stream is consumed.
+ */
+function addResponseHeadersMiddleware(client, onResponse, model, onObserved) {
+    const middleware = (next) => async (args) => {
+        const result = await next(args);
+        const providerResponse = toProviderResponse(result.response);
+        if (providerResponse) {
+            onObserved();
+            await onResponse(providerResponse, model);
+        }
+        return result;
+    };
+    client.middlewareStack.add(middleware, { step: "deserialize", name: "pi-ai-response-headers" });
+}
 export const streamSimple = (model, context, options) => {
-    const base = buildBaseOptions(model, context, options, undefined);
+    const base = {
+        ...buildBaseOptions(model, context, options, undefined),
+        toolChoice: options?.toolChoice,
+    };
     if (!options?.reasoning) {
         return stream(model, context, { ...base, reasoning: undefined });
     }
@@ -386,19 +484,61 @@ function handleContentBlockDelta(event, blocks, output, stream) {
                     partial: output,
                 });
             }
-            if (delta.reasoningContent.signature) {
+            // `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.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;
+                    stream.push({
+                        type: "thinking_delta",
+                        contentIndex: thinkingIndex,
+                        delta: REDACTED_THINKING_PLACEHOLDER,
+                        partial: output,
+                    });
+                }
+                thinkingBlock.redactedChunks ??= [];
+                thinkingBlock.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.
+ */
+function flushRedactedContent(block) {
+    if (block.type !== "thinking" || !block.redactedChunks)
+        return;
+    block.thinkingSignature = bytesToBase64(block.redactedChunks);
+    delete block.redactedChunks;
+}
+/**
+ * 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);
+}
 function handleMetadata(event, model, output) {
     if (event.usage) {
         output.usage.input = event.usage.inputTokens || 0;
         output.usage.output = event.usage.outputTokens || 0;
         output.usage.cacheRead = event.usage.cacheReadInputTokens || 0;
         output.usage.cacheWrite = event.usage.cacheWriteInputTokens || 0;
+        output.usage.cacheWrite1h = event.usage.cacheDetails?.reduce((total, detail) => total + (detail.ttl === CacheTTL.ONE_HOUR ? (detail.inputTokens ?? 0) : 0), 0);
         output.usage.totalTokens = event.usage.totalTokens || output.usage.input + output.usage.output;
         calculateCost(model, output.usage);
     }
@@ -414,6 +554,7 @@ function handleContentBlockStop(event, blocks, output, stream) {
             stream.push({ type: "text_end", contentIndex: index, content: block.text, partial: output });
             break;
         case "thinking":
+            flushRedactedContent(block);
             stream.push({ type: "thinking_end", contentIndex: index, content: block.thinking, partial: output });
             break;
         case "toolCall":
@@ -455,6 +596,18 @@ function supportsNativeXhighEffort(model) {
         s.includes("sonnet-5") ||
         s.includes("fable-5"));
 }
+/**
+ * Check if the model accepts `thinking.block_binding`. Opus 4.6 and Sonnet 4.6 reject it with
+ * "thinking.adaptive.block_binding: Extra inputs are not permitted".
+ */
+function supportsThinkingBlockBinding(model) {
+    const candidates = getModelMatchCandidates(model.id, model.name);
+    return candidates.some((s) => s.includes("opus-4-7") ||
+        s.includes("opus-4-8") ||
+        s.includes("opus-5") ||
+        s.includes("sonnet-5") ||
+        s.includes("fable-5"));
+}
 function mapThinkingLevelToEffort(model, level) {
     if (level === "xhigh" && supportsNativeXhighEffort(model))
         return "xhigh";
@@ -570,6 +723,17 @@ function createNonBlankTextBlock(text) {
 function createRequiredTextBlock(text) {
     return createNonBlankTextBlock(text) ?? { text: EMPTY_TEXT_PLACEHOLDER };
 }
+function sanitizeBedrockDocument(value) {
+    if (Array.isArray(value)) {
+        return value.map(sanitizeBedrockDocument);
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([key]) => key.length > 0)
+            .map(([key, nestedValue]) => [key, sanitizeBedrockDocument(nestedValue)]));
+    }
+    return value;
+}
 function convertToolResultContent(content) {
     const result = [];
     for (const c of content) {
@@ -588,7 +752,7 @@ function convertToolResultContent(content) {
 }
 function convertMessages(context, model, cacheRetention, env) {
     const result = [];
-    const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+    const transformedMessages = transformMessages(withoutInitialSystemMessage(context.messages), model, normalizeToolCallId);
     for (let i = 0; i < transformedMessages.length; i++) {
         const m = transformedMessages[i];
         switch (m.role) {
@@ -616,10 +780,7 @@ function convertMessages(context, model, cacheRetention, env) {
                     if (content.length === 0)
                         content.push({ text: EMPTY_TEXT_PLACEHOLDER });
                 }
-                result.push({
-                    role: ConversationRole.USER,
-                    content,
-                });
+                result.push({ role: ConversationRole.USER, content });
                 break;
             }
             case "assistant": {
@@ -641,10 +802,19 @@ function convertMessages(context, model, cacheRetention, env) {
                         }
                         case "toolCall":
                             contentBlocks.push({
-                                toolUse: { toolUseId: c.id, name: c.name, input: c.arguments },
+                                toolUse: { toolUseId: c.id, name: c.name, input: sanitizeBedrockDocument(c.arguments) },
                             });
                             break;
                         case "thinking": {
+                            // Encrypted reasoning is opaque: replay the stored payload as the
+                            // `redactedContent` member instead of lowering it to reasoning text.
+                            if (c.redacted) {
+                                const redactedContent = decodeRedactedContent(c.thinkingSignature);
+                                if (redactedContent?.length) {
+                                    contentBlocks.push({ reasoningContent: { redactedContent } });
+                                }
+                                continue;
+                            }
                             // Skip empty thinking blocks
                             const thinking = sanitizeSurrogates(c.thinking);
                             if (thinking.trim().length === 0)
@@ -720,10 +890,7 @@ function convertMessages(context, model, cacheRetention, env) {
                 }
                 // Skip the messages we've already processed
                 i = j - 1;
-                result.push({
-                    role: ConversationRole.USER,
-                    content: toolResults,
-                });
+                result.push({ role: ConversationRole.USER, content: toolResults });
                 break;
             }
             default:
@@ -755,7 +922,7 @@ function convertToolConfig(tools, toolChoice, supportsStrictMode) {
             toolSpec: {
                 name: tool.name,
                 description: tool.description,
-                inputSchema: { json: tool.parameters },
+                inputSchema: { json: getJsonSchemaToolParameters(tool, strict) },
                 ...(strict === true ? { strict: true } : {}),
             },
         };
@@ -845,11 +1012,21 @@ function buildAdditionalModelRequestFields(model, options) {
     if (isAnthropicClaudeModel(model)) {
         // GovCloud Bedrock currently rejects the Claude thinking.display field.
         // Omit it there until the GovCloud Converse schema catches up.
-        const display = isGovCloudBedrockTarget(model, options) ? undefined : (options.thinkingDisplay ?? "summarized");
+        const isGovCloud = isGovCloudBedrockTarget(model, options);
+        const display = isGovCloud ? undefined : (options.thinkingDisplay ?? "summarized");
+        // Replayed signed thinking blocks are bound to the system prompt and tools they were
+        // created with. Bedrock 400s on replay after either changes unless stale blocks are
+        // dropped, matching the Anthropic provider. Skipped on GovCloud like display.
+        const useBlockBinding = !isGovCloud && supportsThinkingBlockBinding(model);
         const result = supportsAdaptiveThinking(model.id, model.name)
             ? {
-                thinking: { type: "adaptive", ...(display !== undefined ? { display } : {}) },
+                thinking: {
+                    type: "adaptive",
+                    ...(display !== undefined ? { display } : {}),
+                    ...(useBlockBinding ? { block_binding: { prefix_mismatch_behavior: "drop_block" } } : {}),
+                },
                 output_config: { effort: mapThinkingLevelToEffort(model, options.reasoning) },
+                ...(useBlockBinding ? { anthropic_beta: [THINKING_BINDING_CONTROLS_BETA] } : {}),
             }
             : (() => {
                 const defaultBudgets = {
@@ -897,11 +1074,43 @@ function createImageBlock(mimeType, data) {
         default:
             throw new Error(`Unknown image type: ${mimeType}`);
     }
+    return { source: { bytes: base64ToBytes(data) }, format };
+}
+function base64ToBytes(data) {
     const binaryString = atob(data);
     const bytes = new Uint8Array(binaryString.length);
     for (let i = 0; i < binaryString.length; i++) {
         bytes[i] = binaryString.charCodeAt(i);
     }
-    return { source: { bytes }, format };
+    return bytes;
+}
+/**
+ * Decodes a stored redacted payload. The AWS SDK hands the blob over as bytes, but a
+ * persisted session carries it as base64. A hand-edited or externally produced session
+ * can hold a signature that is not base64; drop that block instead of failing the
+ * whole request.
+ */
+function decodeRedactedContent(signature) {
+    if (!signature)
+        return undefined;
+    try {
+        return base64ToBytes(signature);
+    }
+    catch {
+        return undefined;
+    }
+}
+function bytesToBase64(chunks) {
+    // Encrypted reasoning runs to tens of KB, so build the binary string in slices
+    // rather than one concatenation per byte. The window stays under the engine's
+    // argument-count limit for spread calls.
+    const WINDOW = 0x8000;
+    let binary = "";
+    for (const chunk of chunks) {
+        for (let i = 0; i < chunk.length; i += WINDOW) {
+            binary += String.fromCharCode(...chunk.subarray(i, i + WINDOW));
+        }
+    }
+    return btoa(binary);
 }
 //# sourceMappingURL=bedrock-converse-stream.js.map