@gguf/claw 2026.2.1 → 2026.2.3

package/dist/media-understanding/apply.js

@@ -2,10 +2,10 @@ import path from "node:path";
 import { finalizeInboundContext } from "../auto-reply/reply/inbound-context.js";
 import { logVerbose, shouldLogVerbose } from "../globals.js";
 import { DEFAULT_INPUT_FILE_MAX_BYTES, DEFAULT_INPUT_FILE_MAX_CHARS, DEFAULT_INPUT_FILE_MIMES, DEFAULT_INPUT_MAX_REDIRECTS, DEFAULT_INPUT_PDF_MAX_PAGES, DEFAULT_INPUT_PDF_MAX_PIXELS, DEFAULT_INPUT_PDF_MIN_TEXT_CHARS, DEFAULT_INPUT_TIMEOUT_MS, extractFileContentFromSource, normalizeMimeList, normalizeMimeType, } from "../media/input-files.js";
-import { extractMediaUserText, formatAudioTranscripts, formatMediaUnderstandingBody, } from "./format.js";
+import { resolveAttachmentKind } from "./attachments.js";
 import { runWithConcurrency } from "./concurrency.js";
+import { extractMediaUserText, formatAudioTranscripts, formatMediaUnderstandingBody, } from "./format.js";
 import { resolveConcurrency } from "./resolve.js";
