@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/media-understanding/runner.js

@@ -2,27 +2,18 @@ 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 { AUTO_AUDIO_KEY_PROVIDERS, AUTO_IMAGE_KEY_PROVIDERS, AUTO_VIDEO_KEY_PROVIDERS, CLI_OUTPUT_MAX_BUFFER, DEFAULT_AUDIO_MODELS, DEFAULT_IMAGE_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"];
-const AUTO_VIDEO_KEY_PROVIDERS = ["google"];
-const DEFAULT_IMAGE_MODELS = {
-    openai: "gpt-5-mini",
-    anthropic: "claude-opus-4-5",
-    google: "gemini-3-flash-preview",
-    minimax: "MiniMax-VL-01",
-};
 export function buildProviderRegistry(overrides) {
     return buildMediaUnderstandingRegistry(overrides);
 }
@@ -35,24 +26,29 @@ export function createMediaAttachmentCache(attachments) {
 const binaryCache = new Map();
 const geminiProbeCache = new Map();
 function expandHomeDir(value) {
-    if (!value.startsWith("~"))
+    if (!value.startsWith("~")) {
         return value;
+    }
     const home = os.homedir();
-    if (value === "~")
+    if (value === "~") {
         return home;
-    if (value.startsWith("~/"))
+    }
+    if (value.startsWith("~/")) {
         return path.join(home, value.slice(2));
+    }
     return value;
 }
 function hasPathSeparator(value) {
     return value.includes("/") || value.includes("\\");
 }
 function candidateBinaryNames(name) {
-    if (process.platform !== "win32")
+    if (process.platform !== "win32") {
         return [name];
+    }
     const ext = path.extname(name);
-    if (ext)
+    if (ext) {
         return [name];
+    }
     const pathext = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM")
         .split(";")
         .map((item) => item.trim())
@@ -64,10 +60,12 @@ function candidateBinaryNames(name) {
 async function isExecutable(filePath) {
     try {
         const stat = await fs.stat(filePath);
-        if (!stat.isFile())
+        if (!stat.isFile()) {
             return false;
-        if (process.platform === "win32")
+        }
+        if (process.platform === "win32") {
             return true;
+        }
         await fs.access(filePath, fsConstants.X_OK);
         return true;
     }
@@ -77,29 +75,34 @@ async function isExecutable(filePath) {
 }
 async function findBinary(name) {
     const cached = binaryCache.get(name);
-    if (cached)
+    if (cached) {
         return cached;
+    }
     const resolved = (async () => {
         const direct = expandHomeDir(name.trim());
         if (direct && hasPathSeparator(direct)) {
             for (const candidate of candidateBinaryNames(direct)) {
-                if (await isExecutable(candidate))
+                if (await isExecutable(candidate)) {
                     return candidate;
+                }
             }
         }
         const searchName = name.trim();
-        if (!searchName)
+        if (!searchName) {
             return null;
+        }
         const pathEntries = (process.env.PATH ?? "").split(path.delimiter);
         const candidates = candidateBinaryNames(searchName);
         for (const entryRaw of pathEntries) {
             const entry = expandHomeDir(entryRaw.trim().replace(/^"(.*)"$/, "$1"));
-            if (!entry)
+            if (!entry) {
                 continue;
+            }
             for (const candidate of candidates) {
                 const fullPath = path.join(entry, candidate);
-                if (await isExecutable(fullPath))
+                if (await isExecutable(fullPath)) {
                     return fullPath;
+                }
             }
         }
         return null;
@@ -111,8 +114,9 @@ async function hasBinary(name) {
     return Boolean(await findBinary(name));
 }
 async function fileExists(filePath) {
-    if (!filePath)
+    if (!filePath) {
         return false;
+    }
     try {
         await fs.stat(filePath);
         return true;
@@ -124,8 +128,9 @@ async function fileExists(filePath) {
 function extractLastJsonObject(raw) {
     const trimmed = raw.trim();
     const start = trimmed.lastIndexOf("{");
-    if (start === -1)
+    if (start === -1) {
         return null;
+    }
     const slice = trimmed.slice(start);
     try {
         return JSON.parse(slice);
@@ -136,22 +141,26 @@ function extractLastJsonObject(raw) {
 }
 function extractGeminiResponse(raw) {
     const payload = extractLastJsonObject(raw);
-    if (!payload || typeof payload !== "object")
+    if (!payload || typeof payload !== "object") {
         return null;
+    }
     const response = payload.response;
-    if (typeof response !== "string")
+    if (typeof response !== "string") {
         return null;
+    }
     const trimmed = response.trim();
     return trimmed || null;
 }
 function extractSherpaOnnxText(raw) {
     const tryParse = (value) => {
         const trimmed = value.trim();
-        if (!trimmed)
+        if (!trimmed) {
             return null;
+        }
         const head = trimmed[0];
-        if (head !== "{" && head !== '"')
+        if (head !== "{" && head !== '"') {
             return null;
+        }
         try {
             const parsed = JSON.parse(trimmed);
             if (typeof parsed === "string") {
@@ -168,26 +177,30 @@ function extractSherpaOnnxText(raw) {
         return null;
     };
     const direct = tryParse(raw);
-    if (direct)
+    if (direct) {
         return direct;
+    }
     const lines = raw
         .split("\n")
         .map((line) => line.trim())
         .filter(Boolean);
     for (let i = lines.length - 1; i >= 0; i -= 1) {
         const parsed = tryParse(lines[i] ?? "");
-        if (parsed)
+        if (parsed) {
             return parsed;
+        }
     }
     return null;
 }
 async function probeGeminiCli() {
     const cached = geminiProbeCache.get("gemini");
-    if (cached)
+    if (cached) {
         return cached;
+    }
     const resolved = (async () => {
-        if (!(await hasBinary("gemini")))
+        if (!(await hasBinary("gemini"))) {
             return false;
+        }
         try {
             const { stdout } = await runExec("gemini", ["--output-format", "json", "ok"], {
                 timeoutMs: 8000,
@@ -202,13 +215,15 @@ async function probeGeminiCli() {
     return resolved;
 }
 async function resolveLocalWhisperCppEntry() {
-    if (!(await hasBinary("whisper-cli")))
+    if (!(await hasBinary("whisper-cli"))) {
         return null;
+    }
     const envModel = process.env.WHISPER_CPP_MODEL?.trim();
     const defaultModel = "/opt/homebrew/share/whisper-cpp/for-tests-ggml-tiny.bin";
     const modelPath = envModel && (await fileExists(envModel)) ? envModel : defaultModel;
-    if (!(await fileExists(modelPath)))
+    if (!(await fileExists(modelPath))) {
         return null;
+    }
     return {
         type: "cli",
         command: "whisper-cli",
@@ -216,8 +231,9 @@ async function resolveLocalWhisperCppEntry() {
     };
 }
 async function resolveLocalWhisperEntry() {
-    if (!(await hasBinary("whisper")))
+    if (!(await hasBinary("whisper"))) {
         return null;
+    }
     return {
         type: "cli",
         command: "whisper",
@@ -235,23 +251,29 @@ async function resolveLocalWhisperEntry() {
     };
 }
 async function resolveSherpaOnnxEntry() {
-    if (!(await hasBinary("sherpa-onnx-offline")))
+    if (!(await hasBinary("sherpa-onnx-offline"))) {
         return null;
+    }
     const modelDir = process.env.SHERPA_ONNX_MODEL_DIR?.trim();
-    if (!modelDir)
+    if (!modelDir) {
         return null;
+    }
     const tokens = path.join(modelDir, "tokens.txt");
     const encoder = path.join(modelDir, "encoder.onnx");
     const decoder = path.join(modelDir, "decoder.onnx");
     const joiner = path.join(modelDir, "joiner.onnx");
-    if (!(await fileExists(tokens)))
+    if (!(await fileExists(tokens))) {
         return null;
-    if (!(await fileExists(encoder)))
+    }
+    if (!(await fileExists(encoder))) {
         return null;
-    if (!(await fileExists(decoder)))
+    }
+    if (!(await fileExists(decoder))) {
         return null;
-    if (!(await fileExists(joiner)))
+    }
+    if (!(await fileExists(joiner))) {
         return null;
+    }
     return {
         type: "cli",
         command: "sherpa-onnx-offline",
@@ -266,16 +288,19 @@ async function resolveSherpaOnnxEntry() {
 }
 async function resolveLocalAudioEntry() {
     const sherpa = await resolveSherpaOnnxEntry();
-    if (sherpa)
+    if (sherpa) {
         return sherpa;
+    }
     const whisperCpp = await resolveLocalWhisperCppEntry();
-    if (whisperCpp)
+    if (whisperCpp) {
         return whisperCpp;
+    }
     return await resolveLocalWhisperEntry();
 }
 async function resolveGeminiCliEntry(_capability) {
-    if (!(await probeGeminiCli()))
+    if (!(await probeGeminiCli())) {
         return null;
+    }
     return {
         type: "cli",
         command: "gemini",
@@ -295,14 +320,18 @@ async function resolveKeyEntry(params) {
     const { cfg, agentDir, providerRegistry, capability } = params;
     const checkProvider = async (providerId, model) => {
         const provider = getMediaUnderstandingProvider(providerId, providerRegistry);
-        if (!provider)
+        if (!provider) {
             return null;
-        if (capability === "audio" && !provider.transcribeAudio)
+        }
+        if (capability === "audio" && !provider.transcribeAudio) {
             return null;
-        if (capability === "image" && !provider.describeImage)
+        }
+        if (capability === "image" && !provider.describeImage) {
             return null;
-        if (capability === "video" && !provider.describeVideo)
+        }
+        if (capability === "video" && !provider.describeVideo) {
             return null;
+        }
         try {
             await resolveApiKeyForProvider({ provider: providerId, cfg, agentDir });
             return { type: "provider", provider: providerId, model };
@@ -315,14 +344,16 @@ async function resolveKeyEntry(params) {
         const activeProvider = params.activeModel?.provider?.trim();
         if (activeProvider) {
             const activeEntry = await checkProvider(activeProvider, params.activeModel?.model);
-            if (activeEntry)
+            if (activeEntry) {
                 return activeEntry;
+            }
         }
         for (const providerId of AUTO_IMAGE_KEY_PROVIDERS) {
             const model = DEFAULT_IMAGE_MODELS[providerId];
             const entry = await checkProvider(providerId, model);
-            if (entry)
+            if (entry) {
                 return entry;
+            }
         }
         return null;
     }
@@ -330,57 +361,68 @@ async function resolveKeyEntry(params) {
         const activeProvider = params.activeModel?.provider?.trim();
         if (activeProvider) {
             const activeEntry = await checkProvider(activeProvider, params.activeModel?.model);
-            if (activeEntry)
+            if (activeEntry) {
                 return activeEntry;
+            }
         }
         for (const providerId of AUTO_VIDEO_KEY_PROVIDERS) {
             const entry = await checkProvider(providerId, undefined);
-            if (entry)
+            if (entry) {
                 return entry;
+            }
         }
         return null;
     }
     const activeProvider = params.activeModel?.provider?.trim();
     if (activeProvider) {
         const activeEntry = await checkProvider(activeProvider, params.activeModel?.model);
-        if (activeEntry)
+        if (activeEntry) {
             return activeEntry;
+        }
     }
     for (const providerId of AUTO_AUDIO_KEY_PROVIDERS) {
         const entry = await checkProvider(providerId, undefined);
-        if (entry)
+        if (entry) {
             return entry;
+        }
     }
     return null;
 }
 async function resolveAutoEntries(params) {
     const activeEntry = await resolveActiveModelEntry(params);
-    if (activeEntry)
+    if (activeEntry) {
         return [activeEntry];
+    }
     if (params.capability === "audio") {
         const localAudio = await resolveLocalAudioEntry();
-        if (localAudio)
+        if (localAudio) {
             return [localAudio];
+        }
     }
     const gemini = await resolveGeminiCliEntry(params.capability);
-    if (gemini)
+    if (gemini) {
         return [gemini];
+    }
     const keys = await resolveKeyEntry(params);
-    if (keys)
+    if (keys) {
         return [keys];
+    }
     return [];
 }
 export async function resolveAutoImageModel(params) {
     const providerRegistry = buildProviderRegistry();
     const toActive = (entry) => {
-        if (!entry || entry.type === "cli")
+        if (!entry || entry.type === "cli") {
             return null;
+        }
         const provider = entry.provider;
-        if (!provider)
+        if (!provider) {
             return null;
+        }
         const model = entry.model ?? DEFAULT_IMAGE_MODELS[provider];
-        if (!model)
+        if (!model) {
             return null;
+        }
         return { provider, model };
     };
     const activeEntry = await resolveActiveModelEntry({
@@ -391,8 +433,9 @@ export async function resolveAutoImageModel(params) {
         activeModel: params.activeModel,
     });
     const resolvedActive = toActive(activeEntry);
-    if (resolvedActive)
+    if (resolvedActive) {
         return resolvedActive;
+    }
     const keyEntry = await resolveKeyEntry({
         cfg: params.cfg,
         agentDir: params.agentDir,
@@ -404,20 +447,26 @@ export async function resolveAutoImageModel(params) {
 }
 async function resolveActiveModelEntry(params) {
     const activeProviderRaw = params.activeModel?.provider?.trim();
-    if (!activeProviderRaw)
+    if (!activeProviderRaw) {
         return null;
+    }
     const providerId = normalizeMediaProviderId(activeProviderRaw);
-    if (!providerId)
+    if (!providerId) {
         return null;
+    }
     const provider = getMediaUnderstandingProvider(providerId, params.providerRegistry);
-    if (!provider)
+    if (!provider) {
         return null;
-    if (params.capability === "audio" && !provider.transcribeAudio)
+    }
+    if (params.capability === "audio" && !provider.transcribeAudio) {
         return null;
-    if (params.capability === "image" && !provider.describeImage)
+    }
+    if (params.capability === "image" && !provider.describeImage) {
         return null;
-    if (params.capability === "video" && !provider.describeVideo)
+    }
+    if (params.capability === "video" && !provider.describeVideo) {
         return null;
+    }
     try {
         await resolveApiKeyForProvider({
             provider: providerId,
@@ -436,8 +485,9 @@ async function resolveActiveModelEntry(params) {
 }
 function trimOutput(text, maxChars) {
     const trimmed = text.trim();
-    if (!maxChars || trimmed.length <= maxChars)
+    if (!maxChars || trimmed.length <= maxChars) {
         return trimmed;
+    }
     return trimmed.slice(0, maxChars).trim();
 }
 function commandBase(command) {
@@ -447,8 +497,9 @@ function findArgValue(args, keys) {
     for (let i = 0; i < args.length; i += 1) {
         if (keys.includes(args[i] ?? "")) {
             const value = args[i + 1];
-            if (value)
+            if (value) {
                 return value;
+            }
         }
     }
     return undefined;
@@ -459,20 +510,24 @@ function hasArg(args, keys) {
 function resolveWhisperOutputPath(args, mediaPath) {
     const outputDir = findArgValue(args, ["--output_dir", "-o"]);
     const outputFormat = findArgValue(args, ["--output_format"]);
-    if (!outputDir || !outputFormat)
+    if (!outputDir || !outputFormat) {
         return null;
+    }
     const formats = outputFormat.split(",").map((value) => value.trim());
-    if (!formats.includes("txt"))
+    if (!formats.includes("txt")) {
         return null;
+    }
     const base = path.parse(mediaPath).name;
     return path.join(outputDir, `${base}.txt`);
 }
 function resolveWhisperCppOutputPath(args) {
-    if (!hasArg(args, ["-otxt", "--output-txt"]))
+    if (!hasArg(args, ["-otxt", "--output-txt"])) {
         return null;
+    }
     const outputBase = findArgValue(args, ["-of", "--output-file"]);
-    if (!outputBase)
+    if (!outputBase) {
         return null;
+    }
     return `${outputBase}.txt`;
 }
 async function resolveCliOutput(params) {
@@ -485,44 +540,53 @@ async function resolveCliOutput(params) {
     if (fileOutput && (await fileExists(fileOutput))) {
         try {
             const content = await fs.readFile(fileOutput, "utf8");
-            if (content.trim())
+            if (content.trim()) {
                 return content.trim();
+            }
         }
         catch { }
     }
     if (commandId === "gemini") {
         const response = extractGeminiResponse(params.stdout);
-        if (response)
+        if (response) {
             return response;
+        }
     }
     if (commandId === "sherpa-onnx-offline") {
         const response = extractSherpaOnnxText(params.stdout);
-        if (response)
+        if (response) {
             return response;
+        }
     }
     return params.stdout.trim();
 }
 function normalizeProviderQuery(options) {
-    if (!options)
+    if (!options) {
         return undefined;
+    }
     const query = {};
     for (const [key, value] of Object.entries(options)) {
-        if (value === undefined)
+        if (value === undefined) {
             continue;
+        }
         query[key] = value;
     }
     return Object.keys(query).length > 0 ? query : undefined;
 }
 function buildDeepgramCompatQuery(options) {
-    if (!options)
+    if (!options) {
         return undefined;
+    }
     const query = {};
-    if (typeof options.detectLanguage === "boolean")
+    if (typeof options.detectLanguage === "boolean") {
         query.detect_language = options.detectLanguage;
-    if (typeof options.punctuate === "boolean")
+    }
+    if (typeof options.punctuate === "boolean") {
         query.punctuate = options.punctuate;
-    if (typeof options.smartFormat === "boolean")
+    }
+    if (typeof options.smartFormat === "boolean") {
         query.smart_format = options.smartFormat;
+    }
     return Object.keys(query).length > 0 ? query : undefined;
 }
 function normalizeDeepgramQueryKeys(query) {
@@ -797,8 +861,9 @@ async function runCliEntry(params) {
             mediaPath,
         });
         const text = trimOutput(resolved, maxChars);
-        if (!text)
+        if (!text) {
             return null;
+        }
         return {
             kind: capability === "audio" ? "audio.transcription" : `${capability}.description`,
             attachmentIndex: params.attachmentIndex,
@@ -840,10 +905,12 @@ async function runAttachmentEntries(params) {
                 });
             if (result) {
                 const decision = buildModelDecision({ entry, entryType, outcome: "success" });
-                if (result.provider)
+                if (result.provider) {
                     decision.provider = result.provider;
-                if (result.model)
+                }
+                if (result.model) {
                     decision.model = result.model;
+                }
                 attempts.push(decision);
                 return { output: result, attempts };
             }
@@ -985,8 +1052,9 @@ export async function runCapability(params) {
             entries: resolvedEntries,
             config,
         });
-        if (output)
+        if (output) {
             outputs.push(output);
+        }
         attachmentDecisions.push({
             attachmentIndex: attachment.index,
             attempts,