@agent-native/core 0.175.3 → 0.175.4-nightly-20260826190205

package/dist/agent/engine/translate-ai-sdk.js

@@ -7,6 +7,7 @@
  * `ModelMessage` shapes.
  */
 import { classifyProviderError, describeErrorWithCauses, } from "./error-detail.js";
+import { createProviderToolNameMap, toEngineToolName, toProviderToolName, } from "./tool-name.js";
 import { backfillEngineMessagesToolResults } from "./translate-anthropic.js";
 // ---------------------------------------------------------------------------
 // EngineTool → AI SDK tool definition
@@ -19,7 +20,7 @@ import { backfillEngineMessagesToolResults } from "./translate-anthropic.js";
  * schema is wrapped in the SDK's runtime validator; fall back to the raw JSON
  * Schema object otherwise (mostly for unit tests that don't import `ai`).
  */
-export function engineToolsToAISDK(tools, jsonSchema) {
+export function engineToolsToAISDK(tools, jsonSchema, toolNameMap = createProviderToolNameMap(tools)) {
     const result = {};
     for (const tool of tools) {
         const rawSchema = {
@@ -28,7 +29,8 @@ export function engineToolsToAISDK(tools, jsonSchema) {
             properties: tool.inputSchema.properties ?? {},
             required: tool.inputSchema.required ?? [],
         };
-        result[tool.name] = {
+        const providerName = toProviderToolName(tool.name, toolNameMap);
+        result[providerName] = {
             description: tool.description,
             inputSchema: jsonSchema ? jsonSchema(rawSchema) : rawSchema,
         };
@@ -92,7 +94,7 @@ export function engineMessageToAISDK(msg, opts) {
                 toolResultParts.push({
                     type: "tool-result",
                     toolCallId: part.toolCallId,
-                    toolName: part.toolName,
+                    toolName: toProviderToolName(part.toolName, opts?.toolNameMap),
                     output: toolResultOutputToAISDK(part, opts),
                 });
             }
@@ -121,7 +123,7 @@ export function engineMessageToAISDK(msg, opts) {
                 content.push({
                     type: "tool-call",
                     toolCallId: part.id,
-                    toolName: part.name,
+                    toolName: toProviderToolName(part.name, opts?.toolNameMap),
                     input: part.input,
                 });
             }
@@ -152,7 +154,8 @@ export function engineMessageToAISDK(msg, opts) {
     throw new Error(`unknown EngineMessage role: ${msg.role}`);
 }
 export function engineMessagesToAISDK(messages, opts) {
-    return backfillEngineMessagesToolResults(messages).flatMap((msg) => engineMessageToAISDK(msg, opts));
+    const toolNameMap = opts?.toolNameMap ?? createProviderToolNameMap([], messages);
+    return backfillEngineMessagesToolResults(messages).flatMap((msg) => engineMessageToAISDK(msg, { ...opts, toolNameMap }));
 }
 // ---------------------------------------------------------------------------
 // AI SDK TextStreamPart → EngineEvent
@@ -166,7 +169,7 @@ export function engineMessagesToAISDK(messages, opts) {
  * We absorb text/reasoning boundaries, forward text/reasoning/tool-input
  * deltas, and keep the terminal `tool-call`, `finish-step`, and `finish` parts.
  */
-export function aiSdkPartToEngineEvents(part) {
+export function aiSdkPartToEngineEvents(part, toolNameMap) {
     const events = [];
     switch (part?.type) {
         case "text-delta":
@@ -187,14 +190,14 @@ export function aiSdkPartToEngineEvents(part) {
             events.push({
                 type: "tool-input-start",
                 id: part.id ?? part.toolCallId,
-                name: part.toolName,
+                name: toEngineToolName(part.toolName, toolNameMap),
             });
             break;
         case "tool-input-delta":
             events.push({
                 type: "tool-input-delta",
                 id: part.id ?? part.toolCallId,
-                name: part.toolName,
+                name: toEngineToolName(part.toolName, toolNameMap),
                 text: typeof part.delta === "string"
                     ? part.delta
                     : typeof part.text === "string"
@@ -209,7 +212,7 @@ export function aiSdkPartToEngineEvents(part) {
             events.push({
                 type: "tool-call",
                 id: part.toolCallId,
-                name: part.toolName,
+                name: toEngineToolName(part.toolName, toolNameMap),
                 input: part.input ?? {},
             });
             break;
@@ -218,7 +221,7 @@ export function aiSdkPartToEngineEvents(part) {
             events.push({
                 type: "tool-call-error",
                 id: part.toolCallId,
-                name: part.toolName,
+                name: toEngineToolName(part.toolName, toolNameMap),
                 input: part.input ?? {},
                 error: part.errorText ??
                     (part.error instanceof Error
@@ -313,7 +316,7 @@ function usageEventFromLanguageModelUsage(usage) {
  * Reconstruct the assistant message content from an AI SDK v6 `StepResult`.
  * `step.content` is the canonical structured form — iterate it.
  */
-export function aiSdkStepToAssistantContent(step) {
+export function aiSdkStepToAssistantContent(step, toolNameMap) {
     const parts = [];
     for (const part of step?.content ?? []) {
         if (part.type === "text" && part.text) {
@@ -333,7 +336,7 @@ export function aiSdkStepToAssistantContent(step) {
             parts.push({
                 type: "tool-call",
                 id: part.toolCallId,
-                name: part.toolName,
+                name: toEngineToolName(part.toolName, toolNameMap),
                 input: part.input,
             });
         }
@@ -341,7 +344,7 @@ export function aiSdkStepToAssistantContent(step) {
             parts.push({
                 type: "tool-call",
                 id: part.toolCallId,
-                name: part.toolName,
+                name: toEngineToolName(part.toolName, toolNameMap),
                 input: part.input ?? {},
             });
         }

package/dist/agent/engine/translate-anthropic.d.ts

@@ -13,9 +13,10 @@
  * (`engineMessagesToAnthropic`).
  */
 import type Anthropic from "@anthropic-ai/sdk";
+import { type ProviderToolNameMap } from "./tool-name.js";
 import type { EngineTool, EngineMessage, EngineContentPart, EngineEvent } from "./types.js";
-export declare function engineToolToAnthropic(tool: EngineTool): Anthropic.Tool;
-export declare function engineToolsToAnthropic(tools: EngineTool[]): Anthropic.Tool[];
+export declare function engineToolToAnthropic(tool: EngineTool, toolNameMap?: ProviderToolNameMap): Anthropic.Tool;
+export declare function engineToolsToAnthropic(tools: EngineTool[], toolNameMap?: ProviderToolNameMap): Anthropic.Tool[];
 /** JSON.stringify for tool_use inputs; never throws. */
 export declare function stringifyToolUseInputForGateway(input: unknown): string;
 /** Same lead-in as structured-history replay when a tool_result cannot be paired. */
@@ -41,15 +42,16 @@ export declare function unmatchedToolResultReplayText(part: {
 export declare function backfillEngineMessagesToolResults(messages: EngineMessage[]): EngineMessage[];
 export declare function engineMessageToAnthropic(msg: EngineMessage, opts?: {
     builderGateway?: boolean;
+    toolNameMap?: ProviderToolNameMap;
 }): Anthropic.MessageParam;
 /** Messages for the Anthropic HTTP API (strict schema — no extra tool_result fields). */
-export declare function engineMessagesToAnthropic(messages: EngineMessage[]): Anthropic.MessageParam[];
+export declare function engineMessagesToAnthropic(messages: EngineMessage[], toolNameMap?: ProviderToolNameMap): Anthropic.MessageParam[];
 /**
  * Messages for the Builder LLM gateway (Gemini-backed). Same Anthropic-shaped
  * envelope, but every `tool_result` includes `tool_name` and `tool_input`.
  */
-export declare function engineMessagesToBuilderGatewayAnthropic(messages: EngineMessage[]): Anthropic.MessageParam[];
-export declare function anthropicContentToEngine(content: Anthropic.ContentBlock[]): EngineContentPart[];
+export declare function engineMessagesToBuilderGatewayAnthropic(messages: EngineMessage[], toolNameMap?: ProviderToolNameMap): Anthropic.MessageParam[];
+export declare function anthropicContentToEngine(content: Anthropic.ContentBlock[], toolNameMap?: ProviderToolNameMap): EngineContentPart[];
 /**
  * Mutable state threaded across `anthropicChunkToEngineEvents` calls within a
  * single stream. Anthropic's `content_block_delta` chunks carry only the block
@@ -76,7 +78,7 @@ export declare function createAnthropicChunkStreamState(): AnthropicChunkStreamS
  * the engine, so omitting `state` simply drops the progress events without
  * changing tool dispatch.
  */
-export declare function anthropicChunkToEngineEvents(chunk: any, state?: AnthropicChunkStreamState): EngineEvent[];
+export declare function anthropicChunkToEngineEvents(chunk: any, state?: AnthropicChunkStreamState, toolNameMap?: ProviderToolNameMap): EngineEvent[];
 /**
  * Tool arguments arrive split across an arbitrary number of deltas. Every
  * engine announces a tool call the moment the first delta lands, so a stream

package/dist/agent/engine/translate-anthropic.js

@@ -12,6 +12,7 @@
  * that path. The native Anthropic API keeps the strict `tool_result` shape
  * (`engineMessagesToAnthropic`).
  */
+import { createProviderToolNameMap, toEngineToolName, toProviderToolName, } from "./tool-name.js";
 // ---------------------------------------------------------------------------
 // EngineTool → Anthropic.Tool
 // ---------------------------------------------------------------------------
@@ -61,15 +62,16 @@ function normalizeAnthropicInputSchema(toolName, schema) {
     normalized.type = "object";
     return normalized;
 }
-export function engineToolToAnthropic(tool) {
+export function engineToolToAnthropic(tool, toolNameMap) {
+    const providerName = toProviderToolName(tool.name, toolNameMap);
     return {
-        name: tool.name,
+        name: providerName,
         description: tool.description,
         input_schema: normalizeAnthropicInputSchema(tool.name, tool.inputSchema),
     };
 }
-export function engineToolsToAnthropic(tools) {
-    return tools.map(engineToolToAnthropic);
+export function engineToolsToAnthropic(tools, toolNameMap = createProviderToolNameMap(tools)) {
+    return tools.map((tool) => engineToolToAnthropic(tool, toolNameMap));
 }
 // ---------------------------------------------------------------------------
 // Tool result backfill (Gemini / Builder gateway)
@@ -287,14 +289,14 @@ export function engineMessageToAnthropic(msg, opts) {
         : msg.content.filter(replayableAnthropicPart);
     return {
         role: msg.role,
-        content: content.map((p) => enginePartToAnthropic(p, builderGateway)),
+        content: content.map((p) => enginePartToAnthropic(p, builderGateway, opts?.toolNameMap)),
     };
 }
 /** Messages for the Anthropic HTTP API (strict schema — no extra tool_result fields). */
-export function engineMessagesToAnthropic(messages) {
+export function engineMessagesToAnthropic(messages, toolNameMap = createProviderToolNameMap([], messages)) {
     const normalized = backfillEngineMessagesToolResults(messages);
     return normalized.flatMap((m) => {
-        const translated = engineMessageToAnthropic(m);
+        const translated = engineMessageToAnthropic(m, { toolNameMap });
         return translated.content.length > 0 ? [translated] : [];
     });
 }
@@ -302,11 +304,11 @@ export function engineMessagesToAnthropic(messages) {
  * Messages for the Builder LLM gateway (Gemini-backed). Same Anthropic-shaped
  * envelope, but every `tool_result` includes `tool_name` and `tool_input`.
  */
-export function engineMessagesToBuilderGatewayAnthropic(messages) {
+export function engineMessagesToBuilderGatewayAnthropic(messages, toolNameMap = createProviderToolNameMap([], messages)) {
     const normalized = backfillEngineMessagesToolResults(messages);
-    return normalized.map((m) => engineMessageToAnthropic(m, { builderGateway: true }));
+    return normalized.map((m) => engineMessageToAnthropic(m, { builderGateway: true, toolNameMap }));
 }
-function enginePartToAnthropic(part, builderGateway) {
+function enginePartToAnthropic(part, builderGateway, toolNameMap) {
     switch (part.type) {
         case "text":
             return { type: "text", text: part.text };
@@ -339,24 +341,19 @@ function enginePartToAnthropic(part, builderGateway) {
             return {
                 type: "tool_use",
                 id: part.id,
-                name: part.name,
+                name: toProviderToolName(part.name, toolNameMap),
                 input: part.input,
             }; // tool_use is a ContentBlockParam in Anthropic SDK
         case "tool-result": {
             if (builderGateway) {
-                const tool_name = part.toolName.trim();
+                const tool_name = toProviderToolName(part.toolName.trim(), toolNameMap);
                 const tool_input = part.toolInput;
-                // Gateway degrade: the Builder gateway multiplexes to non-Anthropic
-                // models whose tool_result handling is string-only, so images are
-                // dropped here. The content string already carries a `[image: …]`
-                // note per image (appended by runToolCall), so the model still knows
-                // an image existed and any https URL survives.
                 return {
                     type: "tool_result",
                     tool_use_id: part.toolCallId,
                     tool_name,
                     tool_input,
-                    content: part.content,
+                    content: toolResultContentToAnthropic(part),
                     ...(part.isError ? { is_error: true } : {}),
                 };
             }
@@ -417,7 +414,7 @@ function toolResultContentToAnthropic(part) {
 // ---------------------------------------------------------------------------
 // Anthropic.ContentBlock → EngineContentPart (from final message)
 // ---------------------------------------------------------------------------
-export function anthropicContentToEngine(content) {
+export function anthropicContentToEngine(content, toolNameMap) {
     return content
         .map((block) => {
         if (block.type === "text") {
@@ -427,7 +424,7 @@ export function anthropicContentToEngine(content) {
             return {
                 type: "tool-call",
                 id: block.id,
-                name: block.name,
+                name: toEngineToolName(block.name, toolNameMap),
                 input: block.input,
             };
         }
@@ -471,13 +468,15 @@ export function createAnthropicChunkStreamState() {
  * the engine, so omitting `state` simply drops the progress events without
  * changing tool dispatch.
  */
-export function anthropicChunkToEngineEvents(chunk, state) {
+export function anthropicChunkToEngineEvents(chunk, state, toolNameMap) {
     const events = [];
     if (chunk.type === "content_block_start") {
         const block = chunk.content_block;
         if (block?.type === "tool_use") {
             const id = typeof block.id === "string" ? block.id : undefined;
-            const name = typeof block.name === "string" ? block.name : undefined;
+            const name = typeof block.name === "string"
+                ? toEngineToolName(block.name, toolNameMap)
+                : undefined;
             if (state && typeof chunk.index === "number" && id && name) {
                 state.toolUseByIndex.set(chunk.index, { id, name });
             }

package/dist/agent/production-agent.js

@@ -1895,7 +1895,7 @@ function seedReadOnlyToolResultsFromJournal(journal, actions) {
         })) {
             continue;
         }
-        cache.set(toolCallCacheKey(entry.tool, entry.input), result);
+        cache.set(toolCallCacheKey(entry.tool, entry.input), { content: result });
     }
     return cache;
 }
@@ -1945,7 +1945,10 @@ function seedReadOnlyToolResultsFromHistory(messages, actions, seed) {
                 continue;
             if (!isReusableReadOnlyToolResult(part))
                 continue;
-            cache.set(toolCallCacheKey(call.name, call.input), part.content);
+            cache.set(toolCallCacheKey(call.name, call.input), {
+                content: part.content,
+                ...(part.images?.length ? { images: part.images } : {}),
+            });
         }
     }
     return cache;
@@ -2024,6 +2027,12 @@ function isReusableReadOnlyToolResult(part) {
     const lower = part.content.trim().toLowerCase();
     if (!lower)
         return false;
+    // The ledger persists only the note, not image bytes. Re-execute an image
+    // read when its payload is unavailable so a continuation can restore vision.
+    if (!part.images?.length &&
+        /\[image(?:\s+#\d+|\s*:)[^\n\]]*\battached(?:\s+#\d+|:)[^\n\]]*\]/i.test(part.content)) {
+        return false;
+    }
     return !(lower.startsWith("skipped duplicate read-only call to ") ||
         lower.startsWith("invalid action parameters for ") ||
         lower.startsWith("error running ") ||
@@ -4701,8 +4710,11 @@ export async function runAgentLoop(opts) {
                 const cacheKey = actionEntry.readOnly === true && actionEntry.dedupe !== false
                     ? toolCallCacheKey(toolCall.name, toolCall.input)
                     : null;
-                if (cacheKey && readOnlyToolResultCache.has(cacheKey)) {
-                    const previousResult = readOnlyToolResultCache.get(cacheKey) ?? "";
+                const cachedResult = cacheKey
+                    ? readOnlyToolResultCache.get(cacheKey)
+                    : undefined;
+                if (cacheKey && cachedResult) {
+                    const previousResult = cachedResult.content;
                     // `contextMessages` (not `messages`) is what the model actually sees
                     // this iteration — context-xray eviction/summarization and
                     // observational-memory trimming can drop the earlier result from
@@ -4744,6 +4756,9 @@ export async function runAgentLoop(opts) {
                         toolName: toolCall.name,
                         toolInput: wireToolInput,
                         content: result,
+                        ...(cachedResult.images?.length
+                            ? { images: cachedResult.images }
+                            : {}),
                     };
                 }
                 if (opts.executionMode === "plan" &&
@@ -5006,7 +5021,10 @@ export async function runAgentLoop(opts) {
                 if (!isError) {
                     noteToolCallSucceeded(actionEntry);
                     if (cacheKey) {
-                        readOnlyToolResultCache.set(cacheKey, result);
+                        readOnlyToolResultCache.set(cacheKey, {
+                            content: result,
+                            ...(toolResultImages?.length ? { images: toolResultImages } : {}),
+                        });
                     }
                     else if (actionEntry.readOnly !== true) {
                         // A genuine write invalidates all cached reads. A dedupe:false

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/extensions/fetch-tool.js

@@ -9,10 +9,44 @@
  * Values are resolved server-side AFTER the model emits the tool call —
  * the raw secret never enters the model's context.
  */
-import { collectSecretValues, MAX_EXTENSION_PROXY_RESPONSE_SIZE, normalizeExtensionProxyMethod, readResponseTextWithLimit, redactSecrets, redactString, sanitizeOutboundHeaders, } from "./proxy-security.js";
+import { collectSecretValues, MAX_EXTENSION_PROXY_RESPONSE_SIZE, normalizeExtensionProxyMethod, readResponseBytesWithLimit, readResponseTextWithLimit, redactSecrets, redactString, sanitizeOutboundHeaders, } from "./proxy-security.js";
 import { createSsrfSafeDispatcher, isBlockedExtensionUrlWithDns, } from "./url-safety.js";
 import { formatWebContentResult, parseWebContentSearchOptions, processWebContent, } from "./web-content.js";
 const DEFAULT_TIMEOUT_MS = 15_000;
+const VISION_IMAGE_CONTENT_TYPES = new Set([
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+]);
+const CREDENTIAL_NAME_RE = /(?:^|[-_])(access[-_]?token|api[-_]?key|auth(?:orization)?|credential|expires?|key[-_]?pair[-_]?id|key|password|passwd|policy|secret|session|signature|sig|token|jwt|assertion)(?:$|[-_])/i;
+function uint8ArrayToBase64(bytes) {
+    if (typeof Buffer !== "undefined")
+        return Buffer.from(bytes).toString("base64");
+    let binary = "";
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        binary += String.fromCharCode(...bytes.subarray(i, Math.min(i + chunkSize, bytes.length)));
+    }
+    return btoa(binary);
+}
+function hasCredentialBearingImageRequest(url, headers) {
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(url);
+    }
+    catch {
+        return true;
+    }
+    if (parsedUrl.username || parsedUrl.password)
+        return true;
+    if (parsedUrl.hash)
+        return true;
+    if (Object.keys(headers).some((name) => CREDENTIAL_NAME_RE.test(name.replace(/([a-z])([A-Z])/g, "$1-$2")))) {
+        return true;
+    }
+    return [...parsedUrl.searchParams.keys()].some((name) => CREDENTIAL_NAME_RE.test(name.replace(/([a-z])([A-Z])/g, "$1-$2")));
+}
 /**
  * Headers that mimic a current Chrome on macOS so anti-bot middleware (Cloudflare,
  * PerimeterX, Akamai) treats the request as a real user. We only fill in fields
@@ -84,7 +118,7 @@ export function createFetchToolEntry(opts = {}) {
                         },
                         responseMode: {
                             type: "string",
-                            description: "How to return the response. Default: auto (HTML pages become clean markdown; JSON/text stays raw). Use raw for exact bytes, markdown/text for extracted readable content, links for just links, metadata for page metadata, or matches with search.",
+                            description: "How to return the response. Default: auto (HTML pages become clean markdown; JSON/text stays raw; successful public image responses are attached as vision context). Use raw for exact bytes, markdown/text for extracted readable content, links for just links, metadata for page metadata, or matches with search.",
                             enum: [
                                 "auto",
                                 "raw",
@@ -261,10 +295,46 @@ export function createFetchToolEntry(opts = {}) {
                         }
                         return `HTTP ${response.status} ${response.statusText}\n\nRedirect: ${redirectUrl ? redactString(redirectUrl, secretValues) : "(none)"}`;
                     }
-                    // Check if caller wants to save to workspace file (before truncation).
+                    const contentType = response.headers.get("content-type")?.split(";")[0].trim() ??
+                        "text/plain";
+                    // A fetched image is useful as model context, not as text decoded
+                    // from arbitrary bytes. Pass bounded bytes through the well-known
+                    // result-image field so vision providers never refetch this URL.
                     const saveToFilePath = typeof args.saveToFile === "string"
                         ? args.saveToFile.trim()
                         : "";
+                    const hasCredentials = allUsedKeys.length > 0 ||
+                        hasCredentialBearingImageRequest(resolvedUrl, headers);
+                    if (!saveToFilePath &&
+                        method === "GET" &&
+                        response.ok &&
+                        VISION_IMAGE_CONTENT_TYPES.has(contentType.toLowerCase()) &&
+                        resolvedUrl.startsWith("https://") &&
+                        !hasCredentials) {
+                        const imageBody = await readResponseBytesWithLimit(response, MAX_EXTENSION_PROXY_RESPONSE_SIZE);
+                        if (imageBody.truncated) {
+                            return `HTTP ${response.status} ${response.statusText}\n\nContent-Type: ${contentType}\n\nImage response too large to attach (${imageBody.size} bytes, max ${MAX_EXTENSION_PROXY_RESPONSE_SIZE}).`;
+                        }
+                        console.log("[fetch-tool] " +
+                            method +
+                            " image → " +
+                            response.status +
+                            " (" +
+                            elapsed +
+                            "ms, vision image)");
+                        return {
+                            status: response.status,
+                            statusText: response.statusText,
+                            contentType,
+                            url: resolvedUrl,
+                            _agentImages: [
+                                {
+                                    data: uint8ArrayToBase64(imageBody.bytes),
+                                    mediaType: contentType.toLowerCase(),
+                                },
+                            ],
+                        };
+                    }
                     let body;
                     try {
                         // When saving to file allow larger reads (20MB), otherwise cap at proxy limit.
@@ -278,8 +348,6 @@ export function createFetchToolEntry(opts = {}) {
                         body = "(could not read response body)";
                     }
                     body = redactString(body, secretValues);
-                    const contentType = response.headers.get("content-type")?.split(";")[0].trim() ??
-                        "text/plain";
                     let displayBody;
                     let processedMode = "raw";
                     try {

package/dist/extensions/proxy-security.d.ts

@@ -4,6 +4,11 @@ export declare function sanitizeOutboundHeaders(value: unknown): Record<string,
 export declare function collectSecretValues(...groups: Array<Array<string> | undefined>): string[];
 export declare function redactSecrets<T>(value: T, secretValues: string[]): T;
 export declare function redactString(text: string, secretValues: string[]): string;
+export declare function readResponseBytesWithLimit(response: Response, maxBytes?: number): Promise<{
+    bytes: Uint8Array;
+    truncated: boolean;
+    size: number;
+}>;
 export declare function readResponseTextWithLimit(response: Response, maxBytes?: number): Promise<{
     text: string;
     truncated: boolean;

package/dist/extensions/proxy-security.js

@@ -99,11 +99,12 @@ function redactionCandidates(secret) {
     catch { }
     return [...candidates].sort((a, b) => b.length - a.length);
 }
-export async function readResponseTextWithLimit(response, maxBytes = MAX_EXTENSION_PROXY_RESPONSE_SIZE) {
+export async function readResponseBytesWithLimit(response, maxBytes = MAX_EXTENSION_PROXY_RESPONSE_SIZE) {
     const contentLength = response.headers.get("content-length");
     if (contentLength && Number(contentLength) > maxBytes) {
+        await response.body?.cancel().catch(() => { });
         return {
-            text: `(response too large - ${contentLength} bytes, max ${maxBytes})`,
+            bytes: new Uint8Array(),
             truncated: true,
             size: Number(contentLength),
         };
@@ -113,13 +114,13 @@ export async function readResponseTextWithLimit(response, maxBytes = MAX_EXTENSI
         const buffer = await response.arrayBuffer();
         if (buffer.byteLength > maxBytes) {
             return {
-                text: `(response truncated - ${buffer.byteLength} bytes, max ${maxBytes})`,
+                bytes: new Uint8Array(),
                 truncated: true,
                 size: buffer.byteLength,
             };
         }
         return {
-            text: new TextDecoder().decode(buffer),
+            bytes: new Uint8Array(buffer),
             truncated: false,
             size: buffer.byteLength,
         };
@@ -135,23 +136,30 @@ export async function readResponseTextWithLimit(response, maxBytes = MAX_EXTENSI
         total += value.byteLength;
         if (total > maxBytes) {
             await reader.cancel().catch(() => { });
-            return {
-                text: `(response truncated - ${total} bytes, max ${maxBytes})`,
-                truncated: true,
-                size: total,
-            };
+            return { bytes: new Uint8Array(), truncated: true, size: total };
         }
         chunks.push(value);
     }
-    const buffer = new Uint8Array(total);
+    const bytes = new Uint8Array(total);
     let offset = 0;
     for (const chunk of chunks) {
-        buffer.set(chunk, offset);
+        bytes.set(chunk, offset);
         offset += chunk.byteLength;
     }
+    return { bytes, truncated: false, size: total };
+}
+export async function readResponseTextWithLimit(response, maxBytes = MAX_EXTENSION_PROXY_RESPONSE_SIZE) {
+    const result = await readResponseBytesWithLimit(response, maxBytes);
+    if (result.truncated) {
+        const contentLength = response.headers.get("content-length");
+        const text = contentLength && Number(contentLength) > maxBytes
+            ? `(response too large - ${contentLength} bytes, max ${maxBytes})`
+            : `(response truncated - ${result.size} bytes, max ${maxBytes})`;
+        return { text, truncated: true, size: result.size };
+    }
     return {
-        text: new TextDecoder().decode(buffer),
+        text: new TextDecoder().decode(result.bytes),
         truncated: false,
-        size: total,
+        size: result.size,
     };
 }