-import { resolveAttachmentKind } from "./attachments.js";
 import { buildProviderRegistry, createMediaAttachmentCache, normalizeMediaAttachments, runCapability, } from "./runner.js";
 const CAPABILITY_ORDER = ["image", "audio", "video"];
 const EXTRA_TEXT_MIMES = [
@@ -46,11 +46,27 @@ const XML_ESCAPE_MAP = {
 function xmlEscapeAttr(value) {
     return value.replace(/[<>&"']/g, (char) => XML_ESCAPE_MAP[char] ?? char);
 }
+function escapeFileBlockContent(value) {
+    return value.replace(/<\s*\/\s*file\s*>/gi, "&lt;/file&gt;").replace(/<\s*file\b/gi, "&lt;file");
+}
+function sanitizeMimeType(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed) {
+        return undefined;
+    }
+    const match = trimmed.match(/^([a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+)/);
+    return match?.[1];
+}
 function resolveFileLimits(cfg) {
     const files = cfg.gateway?.http?.endpoints?.responses?.files;
+    const allowedMimesConfigured = Boolean(files?.allowedMimes && files.allowedMimes.length > 0);
     return {
         allowUrl: files?.allowUrl ?? true,
         allowedMimes: normalizeMimeList(files?.allowedMimes, DEFAULT_INPUT_FILE_MIMES),
+        allowedMimesConfigured,
         maxBytes: files?.maxBytes ?? DEFAULT_INPUT_FILE_MAX_BYTES,
         maxChars: files?.maxChars ?? DEFAULT_INPUT_FILE_MAX_CHARS,
         maxRedirects: files?.maxRedirects ?? DEFAULT_INPUT_MAX_REDIRECTS,
@@ -86,42 +102,124 @@ function resolveUtf16Charset(buffer) {
         return "utf-16be";
     }
     const sampleLen = Math.min(buffer.length, 2048);
-    let zeroCount = 0;
+    let zeroEven = 0;
+    let zeroOdd = 0;
     for (let i = 0; i < sampleLen; i += 1) {
-        if (buffer[i] === 0) {
-            zeroCount += 1;
+        if (buffer[i] !== 0) {
+            continue;
+        }
+        if (i % 2 === 0) {
+            zeroEven += 1;
+        }
+        else {
+            zeroOdd += 1;
         }
     }
+    const zeroCount = zeroEven + zeroOdd;
     if (zeroCount / sampleLen > 0.2) {
-        return "utf-16le";
+        return zeroOdd >= zeroEven ? "utf-16le" : "utf-16be";
     }
     return undefined;
 }
-function looksLikeUtf8Text(buffer) {
-    if (!buffer || buffer.length === 0) {
-        return false;
+const WORDISH_CHAR = /[\p{L}\p{N}]/u;
+const CP1252_MAP = [
+    "\u20ac",
+    undefined,
+    "\u201a",
+    "\u0192",
+    "\u201e",
+    "\u2026",
+    "\u2020",
+    "\u2021",
+    "\u02c6",
+    "\u2030",
+    "\u0160",
+    "\u2039",
+    "\u0152",
+    undefined,
+    "\u017d",
+    undefined,
+    undefined,
+    "\u2018",
+    "\u2019",
+    "\u201c",
+    "\u201d",
+    "\u2022",
+    "\u2013",
+    "\u2014",
+    "\u02dc",
+    "\u2122",
+    "\u0161",
+    "\u203a",
+    "\u0153",
+    undefined,
+    "\u017e",
+    "\u0178",
+];
+function decodeLegacyText(buffer) {
+    let output = "";
+    for (const byte of buffer) {
+        if (byte >= 0x80 && byte <= 0x9f) {
+            const mapped = CP1252_MAP[byte - 0x80];
+            output += mapped ?? String.fromCharCode(byte);
+            continue;
+        }
+        output += String.fromCharCode(byte);
+    }
+    return output;
+}
+function getTextStats(text) {
+    if (!text) {
+        return { printableRatio: 0, wordishRatio: 0 };
     }
-    const sampleLen = Math.min(buffer.length, 4096);
     let printable = 0;
-    let other = 0;
-    for (let i = 0; i < sampleLen; i += 1) {
-        const byte = buffer[i];
-        if (byte === 0) {
-            other += 1;
+    let control = 0;
+    let wordish = 0;
+    for (const char of text) {
+        const code = char.codePointAt(0) ?? 0;
+        if (code === 9 || code === 10 || code === 13 || code === 32) {
+            printable += 1;
+            wordish += 1;
             continue;
         }
-        if (byte === 9 || byte === 10 || byte === 13 || (byte >= 32 && byte <= 126)) {
-            printable += 1;
+        if (code < 32 || (code >= 0x7f && code <= 0x9f)) {
+            control += 1;
+            continue;
         }
-        else {
-            other += 1;
+        printable += 1;
+        if (WORDISH_CHAR.test(char)) {
+            wordish += 1;
         }
     }
-    const total = printable + other;
+    const total = printable + control;
     if (total === 0) {
+        return { printableRatio: 0, wordishRatio: 0 };
+    }
+    return { printableRatio: printable / total, wordishRatio: wordish / total };
+}
+function isMostlyPrintable(text) {
+    return getTextStats(text).printableRatio > 0.85;
+}
+function looksLikeLegacyTextBytes(buffer) {
+    if (buffer.length === 0) {
         return false;
     }
-    return printable / total > 0.85;
+    const text = decodeLegacyText(buffer);
+    const { printableRatio, wordishRatio } = getTextStats(text);
+    return printableRatio > 0.95 && wordishRatio > 0.3;
+}
+function looksLikeUtf8Text(buffer) {
+    if (!buffer || buffer.length === 0) {
+        return false;
+    }
+    const sample = buffer.subarray(0, Math.min(buffer.length, 4096));
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(sample);
+        return isMostlyPrintable(text);
+    }
+    catch {
+        return looksLikeLegacyTextBytes(sample);
+    }
 }
 function decodeTextSample(buffer) {
     if (!buffer || buffer.length === 0) {
@@ -164,8 +262,14 @@ function resolveTextMimeFromName(name) {
     const ext = path.extname(name).toLowerCase();
     return TEXT_EXT_MIME.get(ext);
 }
+function isBinaryMediaMime(mime) {
+    if (!mime) {
+        return false;
+    }
+    return mime.startsWith("image/") || mime.startsWith("audio/") || mime.startsWith("video/");
+}
 async function extractFileBlocks(params) {
-    const { attachments, cache, limits } = params;
+    const { attachments, cache, limits, skipAttachmentIndexes } = params;
     if (!attachments || attachments.length === 0) {
         return [];
     }
@@ -174,9 +278,12 @@ async function extractFileBlocks(params) {
         if (!attachment) {
             continue;
         }
+        if (skipAttachmentIndexes?.has(attachment.index)) {
+            continue;
+        }
         const forcedTextMime = resolveTextMimeFromName(attachment.path ?? attachment.url ?? "");
         const kind = forcedTextMime ? "document" : resolveAttachmentKind(attachment);
-        if (!forcedTextMime && (kind === "image" || kind === "video")) {
+        if (!forcedTextMime && (kind === "image" || kind === "video" || kind === "audio")) {
             continue;
         }
         if (!limits.allowUrl && attachment.url && !attachment.path) {
@@ -201,16 +308,17 @@ async function extractFileBlocks(params) {
         }
         const nameHint = bufferResult?.fileName ?? attachment.path ?? attachment.url;
         const forcedTextMimeResolved = forcedTextMime ?? resolveTextMimeFromName(nameHint ?? "");
+        const rawMime = bufferResult?.mime ?? attachment.mime;
+        const normalizedRawMime = normalizeMimeType(rawMime);
+        if (!forcedTextMimeResolved && isBinaryMediaMime(normalizedRawMime)) {
+            continue;
+        }
         const utf16Charset = resolveUtf16Charset(bufferResult?.buffer);
         const textSample = decodeTextSample(bufferResult?.buffer);
         const textLike = Boolean(utf16Charset) || looksLikeUtf8Text(bufferResult?.buffer);
-        if (!forcedTextMimeResolved && kind === "audio" && !textLike) {
-            continue;
-        }
         const guessedDelimited = textLike ? guessDelimitedMime(textSample) : undefined;
         const textHint = forcedTextMimeResolved ?? guessedDelimited ?? (textLike ? "text/plain" : undefined);
-        const rawMime = bufferResult?.mime ?? attachment.mime;
-        const mimeType = textHint ?? normalizeMimeType(rawMime);
+        const mimeType = sanitizeMimeType(textHint ?? normalizeMimeType(rawMime));
         // Log when MIME type is overridden from non-text to text for auditability
         if (textHint && rawMime && !rawMime.startsWith("text/")) {
             logVerbose(`media: MIME override from "${rawMime}" to "${textHint}" for index=${attachment.index}`);
@@ -222,11 +330,13 @@ async function extractFileBlocks(params) {
             continue;
         }
         const allowedMimes = new Set(limits.allowedMimes);
-        for (const extra of EXTRA_TEXT_MIMES) {
-            allowedMimes.add(extra);
-        }
-        if (mimeType.startsWith("text/")) {
-            allowedMimes.add(mimeType);
+        if (!limits.allowedMimesConfigured) {
+            for (const extra of EXTRA_TEXT_MIMES) {
+                allowedMimes.add(extra);
+            }
+            if (mimeType.startsWith("text/")) {
+                allowedMimes.add(mimeType);
+            }
         }
         if (!allowedMimes.has(mimeType)) {
             if (shouldLogVerbose()) {
@@ -237,6 +347,7 @@ async function extractFileBlocks(params) {
         let extracted;
         try {
             const mediaType = utf16Charset ? `${mimeType}; charset=${utf16Charset}` : mimeType;
+            const { allowedMimesConfigured: _allowedMimesConfigured, ...baseLimits } = limits;
             extracted = await extractFileContentFromSource({
                 source: {
                     type: "base64",
@@ -245,7 +356,7 @@ async function extractFileBlocks(params) {
                     filename: bufferResult.fileName,
                 },
                 limits: {
-                    ...limits,
+                    ...baseLimits,
                     allowedMimes,
                 },
             });
@@ -270,7 +381,7 @@ async function extractFileBlocks(params) {
             .replace(/[\r\n\t]+/g, " ")
             .trim();
         // Escape XML special characters in attributes to prevent injection
-        blocks.push(`<file name="${xmlEscapeAttr(safeName)}" mime="${xmlEscapeAttr(mimeType)}">\n${blockText}\n</file>`);
+        blocks.push(`<file name="${xmlEscapeAttr(safeName)}" mime="${xmlEscapeAttr(mimeType)}">\n${escapeFileBlockContent(blockText)}\n</file>`);
     }
     return blocks;
 }
@@ -284,11 +395,6 @@ export async function applyMediaUnderstanding(params) {
     const providerRegistry = buildProviderRegistry(params.providers);
     const cache = createMediaAttachmentCache(attachments);
     try {
-        const fileBlocks = await extractFileBlocks({
-            attachments,
-            cache,
-            limits: resolveFileLimits(cfg),
-        });
         const tasks = CAPABILITY_ORDER.map((capability) => async () => {
             const config = cfg.tools?.media?.[capability];
             return await runCapability({
@@ -339,13 +445,22 @@ export async function applyMediaUnderstanding(params) {
             }
             ctx.MediaUnderstanding = [...(ctx.MediaUnderstanding ?? []), ...outputs];
         }
+        const audioAttachmentIndexes = new Set(outputs
+            .filter((output) => output.kind === "audio.transcription")
+            .map((output) => output.attachmentIndex));
+        const fileBlocks = await extractFileBlocks({
+            attachments,
+            cache,
+            limits: resolveFileLimits(cfg),
+            skipAttachmentIndexes: audioAttachmentIndexes.size > 0 ? audioAttachmentIndexes : undefined,
+        });
         if (fileBlocks.length > 0) {
             ctx.Body = appendFileBlocks(ctx.Body, fileBlocks);
         }
         if (outputs.length > 0 || fileBlocks.length > 0) {
             finalizeInboundContext(ctx, {
                 forceBodyForAgent: true,
-                forceBodyForCommands: outputs.length > 0,
+                forceBodyForCommands: outputs.length > 0 || fileBlocks.length > 0,
             });
         }
         return {

package/dist/media-understanding/attachments.js

@@ -3,11 +3,11 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { logVerbose, shouldLogVerbose } from "../globals.js";
 import { fetchRemoteMedia, MediaFetchError } from "../media/fetch.js";
 import { detectMime, getFileExtension, isAudioFileName, kindFromMime } from "../media/mime.js";
-import { logVerbose, shouldLogVerbose } from "../globals.js";
-import { fetchWithTimeout } from "./providers/shared.js";
 import { MediaUnderstandingSkipError } from "./errors.js";
+import { fetchWithTimeout } from "./providers/shared.js";
 const DEFAULT_MAX_ATTACHMENTS = 1;
 function normalizeAttachmentPath(raw) {
     const value = raw?.trim();

package/dist/media-understanding/providers/deepgram/audio.js

@@ -1,4 +1,4 @@
-import { fetchWithTimeout, normalizeBaseUrl, readErrorResponse } from "../shared.js";
+import { fetchWithTimeoutGuarded, normalizeBaseUrl, readErrorResponse } from "../shared.js";
 export const DEFAULT_DEEPGRAM_AUDIO_BASE_URL = "https://api.deepgram.com/v1";
 export const DEFAULT_DEEPGRAM_AUDIO_MODEL = "nova-3";
 function resolveModel(model) {
@@ -8,6 +8,7 @@ function resolveModel(model) {
 export async function transcribeDeepgramAudio(params) {
     const fetchFn = params.fetchFn ?? fetch;
     const baseUrl = normalizeBaseUrl(params.baseUrl, DEFAULT_DEEPGRAM_AUDIO_BASE_URL);
+    const allowPrivate = Boolean(params.baseUrl?.trim());
     const model = resolveModel(params.model);
     const url = new URL(`${baseUrl}/listen`);
     url.searchParams.set("model", model);
@@ -30,20 +31,25 @@ export async function transcribeDeepgramAudio(params) {
         headers.set("content-type", params.mime ?? "application/octet-stream");
     }
     const body = new Uint8Array(params.buffer);
-    const res = await fetchWithTimeout(url.toString(), {
+    const { response: res, release } = await fetchWithTimeoutGuarded(url.toString(), {
         method: "POST",
         headers,
         body,
-    }, params.timeoutMs, fetchFn);
-    if (!res.ok) {
-        const detail = await readErrorResponse(res);
-        const suffix = detail ? `: ${detail}` : "";
-        throw new Error(`Audio transcription failed (HTTP ${res.status})${suffix}`);
+    }, params.timeoutMs, fetchFn, allowPrivate ? { ssrfPolicy: { allowPrivateNetwork: true } } : undefined);
+    try {
+        if (!res.ok) {
+            const detail = await readErrorResponse(res);
+            const suffix = detail ? `: ${detail}` : "";
+            throw new Error(`Audio transcription failed (HTTP ${res.status})${suffix}`);
+        }
+        const payload = (await res.json());
+        const transcript = payload.results?.channels?.[0]?.alternatives?.[0]?.transcript?.trim();
+        if (!transcript) {
+            throw new Error("Audio transcription response missing transcript");
+        }
+        return { text: transcript, model };
     }
-    const payload = (await res.json());
-    const transcript = payload.results?.channels?.[0]?.alternatives?.[0]?.transcript?.trim();
-    if (!transcript) {
-        throw new Error("Audio transcription response missing transcript");
+    finally {
+        await release();
     }
-    return { text: transcript, model };
 }

package/dist/media-understanding/providers/google/audio.js

@@ -1,5 +1,5 @@
 import { normalizeGoogleModelId } from "../../../agents/models-config.providers.js";
-import { fetchWithTimeout, normalizeBaseUrl, readErrorResponse } from "../shared.js";
+import { fetchWithTimeoutGuarded, normalizeBaseUrl, readErrorResponse } from "../shared.js";
 export const DEFAULT_GOOGLE_AUDIO_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 const DEFAULT_GOOGLE_AUDIO_MODEL = "gemini-3-flash-preview";
 const DEFAULT_GOOGLE_AUDIO_PROMPT = "Transcribe the audio.";
@@ -17,6 +17,7 @@ function resolvePrompt(prompt) {
 export async function transcribeGeminiAudio(params) {
     const fetchFn = params.fetchFn ?? fetch;
     const baseUrl = normalizeBaseUrl(params.baseUrl, DEFAULT_GOOGLE_AUDIO_BASE_URL);
+    const allowPrivate = Boolean(params.baseUrl?.trim());
     const model = resolveModel(params.model);
     const url = `${baseUrl}/models/${model}:generateContent`;
     const headers = new Headers(params.headers);
@@ -42,24 +43,29 @@ export async function transcribeGeminiAudio(params) {
             },
         ],
     };
-    const res = await fetchWithTimeout(url, {
+    const { response: res, release } = await fetchWithTimeoutGuarded(url, {
         method: "POST",
         headers,
         body: JSON.stringify(body),
-    }, params.timeoutMs, fetchFn);
-    if (!res.ok) {
-        const detail = await readErrorResponse(res);
-        const suffix = detail ? `: ${detail}` : "";
-        throw new Error(`Audio transcription failed (HTTP ${res.status})${suffix}`);
+    }, params.timeoutMs, fetchFn, allowPrivate ? { ssrfPolicy: { allowPrivateNetwork: true } } : undefined);
+    try {
+        if (!res.ok) {
+            const detail = await readErrorResponse(res);
+            const suffix = detail ? `: ${detail}` : "";
+            throw new Error(`Audio transcription failed (HTTP ${res.status})${suffix}`);
+        }
+        const payload = (await res.json());
+        const parts = payload.candidates?.[0]?.content?.parts ?? [];
+        const text = parts
+            .map((part) => part?.text?.trim())
+            .filter(Boolean)
+            .join("\n");
+        if (!text) {
+            throw new Error("Audio transcription response missing text");
+        }
+        return { text, model };
     }
-    const payload = (await res.json());
-    const parts = payload.candidates?.[0]?.content?.parts ?? [];
-    const text = parts
-        .map((part) => part?.text?.trim())
-        .filter(Boolean)
-        .join("\n");
-    if (!text) {
-        throw new Error("Audio transcription response missing text");
+    finally {
+        await release();
     }
-    return { text, model };
 }

package/dist/media-understanding/providers/google/video.js

@@ -1,5 +1,5 @@
 import { normalizeGoogleModelId } from "../../../agents/models-config.providers.js";
-import { fetchWithTimeout, normalizeBaseUrl, readErrorResponse } from "../shared.js";
+import { fetchWithTimeoutGuarded, normalizeBaseUrl, readErrorResponse } from "../shared.js";
 export const DEFAULT_GOOGLE_VIDEO_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 const DEFAULT_GOOGLE_VIDEO_MODEL = "gemini-3-flash-preview";
 const DEFAULT_GOOGLE_VIDEO_PROMPT = "Describe the video.";
@@ -17,6 +17,7 @@ function resolvePrompt(prompt) {
 export async function describeGeminiVideo(params) {
     const fetchFn = params.fetchFn ?? fetch;
     const baseUrl = normalizeBaseUrl(params.baseUrl, DEFAULT_GOOGLE_VIDEO_BASE_URL);
+    const allowPrivate = Boolean(params.baseUrl?.trim());
     const model = resolveModel(params.model);
     const url = `${baseUrl}/models/${model}:generateContent`;
     const headers = new Headers(params.headers);
@@ -42,24 +43,29 @@ export async function describeGeminiVideo(params) {
             },
         ],
     };
-    const res = await fetchWithTimeout(url, {
+    const { response: res, release } = await fetchWithTimeoutGuarded(url, {
         method: "POST",
         headers,
         body: JSON.stringify(body),
-    }, params.timeoutMs, fetchFn);
-    if (!res.ok) {
-        const detail = await readErrorResponse(res);
-        const suffix = detail ? `: ${detail}` : "";
-        throw new Error(`Video description failed (HTTP ${res.status})${suffix}`);
+    }, params.timeoutMs, fetchFn, allowPrivate ? { ssrfPolicy: { allowPrivateNetwork: true } } : undefined);
+    try {
+        if (!res.ok) {
+            const detail = await readErrorResponse(res);
+            const suffix = detail ? `: ${detail}` : "";
+            throw new Error(`Video description failed (HTTP ${res.status})${suffix}`);
+        }
+        const payload = (await res.json());
+        const parts = payload.candidates?.[0]?.content?.parts ?? [];
+        const text = parts
+            .map((part) => part?.text?.trim())
+            .filter(Boolean)
+            .join("\n");
+        if (!text) {
+            throw new Error("Video description response missing text");
+        }
+        return { text, model };
     }
-    const payload = (await res.json());
-    const parts = payload.candidates?.[0]?.content?.parts ?? [];
-    const text = parts
-        .map((part) => part?.text?.trim())
-        .filter(Boolean)
-        .join("\n");
-    if (!text) {
-        throw new Error("Video description response missing text");
+    finally {
+        await release();
     }
-    return { text, model };
 }

package/dist/media-understanding/providers/image.js

@@ -1,8 +1,8 @@
 import { complete } from "@mariozechner/pi-ai";
-import { discoverAuthStorage, discoverModels } from "../../agents/pi-model-discovery.js";
+import { minimaxUnderstandImage } from "../../agents/minimax-vlm.js";
 import { getApiKeyForModel, requireApiKey } from "../../agents/model-auth.js";
 import { ensureOpenClawModelsJson } from "../../agents/models-config.js";
-import { minimaxUnderstandImage } from "../../agents/minimax-vlm.js";
+import { discoverAuthStorage, discoverModels } from "../../agents/pi-model-discovery.js";
 import { coerceImageAssistantText } from "../../agents/tools/image-tool.helpers.js";
 export async function describeImageWithModel(params) {
     await ensureOpenClawModelsJson(params.cfg, params.agentDir);

package/dist/media-understanding/providers/openai/audio.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { fetchWithTimeout, normalizeBaseUrl, readErrorResponse } from "../shared.js";
+import { fetchWithTimeoutGuarded, normalizeBaseUrl, readErrorResponse } from "../shared.js";
 export const DEFAULT_OPENAI_AUDIO_BASE_URL = "https://api.openai.com/v1";
 const DEFAULT_OPENAI_AUDIO_MODEL = "gpt-4o-mini-transcribe";
 function resolveModel(model) {
@@ -9,6 +9,7 @@ function resolveModel(model) {
 export async function transcribeOpenAiCompatibleAudio(params) {
     const fetchFn = params.fetchFn ?? fetch;
     const baseUrl = normalizeBaseUrl(params.baseUrl, DEFAULT_OPENAI_AUDIO_BASE_URL);
+    const allowPrivate = Boolean(params.baseUrl?.trim());
     const url = `${baseUrl}/audio/transcriptions`;
     const model = resolveModel(params.model);
     const form = new FormData();
@@ -29,20 +30,25 @@ export async function transcribeOpenAiCompatibleAudio(params) {
     if (!headers.has("authorization")) {
         headers.set("authorization", `Bearer ${params.apiKey}`);
     }
-    const res = await fetchWithTimeout(url, {
+    const { response: res, release } = await fetchWithTimeoutGuarded(url, {
         method: "POST",
         headers,
         body: form,
-    }, params.timeoutMs, fetchFn);
-    if (!res.ok) {
-        const detail = await readErrorResponse(res);
-        const suffix = detail ? `: ${detail}` : "";
-        throw new Error(`Audio transcription failed (HTTP ${res.status})${suffix}`);
+    }, params.timeoutMs, fetchFn, allowPrivate ? { ssrfPolicy: { allowPrivateNetwork: true } } : undefined);
+    try {
+        if (!res.ok) {
+            const detail = await readErrorResponse(res);
+            const suffix = detail ? `: ${detail}` : "";
+            throw new Error(`Audio transcription failed (HTTP ${res.status})${suffix}`);
+        }
+        const payload = (await res.json());
+        const text = payload.text?.trim();
+        if (!text) {
+            throw new Error("Audio transcription response missing text");
+        }
+        return { text, model };
     }
-    const payload = (await res.json());
-    const text = payload.text?.trim();
-    if (!text) {
-        throw new Error("Audio transcription response missing text");
+    finally {
+        await release();
     }
-    return { text, model };
 }

package/dist/media-understanding/providers/shared.d.ts

@@ -1,3 +1,10 @@
+import type { GuardedFetchResult } from "../../infra/net/fetch-guard.js";
+import type { LookupFn, SsrFPolicy } from "../../infra/net/ssrf.js";
 export declare function normalizeBaseUrl(baseUrl: string | undefined, fallback: string): string;
 export declare function fetchWithTimeout(url: string, init: RequestInit, timeoutMs: number, fetchFn: typeof fetch): Promise<Response>;
+export declare function fetchWithTimeoutGuarded(url: string, init: RequestInit, timeoutMs: number, fetchFn: typeof fetch, options?: {
+    ssrfPolicy?: SsrFPolicy;
+    lookupFn?: LookupFn;
+    pinDns?: boolean;
+}): Promise<GuardedFetchResult>;
 export declare function readErrorResponse(res: Response): Promise<string | undefined>;

package/dist/media-understanding/providers/shared.js

@@ -1,3 +1,4 @@
+import { fetchWithSsrFGuard } from "../../infra/net/fetch-guard.js";
 const MAX_ERROR_CHARS = 300;
 export function normalizeBaseUrl(baseUrl, fallback) {
     const raw = baseUrl?.trim() || fallback;
@@ -13,6 +14,17 @@ export async function fetchWithTimeout(url, init, timeoutMs, fetchFn) {
         clearTimeout(timer);
     }
 }
+export async function fetchWithTimeoutGuarded(url, init, timeoutMs, fetchFn, options) {
+    return await fetchWithSsrFGuard({
+        url,
+        fetchImpl: fetchFn,
+        init,
+        timeoutMs,
+        policy: options?.ssrfPolicy,
+        lookupFn: options?.lookupFn,
+        pinDns: options?.pinDns,
+    });
+}
 export async function readErrorResponse(res) {
     try {
         const text = await res.text();

package/dist/media-understanding/resolve.d.ts

@@ -1,5 +1,5 @@
-import type { OpenClawConfig } from "../config/config.js";
 import type { MsgContext } from "../auto-reply/templating.js";
+import type { OpenClawConfig } from "../config/config.js";
 import type { MediaUnderstandingConfig, MediaUnderstandingModelConfig, MediaUnderstandingScopeConfig } from "../config/types.tools.js";
 import type { MediaUnderstandingCapability } from "./types.js";
 export declare function resolveTimeoutMs(seconds: number | undefined, fallbackSeconds: number): number;

package/dist/media-understanding/runner.d.ts

@@ -1,8 +1,8 @@
-import type { OpenClawConfig } from "../config/config.js";
 import type { MsgContext } from "../auto-reply/templating.js";
+import type { OpenClawConfig } from "../config/config.js";
 import type { MediaUnderstandingConfig } from "../config/types.tools.js";
-import { MediaAttachmentCache } from "./attachments.js";
 import type { MediaAttachment, MediaUnderstandingCapability, MediaUnderstandingDecision, MediaUnderstandingOutput, MediaUnderstandingProvider } from "./types.js";
+import { MediaAttachmentCache } from "./attachments.js";
 export type ActiveMediaModel = {
     provider: string;
     model?: string;

package/dist/media-understanding/runner.js

@@ -2,17 +2,17 @@ import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { requireApiKey, resolveApiKeyForProvider } from "../agents/model-auth.js";
 import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { applyTemplate } from "../auto-reply/templating.js";
-import { requireApiKey, resolveApiKeyForProvider } from "../agents/model-auth.js";
 import { logVerbose, shouldLogVerbose } from "../globals.js";
 import { runExec } from "../process/exec.js";
 import { MediaAttachmentCache, normalizeAttachments, selectAttachments } from "./attachments.js";
 import { CLI_OUTPUT_MAX_BUFFER, DEFAULT_AUDIO_MODELS, DEFAULT_TIMEOUT_SECONDS, } from "./defaults.js";
 import { isMediaUnderstandingSkipError, MediaUnderstandingSkipError } from "./errors.js";
-import { resolveMaxBytes, resolveMaxChars, resolveModelEntries, resolvePrompt, resolveScopeDecision, resolveTimeoutMs, } from "./resolve.js";
-import { buildMediaUnderstandingRegistry, getMediaUnderstandingProvider, normalizeMediaProviderId, } from "./providers/index.js";
 import { describeImageWithModel } from "./providers/image.js";
+import { buildMediaUnderstandingRegistry, getMediaUnderstandingProvider, normalizeMediaProviderId, } from "./providers/index.js";
+import { resolveMaxBytes, resolveMaxChars, resolveModelEntries, resolvePrompt, resolveScopeDecision, resolveTimeoutMs, } from "./resolve.js";
 import { estimateBase64Size, resolveVideoMaxBase64Bytes } from "./video.js";
 const AUTO_AUDIO_KEY_PROVIDERS = ["openai", "groq", "deepgram", "google"];
 const AUTO_IMAGE_KEY_PROVIDERS = ["openai", "anthropic", "google", "minimax"];

package/dist/memory/batch-gemini.js

@@ -1,5 +1,5 @@
-import { createSubsystemLogger } from "../logging/subsystem.js";
 import { isTruthyEnvValue } from "../infra/env.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { hashText } from "./internal.js";
 const GEMINI_BATCH_MAX_REQUESTS = 50000;
 const debugEmbeddings = isTruthyEnvValue(process.env.OPENCLAW_DEBUG_MEMORY_EMBEDDINGS);