openfox 2.0.134 → 2.0.136

package/dist/chunk-U6FHHT2B.js

@@ -0,0 +1,1155 @@
+import {
+  serverT
+} from "./chunk-4SBVW4UH.js";
+import {
+  AskUserInterrupt
+} from "./chunk-V5AC2TV7.js";
+import {
+  PathAccessDeniedError,
+  registerPathConfirmation,
+  requestPathAccess
+} from "./chunk-PQKLOLGC.js";
+import {
+  getEventStore
+} from "./chunk-342BKOTE.js";
+import {
+  getRuntimeConfig
+} from "./chunk-BHVR2YS5.js";
+import {
+  createChatPathConfirmationMessage
+} from "./chunk-AATMPL7S.js";
+import {
+  modelSupportsVision
+} from "./chunk-TS5WKTFB.js";
+import {
+  OUTPUT_LIMITS,
+  cacheSet,
+  contentHash,
+  decodeDataUrl,
+  extractPdfContent,
+  extractPdfText,
+  formatPdfErrorMessage,
+  isPdfBuffer,
+  processPdfContent
+} from "./chunk-FSSUPWYO.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+
+// src/server/tools/describe-image.ts
+import { readFile as readFile3, stat as stat2 } from "fs/promises";
+import { relative as relative3 } from "path";
+
+// src/server/tools/tool-helpers.ts
+import { randomUUID } from "crypto";
+import { resolve } from "path";
+var confirmationSeqCounter = 0;
+async function requestUserConfirmation(context, toolLabel, desc) {
+  if (context.dangerLevel === "dangerous") return Promise.resolve(true);
+  if (toolLabel === "workspace" || toolLabel === "command") {
+    try {
+      const { getSetting, SETTINGS_KEYS } = await import("./settings-WH6BVQCP.js");
+      if (getSetting(SETTINGS_KEYS.CONFIRM_ON_WORKSPACE_ACTIONS) !== "true") {
+        return Promise.resolve(true);
+      }
+    } catch {
+    }
+  }
+  if (context.isSubAgent) return Promise.resolve(false);
+  if (typeof context.onEvent !== "function") return Promise.resolve(false);
+  const seq = ++confirmationSeqCounter;
+  const callId = context.toolCallId ? `${context.toolCallId}-${seq}` : randomUUID();
+  try {
+    const eventStore = getEventStore();
+    eventStore.append(context.sessionId, {
+      type: "path.confirmation_pending",
+      data: { callId, tool: toolLabel, paths: [desc], workdir: context.workdir, reason: "dangerous_command" }
+    });
+  } catch {
+  }
+  const promise = registerPathConfirmation(
+    callId,
+    [desc],
+    context.sessionId,
+    toolLabel,
+    context.workdir,
+    "dangerous_command"
+  );
+  context.onEvent(
+    createChatPathConfirmationMessage(callId, toolLabel, [desc], context.workdir, "dangerous_command")
+  );
+  return promise;
+}
+function buildSignal(timeoutMs, contextSignal) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  if (contextSignal) {
+    return AbortSignal.any([timeoutSignal, contextSignal]);
+  }
+  return timeoutSignal;
+}
+function validateAction(action, allowed, startTime) {
+  if (!action || !allowed.includes(action)) {
+    return {
+      success: false,
+      error: serverT(
+        {
+          en: "Invalid action: {{action}}. Must be one of: {{allowed}}",
+          fr: "Action invalide : {{action}}. Doit \xEAtre l\u2019une des actions suivantes : {{allowed}}"
+        },
+        { action: action ?? "", allowed: allowed.join(", ") }
+      ),
+      durationMs: Date.now() - startTime,
+      truncated: false
+    };
+  }
+  return void 0;
+}
+function checkActionPermission(action, permittedActions, startTime) {
+  if (action && permittedActions && permittedActions.length > 0 && !permittedActions.includes(action)) {
+    return {
+      success: false,
+      error: serverT(
+        {
+          en: "Action '{{action}}' not allowed. Available: {{available}}",
+          fr: "Action \xAB {{action}} \xBB non autoris\xE9e. Disponibles : {{available}}"
+        },
+        { action: action ?? "", available: permittedActions.join(", ") }
+      ),
+      durationMs: Date.now() - startTime,
+      truncated: false
+    };
+  }
+  return void 0;
+}
+function requireSession(sessionManager, sessionId) {
+  return sessionManager.requireSession(sessionId);
+}
+function validateActionWithPermission(action, allowedActions, toolName, permittedActions, startTime) {
+  const actionError = validateAction(action, allowedActions, startTime ?? Date.now());
+  if (actionError) return actionError;
+  const permittedToolActions = permittedActions?.[toolName];
+  const permissionError = checkActionPermission(action, permittedToolActions, startTime ?? Date.now());
+  if (permissionError) return permissionError;
+  return void 0;
+}
+function createTool(name, definition, handler) {
+  return {
+    name,
+    definition,
+    async execute(args, context) {
+      const startTime = Date.now();
+      const helpers = {
+        resolvePath: (path) => resolve(context.workdir, path),
+        checkPathAccess: async (paths, command) => {
+          if (context.onEvent) {
+            await requestPathAccess(
+              paths,
+              context.workdir,
+              context.sessionId,
+              context.toolCallId ?? crypto.randomUUID(),
+              name,
+              context.onEvent,
+              context.dangerLevel,
+              command,
+              context.isSubAgent
+            );
+          }
+        },
+        error: (message, truncated = false) => ({
+          success: false,
+          error: message,
+          durationMs: Date.now() - startTime,
+          truncated
+        }),
+        success: (output, truncated = false, extra) => ({
+          success: true,
+          output,
+          durationMs: Date.now() - startTime,
+          truncated,
+          ...extra
+        })
+      };
+      try {
+        return await handler(args, context, helpers);
+      } catch (error) {
+        if (error instanceof PathAccessDeniedError || error instanceof AskUserInterrupt) {
+          throw error;
+        }
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : serverT({
+            en: "Unknown error in tool execution",
+            fr: "Erreur inconnue lors de l\u2019ex\xE9cution de l\u2019outil"
+          }),
+          durationMs: Date.now() - startTime,
+          truncated: false
+        };
+      }
+    }
+  };
+}
+
+// src/server/tools/read.ts
+import { readFile as readFile2, stat, readdir } from "fs/promises";
+import { extname, join, relative as relative2 } from "path";
+
+// src/server/tools/file-tracker.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import { relative, resolve as resolve2 } from "path";
+var FileNotReadError = class extends Error {
+  constructor(path) {
+    super(`File "${path}" must be read before writing. Use read_file first.`);
+    this.name = "FileNotReadError";
+  }
+};
+var FileChangedExternallyError = class extends Error {
+  constructor(path) {
+    super(
+      `File "${path}" was modified externally and must be read before writing. Use read_file to see current contents.`
+    );
+    this.name = "FileChangedExternallyError";
+  }
+};
+async function computeFileHash(filePath) {
+  try {
+    const content = await readFile(filePath);
+    const hash = createHash("sha256");
+    hash.update(content);
+    return hash.digest("hex");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function validateFileForWrite(filePath, readFiles, baseDir) {
+  const normalizedPath = resolve2(filePath);
+  const currentHash = await computeFileHash(normalizedPath);
+  if (currentHash === null) {
+    return { valid: true };
+  }
+  const readEntry = readFiles[normalizedPath];
+  if (readEntry) {
+    if (readEntry.hash !== currentHash) {
+      return {
+        valid: false,
+        error: new FileChangedExternallyError(filePath)
+      };
+    }
+    return { valid: true };
+  }
+  if (baseDir) {
+    const relPath = relative(baseDir, normalizedPath);
+    if (!relPath.startsWith("..")) {
+      const relMatches = Object.values(readFiles).filter((entry) => entry.relPath === relPath);
+      if (relMatches.some((entry) => entry.hash === currentHash)) {
+        return { valid: true };
+      }
+    }
+  }
+  return {
+    valid: false,
+    error: new FileNotReadError(filePath)
+  };
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/server/utils/encoding.ts
+import { detect } from "jschardet";
+import * as iconv from "iconv-lite";
+function detectEncoding(buffer) {
+  if (buffer.length === 0) {
+    return { encoding: "utf-8", confidence: 1, bomSize: 0 };
+  }
+  const bomSize = detectBOM(buffer);
+  const bomStripped = bomSize > 0 ? buffer.subarray(bomSize) : buffer;
+  if (bomSize > 0) {
+    const bomEncoding = bomEncodingForSize(buffer);
+    return { encoding: bomEncoding, confidence: 1, bomSize };
+  }
+  if (isValidUtf8(bomStripped)) {
+    return { encoding: "utf-8", confidence: 0.95, bomSize: 0 };
+  }
+  const detected = detect(bomStripped);
+  if (detected && detected.encoding && detected.confidence > 0.2) {
+    return { encoding: normalizeEncoding(detected.encoding), confidence: detected.confidence, bomSize: 0 };
+  }
+  return { encoding: "ISO-8859-1", confidence: 0.1, bomSize: 0 };
+}
+function detectBOM(buffer) {
+  if (buffer.length >= 4 && buffer[0] === 0 && buffer[1] === 0 && buffer[2] === 254 && buffer[3] === 255)
+    return 4;
+  if (buffer.length >= 4 && buffer[0] === 255 && buffer[1] === 254 && buffer[2] === 0 && buffer[3] === 0)
+    return 4;
+  if (buffer.length >= 2 && buffer[0] === 254 && buffer[1] === 255) return 2;
+  if (buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 254) return 2;
+  if (buffer.length >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) return 3;
+  return 0;
+}
+function bomEncodingForSize(buffer) {
+  if (buffer.length >= 2) {
+    if (buffer[0] === 254 && buffer[1] === 255) return "utf-16be";
+    if (buffer[0] === 255 && buffer[1] === 254) {
+      if (buffer.length >= 4 && buffer[2] === 0 && buffer[3] === 0) return "utf-32";
+      return "utf-16le";
+    }
+  }
+  if (buffer.length >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) return "utf-8";
+  if (buffer.length >= 4 && buffer[0] === 0 && buffer[1] === 0 && buffer[2] === 254 && buffer[3] === 255)
+    return "utf-32be";
+  return "utf-8";
+}
+function isValidUtf8(buffer) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  try {
+    decoder.decode(buffer);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeEncoding(enc) {
+  const lower = enc.toLowerCase().replace(/_/g, "-");
+  const map = {
+    "utf-8": "utf-8",
+    utf8: "utf-8",
+    ascii: "utf-8",
+    "iso-8859-1": "ISO-8859-1",
+    "iso8859-1": "ISO-8859-1",
+    latin1: "ISO-8859-1",
+    "windows-1252": "windows-1252",
+    "shift-jis": "Shift_JIS",
+    shift_jis: "Shift_JIS",
+    "euc-jp": "EUC-JP",
+    "euc-kr": "EUC-KR",
+    gb2312: "GB2312",
+    gb18030: "GB18030",
+    big5: "Big5",
+    "utf-16": "utf-16le",
+    "utf-16le": "utf-16le",
+    "utf-16be": "utf-16be",
+    "utf-32": "utf-32le",
+    "utf-32le": "utf-32le",
+    "utf-32be": "utf-32be",
+    "koi8-r": "KOI8-R",
+    "koi8-u": "KOI8-U"
+  };
+  return map[lower] ?? enc;
+}
+function decodeContent(buffer, encoding) {
+  const bomSize = detectBOM(buffer);
+  const contentBuf = bomSize > 0 ? buffer.subarray(bomSize) : buffer;
+  const normalized = normalizeEncoding(encoding);
+  if (normalized === "utf-8") {
+    return contentBuf.toString("utf-8");
+  }
+  if (normalized === "utf-16le") {
+    return contentBuf.toString("utf-16le");
+  }
+  if (normalized === "utf-16be") {
+    return swapUtf16Endianness(contentBuf).toString("utf-16le");
+  }
+  if (normalized === "utf-32le") {
+    return utf32ToString(contentBuf, true);
+  }
+  if (normalized === "utf-32be") {
+    return utf32ToString(contentBuf, false);
+  }
+  return iconv.decode(contentBuf, normalized);
+}
+function encodeContent(content, encoding, addBom = false) {
+  const normalized = normalizeEncoding(encoding);
+  let encoded;
+  if (normalized === "utf-8") {
+    encoded = Buffer.from(content, "utf-8");
+  } else if (normalized === "utf-16le") {
+    encoded = Buffer.from(content, "utf-16le");
+  } else if (normalized === "utf-16be") {
+    encoded = swapUtf16Endianness(Buffer.from(content, "utf-16le"));
+  } else if (normalized === "utf-32le") {
+    encoded = stringToUtf32(content, true);
+  } else if (normalized === "utf-32be") {
+    encoded = stringToUtf32(content, false);
+  } else {
+    encoded = iconv.encode(content, normalized);
+  }
+  if (addBom) {
+    const bom = bomForEncoding(normalized);
+    if (bom) {
+      encoded = Buffer.concat([bom, encoded]);
+    }
+  }
+  return encoded;
+}
+function bomForEncoding(encoding) {
+  switch (encoding) {
+    case "utf-8":
+      return Buffer.from([239, 187, 191]);
+    case "utf-16le":
+      return Buffer.from([255, 254]);
+    case "utf-16be":
+      return Buffer.from([254, 255]);
+    case "utf-32le":
+      return Buffer.from([255, 254, 0, 0]);
+    case "utf-32be":
+      return Buffer.from([0, 0, 254, 255]);
+    default:
+      return null;
+  }
+}
+function swapUtf16Endianness(buf) {
+  const out = Buffer.alloc(buf.length);
+  for (let i = 0; i + 1 < buf.length; i += 2) {
+    out[i] = buf[i + 1];
+    out[i + 1] = buf[i];
+  }
+  return out;
+}
+function utf32ToString(buffer, littleEndian) {
+  const chars = [];
+  for (let i = 0; i + 3 < buffer.length; i += 4) {
+    const code = littleEndian ? buffer.readUInt32LE(i) : buffer.readUInt32BE(i);
+    if (code > 1114111) continue;
+    chars.push(String.fromCodePoint(code));
+  }
+  return chars.join("");
+}
+function stringToUtf32(str, littleEndian) {
+  const codes = [];
+  for (const ch of str) {
+    codes.push(ch.codePointAt(0));
+  }
+  const buf = Buffer.alloc(codes.length * 4);
+  for (let i = 0; i < codes.length; i++) {
+    if (littleEndian) {
+      buf.writeUInt32LE(codes[i], i * 4);
+    } else {
+      buf.writeUInt32BE(codes[i], i * 4);
+    }
+  }
+  return buf;
+}
+
+// src/server/tools/read.ts
+import { fileTypeFromBuffer } from "file-type";
+async function detectImageType(buffer, filePath) {
+  const fileType = await fileTypeFromBuffer(buffer);
+  const imageMimeTypes = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/bmp", "image/svg+xml"];
+  if (fileType?.mime && imageMimeTypes.includes(fileType.mime)) {
+    return fileType.mime;
+  }
+  const ext = extname(filePath).toLowerCase();
+  if (ext === ".svg" && buffer.length > 0) {
+    const content = buffer.toString("utf-8");
+    const trimmedStart = content.trimStart();
+    if (trimmedStart.startsWith("<?xml") || trimmedStart.startsWith("<svg")) {
+      return "image/svg+xml";
+    }
+  }
+  return null;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function listDirectory(dirPath, relativePath) {
+  const entries = await readdir(dirPath, { withFileTypes: true });
+  const sorted = [...entries].sort((a, b) => {
+    if (a.isDirectory() !== b.isDirectory()) {
+      return a.isDirectory() ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  const lines = [`${relativePath}/`];
+  for (let i = 0; i < sorted.length; i++) {
+    const entry = sorted[i];
+    const isLast = i === sorted.length - 1;
+    const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const suffix = entry.isDirectory() ? "/" : "";
+    let sizeStr = "";
+    if (!entry.isDirectory()) {
+      try {
+        const entryStat = await stat(join(dirPath, entry.name));
+        sizeStr = `  ${formatSize(entryStat.size).padStart(7)}`;
+      } catch {
+      }
+    }
+    lines.push(`${prefix}${entry.name}${suffix}${sizeStr}`);
+  }
+  return lines.join("\n");
+}
+var readFileTool = createTool(
+  "read_file",
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read the contents of a file or list directory contents. For text files: returns file content. For images (PNG, JPEG, GIF, WebP, BMP, SVG): returns base64-encoded data with MIME type metadata. For PDF files: extracts text content page by page. For directories: returns a tree-formatted listing of entries with file sizes.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file (relative to workdir or absolute)"
+          },
+          offset: {
+            type: "number",
+            description: "Line number to start from (1-indexed). Default: 1. Only applies to text files."
+          },
+          limit: {
+            type: "number",
+            description: `Maximum number of lines to read. Default: ${OUTPUT_LIMITS.read_file.maxLines}. Only applies to text files.`
+          }
+        },
+        required: ["path"]
+      }
+    }
+  },
+  async (args, context, helpers) => {
+    const offset = args.offset ?? 1;
+    const limit = Math.min(args.limit ?? OUTPUT_LIMITS.read_file.maxLines, OUTPUT_LIMITS.read_file.maxLines);
+    const fullPath = helpers.resolvePath(args.path);
+    await helpers.checkPathAccess([fullPath]);
+    try {
+      const stats = await stat(fullPath);
+      if (stats.isDirectory()) {
+        const listing = await listDirectory(fullPath, args.path);
+        return helpers.success(listing);
+      }
+      if (stats.size > OUTPUT_LIMITS.read_file.maxFileBytes) {
+        return helpers.error(
+          serverT(
+            {
+              en: "File size ({{size}} bytes) exceeds maximum file size (20MB). Use shell command to process large files.",
+              fr: "La taille du fichier ({{size}} octets) d\xE9passe la taille maximale (20 Mo). Utilisez une commande shell pour traiter les fichiers volumineux."
+            },
+            { size: stats.size }
+          )
+        );
+      }
+      if (stats.size > OUTPUT_LIMITS.read_file.maxImageBytes) {
+        return helpers.error(
+          serverT(
+            {
+              en: "File size ({{size}} bytes) exceeds image size limit (2MB). Use shell command to process large files.",
+              fr: "La taille du fichier ({{size}} octets) d\xE9passe la limite pour les images (2 Mo). Utilisez une commande shell pour traiter les fichiers volumineux."
+            },
+            { size: stats.size }
+          )
+        );
+      }
+    } catch {
+      return helpers.error(
+        serverT({ en: "File not found: {{path}}", fr: "Fichier introuvable : {{path}}" }, { path: args.path })
+      );
+    }
+    const rawBuffer = await readFile2(fullPath);
+    const mimeType = await detectImageType(rawBuffer, args.path);
+    if (mimeType) {
+      const base64Data = rawBuffer.toString("base64");
+      const dataUrl = `data:${mimeType};base64,${base64Data}`;
+      const contentHash3 = await computeFileHash(fullPath);
+      if (contentHash3) {
+        context.sessionManager.recordFileRead(
+          context.sessionId,
+          fullPath,
+          contentHash3,
+          relative2(context.workdir, fullPath)
+        );
+      }
+      return helpers.success(
+        serverT(
+          { en: "[Image: {{path}} ({{mime}}, {{size}} bytes)]", fr: "[Image : {{path}} ({{mime}}, {{size}} octets)]" },
+          { path: args.path, mime: mimeType, size: rawBuffer.length }
+        ),
+        false,
+        {
+          metadata: {
+            mimeType,
+            size: rawBuffer.length,
+            base64Data,
+            dataUrl,
+            path: fullPath
+          }
+        }
+      );
+    }
+    if (isPdfBuffer(rawBuffer)) {
+      try {
+        const { text, pageCount, title, author } = await extractPdfText(rawBuffer);
+        const { output: output2, truncated: truncated2, isScanned } = processPdfContent(text, OUTPUT_LIMITS.read_file.maxBytes);
+        const contentHash3 = await computeFileHash(fullPath);
+        if (contentHash3) {
+          context.sessionManager.recordFileRead(
+            context.sessionId,
+            fullPath,
+            contentHash3,
+            relative2(context.workdir, fullPath)
+          );
+        }
+        if (isScanned) {
+          return helpers.success(
+            `[PDF: ${args.path} \u2014 This PDF has no text layer (scanned or image-only). Use a shell command with OCR to extract text.]`,
+            false,
+            {
+              metadata: {
+                format: "pdf",
+                pageCount,
+                title,
+                author,
+                path: fullPath
+              }
+            }
+          );
+        }
+        return helpers.success(output2, truncated2, {
+          metadata: {
+            format: "pdf",
+            pageCount,
+            title,
+            author,
+            path: fullPath
+          }
+        });
+      } catch (err) {
+        return helpers.error(formatPdfErrorMessage(err));
+      }
+    }
+    const { encoding, confidence } = detectEncoding(rawBuffer);
+    const content = decodeContent(rawBuffer, encoding);
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    const startLine = Math.max(1, offset);
+    const endLine = Math.min(startLine + limit - 1, totalLines);
+    const selectedLines = lines.slice(startLine - 1, endLine);
+    const formatted = selectedLines.join("\n");
+    const truncated = endLine < totalLines;
+    let output = formatted;
+    if (truncated) {
+      output += `
+
+[Showing lines ${startLine}-${endLine} of ${totalLines} total. Use offset to read more.]`;
+    }
+    if (output.length > OUTPUT_LIMITS.read_file.maxBytes) {
+      output = output.slice(0, OUTPUT_LIMITS.read_file.maxBytes);
+      output += "\n\n[Output truncated due to size limit]";
+    }
+    const contentHash2 = await computeFileHash(fullPath);
+    if (contentHash2) {
+      context.sessionManager.recordFileRead(
+        context.sessionId,
+        fullPath,
+        contentHash2,
+        relative2(context.workdir, fullPath)
+      );
+    }
+    return helpers.success(output, truncated, {
+      metadata: {
+        encoding,
+        confidence: Math.round(confidence * 100) / 100,
+        lineCount: totalLines,
+        startLine,
+        endLine,
+        path: fullPath
+      }
+    });
+  }
+);
+
+// src/server/llm/vision-fallback.ts
+var IMAGE_PROMPT = `Describe this image thoroughly and accurately. Include:
+- What the image shows (UI, diagram, photo, illustration, etc.)
+- All visible text, transcribed verbatim \u2014 every label, heading, number, and value
+- Spatial layout: where elements are positioned and how they relate
+- Colors, visual hierarchy, and any distinctive visual features
+
+Be exhaustive rather than concise. Prioritize precision \u2014 if there are numbers, lists, or structured data, capture them completely. If the image contains a table or grid, reproduce it as a markdown table with exact values.`;
+function buildPrompt(context, question) {
+  if (question) {
+    return `Answer the following question about this image. Be precise and concise, and if the answer is not visible in the image, say so explicitly:
+
+${question}`;
+  }
+  return context ? `${IMAGE_PROMPT}
+
+Context: ${context}` : IMAGE_PROMPT;
+}
+function buildOllamaRequest(base64Data, model, context, question) {
+  return {
+    model,
+    messages: [
+      {
+        role: "user",
+        content: buildPrompt(context, question),
+        images: [base64Data]
+      }
+    ],
+    stream: false,
+    think: false
+  };
+}
+function buildOpenAIRequest(base64Data, model, context, question) {
+  return {
+    model,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: buildPrompt(context, question) },
+          { type: "image_url", image_url: { url: `data:image/png;base64,${base64Data}` } }
+        ]
+      }
+    ]
+  };
+}
+function parseOllamaResponse(data) {
+  const resp = data;
+  return resp.message?.content?.trim() ?? null;
+}
+function parseOpenAIResponse(data) {
+  const resp = data;
+  const choice = resp.choices?.[0];
+  if (!choice) return null;
+  return choice.message?.content?.trim() ?? null;
+}
+async function describeImage(base64Data, visionModel, options) {
+  const timeout = visionModel.timeout;
+  try {
+    const isOpenAI = visionModel.backend === "openai";
+    const url = isOpenAI ? `${visionModel.baseUrl.replace(/\/+$/, "")}/chat/completions` : `${visionModel.baseUrl.replace(/\/+$/, "")}/api/chat`;
+    const requestBody = isOpenAI ? buildOpenAIRequest(base64Data, visionModel.model, options?.context, options?.question) : buildOllamaRequest(base64Data, visionModel.model, options?.context, options?.question);
+    const timeoutController = new AbortController();
+    const timeoutId = setTimeout(() => timeoutController.abort(), timeout);
+    const signal = options?.signal ? AbortSignal.any([timeoutController.signal, options.signal]) : timeoutController.signal;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (isOpenAI && visionModel.apiKey) {
+      headers["Authorization"] = `Bearer ${visionModel.apiKey}`;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody),
+      signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      logger.error("Vision fallback API error", { status: response.status, error: errorText });
+      return `[Image description failed: HTTP ${response.status}]`;
+    }
+    const data = await response.json();
+    const description = isOpenAI ? parseOpenAIResponse(data) : parseOllamaResponse(data);
+    if (!description) {
+      logger.warn("Vision fallback returned empty description");
+      return "[Image - could not describe]";
+    }
+    return description;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    logger.error("Vision fallback error", { error: message });
+    if (message.includes("abort")) {
+      return "[Image description timed out]";
+    }
+    return `[Image description failed: ${message}]`;
+  }
+}
+async function describeImageFromDataUrl(dataUrl, visionModel, options) {
+  const base64Match = dataUrl.match(/^data:image\/[^;]+;base64,(.+)$/);
+  if (!base64Match || !base64Match[1]) {
+    return "[Invalid image data URL]";
+  }
+  return describeImage(base64Match[1], visionModel, options);
+}
+function isVisionFallbackFailure(description) {
+  return description.startsWith("[Image description failed:") || description === "[Image description timed out]" || description === "[Image - could not describe]" || description === "[Invalid image data URL]";
+}
+
+// src/server/context/image-processor.ts
+async function loadVisionModelFromGlobalConfig() {
+  try {
+    const { loadGlobalConfig, resolveVisionFallback } = await import("./config-LOK3LXFH.js");
+    const runtimeConfig = getRuntimeConfig();
+    const mode = runtimeConfig.mode ?? "production";
+    const globalConfig = await loadGlobalConfig(mode);
+    return resolveVisionFallback(globalConfig);
+  } catch {
+  }
+  return void 0;
+}
+async function loadResolvedVisionModel() {
+  const runtimeConfig = getRuntimeConfig();
+  const llm = runtimeConfig.llm;
+  if (llm?.visionModel) {
+    return {
+      baseUrl: llm.baseUrl,
+      model: llm.visionModel,
+      timeout: llm.timeout,
+      backend: llm.backend === "ollama" ? "ollama" : "openai"
+    };
+  }
+  return loadVisionModelFromGlobalConfig();
+}
+var descriptionCache = /* @__PURE__ */ new Map();
+function isImageAttachment(att) {
+  return att.mimeType.startsWith("image/");
+}
+function isPdfAttachment(att) {
+  return att.mimeType === "application/pdf";
+}
+function hasImageMetadata(result) {
+  const meta = result.metadata;
+  if (!meta) return false;
+  const dataUrl = meta["dataUrl"];
+  const mimeType = meta["mimeType"];
+  return typeof dataUrl === "string" && typeof mimeType === "string" && mimeType.startsWith("image/");
+}
+async function describeImageDataUrl(dataUrl, attachmentId, messageId, options, descriptions, filename) {
+  const cacheKey = contentHash(dataUrl);
+  if (descriptionCache.has(cacheKey)) {
+    const cached = descriptionCache.get(cacheKey);
+    descriptions.set(attachmentId, cached);
+    return cached;
+  }
+  if (options.visionModel) {
+    const startData = {
+      messageId,
+      attachmentId
+    };
+    if (filename !== void 0) {
+      startData.filename = filename;
+    }
+    options.onEvent?.({ type: "vision_fallback.start", data: startData });
+    const description = await describeImageFromDataUrl(dataUrl, options.visionModel, {
+      context: filename ? `File: ${filename}` : void 0,
+      signal: options.signal
+    });
+    cacheSet(descriptionCache, cacheKey, description);
+    descriptions.set(attachmentId, description);
+    options.onEvent?.({ type: "vision_fallback.done", data: { messageId, attachmentId, description } });
+    return description;
+  }
+  const placeholder = filename ? `[Image: ${filename}]` : "[Image]";
+  descriptions.set(attachmentId, placeholder);
+  return placeholder;
+}
+async function describeAttachment(att, messageId, options, descriptions) {
+  return describeImageDataUrl(att.data, att.id, messageId, options, descriptions, att.filename);
+}
+async function describePdfAttachment(att, messageId, options, descriptions) {
+  const hasVision = !!options.visionModel;
+  const cacheKey = `pdf:${hasVision}:${contentHash(att.data)}`;
+  const filenameLabel = att.filename || "document.pdf";
+  if (descriptionCache.has(cacheKey)) {
+    const cached = descriptionCache.get(cacheKey);
+    const output2 = `[PDF: ${filenameLabel}]${cached}`;
+    descriptions.set(att.id, output2);
+    return output2;
+  }
+  const buffer = decodeDataUrl(att.data);
+  if (!buffer) {
+    const fallback = `[PDF: ${filenameLabel}] (could not decode)`;
+    cacheSet(descriptionCache, cacheKey, fallback);
+    descriptions.set(att.id, fallback);
+    return fallback;
+  }
+  let blocks;
+  try {
+    const result = await extractPdfContent(buffer);
+    blocks = result.blocks;
+  } catch {
+    const errorText = `[PDF: ${filenameLabel}] (could not extract content)`;
+    descriptions.set(att.id, errorText);
+    return errorText;
+  }
+  let body = "";
+  let imageIndex = 0;
+  for (const block of blocks) {
+    if (block.type === "text" && block.content) {
+      body += "\n\n" + block.content;
+    } else if (block.type === "image" && block.dataUrl) {
+      const imgAttachmentId = `${att.id}/image-${imageIndex}`;
+      const description = await describeImageDataUrl(block.dataUrl, imgAttachmentId, messageId, options, descriptions);
+      body += "\n\n" + description;
+      imageIndex++;
+    }
+  }
+  const output = `[PDF: ${filenameLabel}]${body}`;
+  cacheSet(descriptionCache, cacheKey, body);
+  descriptions.set(att.id, output);
+  return output;
+}
+async function processContextImages(events, options) {
+  if (options.modelSupportsVision) {
+    return { events, descriptions: /* @__PURE__ */ new Map() };
+  }
+  const descriptions = /* @__PURE__ */ new Map();
+  const modifiedEvents = events.map((event) => structuredClone(event));
+  for (const event of modifiedEvents) {
+    if (event.type === "message.start") {
+      const data = event.data;
+      if (!data.attachments || data.attachments.length === 0) continue;
+      let enriched = false;
+      const imageAtts = data.attachments.filter(isImageAttachment);
+      for (const att of imageAtts) {
+        if (att.description) {
+          descriptions.set(att.id, att.description);
+          continue;
+        }
+        const description = await describeAttachment(att, data.messageId, options, descriptions);
+        att.description = description;
+        enriched = true;
+      }
+      const pdfAtts = data.attachments.filter(isPdfAttachment);
+      for (const att of pdfAtts) {
+        if (att.pdfContent) {
+          descriptions.set(att.id, att.pdfContent);
+          continue;
+        }
+        const pdfContent = await describePdfAttachment(att, data.messageId, options, descriptions);
+        att.pdfContent = pdfContent;
+        enriched = true;
+      }
+      if (enriched && options.persistEvent) {
+        options.persistEvent(event.sessionId, event.seq, data);
+      }
+    }
+    if (event.type === "tool.result") {
+      const data = event.data;
+      if (!data.result.metadata || !hasImageMetadata(data.result)) continue;
+      const meta = data.result.metadata;
+      if (meta["description"]) {
+        descriptions.set(data.toolCallId, meta["description"]);
+        continue;
+      }
+      const dataUrl = meta["dataUrl"];
+      const path = meta["path"];
+      const description = await describeImageDataUrl(
+        dataUrl,
+        data.toolCallId,
+        data.messageId,
+        options,
+        descriptions,
+        path
+      );
+      meta["description"] = description;
+      if (options.persistEvent) {
+        options.persistEvent(event.sessionId, event.seq, data);
+      }
+    }
+    if (event.type === "turn.snapshot") {
+      const snapshot = event.data;
+      let enriched = false;
+      for (const message of snapshot.messages) {
+        if (message.role === "user" && message.attachments && message.attachments.length > 0) {
+          for (const att of message.attachments) {
+            if (isImageAttachment(att)) {
+              if (att.description) {
+                descriptions.set(att.id, att.description);
+                continue;
+              }
+              const description = await describeAttachment(att, message.id, options, descriptions);
+              att.description = description;
+              enriched = true;
+            } else if (isPdfAttachment(att)) {
+              if (att.pdfContent) {
+                descriptions.set(att.id, att.pdfContent);
+                continue;
+              }
+              const pdfContent = await describePdfAttachment(att, message.id, options, descriptions);
+              att.pdfContent = pdfContent;
+              enriched = true;
+            }
+          }
+        }
+        if (message.role === "assistant" && message.toolCalls) {
+          for (const toolCall of message.toolCalls) {
+            if (!toolCall.result || !toolCall.result.metadata || !hasImageMetadata(toolCall.result)) continue;
+            const meta = toolCall.result.metadata;
+            if (meta["description"]) {
+              descriptions.set(toolCall.id, meta["description"]);
+              continue;
+            }
+            const dataUrl = meta["dataUrl"];
+            const path = meta["path"];
+            const description = await describeImageDataUrl(
+              dataUrl,
+              toolCall.id,
+              message.id,
+              options,
+              descriptions,
+              path
+            );
+            meta["description"] = description;
+            enriched = true;
+          }
+        }
+      }
+      if (enriched && options.persistEvent) {
+        options.persistEvent(event.sessionId, event.seq, snapshot);
+      }
+    }
+  }
+  return { events: modifiedEvents, descriptions };
+}
+
+// src/server/tools/describe-image.ts
+async function isDescribeImageEligible(modelName) {
+  if (!modelName) return false;
+  if (modelSupportsVision(modelName)) return false;
+  const visionModel = await loadResolvedVisionModel();
+  return !!visionModel;
+}
+var describeImageTool = createTool(
+  "describe_image",
+  {
+    type: "function",
+    function: {
+      name: "describe_image",
+      description: "Ask a vision fallback model a specific question about an image file.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the image file (relative to workdir or absolute)"
+          },
+          question: {
+            type: "string",
+            description: 'The precise detail to extract from the image (e.g. "What does the button in the top-right corner say?")'
+          }
+        },
+        required: ["path", "question"]
+      }
+    }
+  },
+  async (args, context, helpers) => {
+    const question = String(args.question ?? "").trim();
+    if (!question) {
+      return helpers.error(
+        serverT({
+          en: "A question is required for describe_image.",
+          fr: "Une question est requise pour describe_image."
+        })
+      );
+    }
+    const fullPath = helpers.resolvePath(args.path);
+    await helpers.checkPathAccess([fullPath]);
+    const activeModel = context.llmClient?.getModel();
+    if (activeModel && modelSupportsVision(activeModel)) {
+      return helpers.error(
+        serverT({
+          en: "describe_image is only available when the active model cannot see images. The active model supports vision, so read the image directly with read_file instead.",
+          fr: "describe_image n\u2019est disponible que lorsque le mod\xE8le actif ne voit pas les images. Le mod\xE8le actif supporte la vision : lisez plut\xF4t l\u2019image directement avec read_file."
+        })
+      );
+    }
+    let size;
+    try {
+      const stats = await stat2(fullPath);
+      size = stats.size;
+    } catch {
+      return helpers.error(
+        serverT({ en: "File not found: {{path}}", fr: "Fichier introuvable : {{path}}" }, { path: args.path })
+      );
+    }
+    if (size > OUTPUT_LIMITS.read_file.maxFileBytes) {
+      return helpers.error(
+        serverT(
+          {
+            en: "File size ({{size}} bytes) exceeds maximum file size (20MB). Use a shell command to process large files.",
+            fr: "La taille du fichier ({{size}} octets) d\xE9passe la taille maximale (20 Mo). Utilisez une commande shell pour traiter les fichiers volumineux."
+          },
+          { size }
+        )
+      );
+    }
+    if (size > OUTPUT_LIMITS.read_file.maxImageBytes) {
+      return helpers.error(
+        serverT(
+          {
+            en: "File size ({{size}} bytes) exceeds image size limit (2MB). Use a shell command to process large files.",
+            fr: "La taille du fichier ({{size}} octets) d\xE9passe la limite pour les images (2 Mo). Utilisez une commande shell pour traiter les fichiers volumineux."
+          },
+          { size }
+        )
+      );
+    }
+    const rawBuffer = await readFile3(fullPath);
+    const mimeType = await detectImageType(rawBuffer, args.path);
+    if (!mimeType) {
+      return helpers.error(
+        serverT(
+          {
+            en: "Not an image file: {{path}}. describe_image only works on images (PNG, JPEG, GIF, WebP, BMP, SVG).",
+            fr: "Ce n\u2019est pas une image : {{path}}. describe_image ne fonctionne que sur des images (PNG, JPEG, GIF, WebP, BMP, SVG)."
+          },
+          { path: args.path }
+        )
+      );
+    }
+    const visionModel = await loadResolvedVisionModel();
+    if (!visionModel) {
+      return helpers.error(
+        serverT({
+          en: "No vision fallback is configured. Configure a vision fallback to use describe_image.",
+          fr: "Aucun fallback vision n\u2019est configur\xE9. Configurez un fallback vision pour utiliser describe_image."
+        })
+      );
+    }
+    const base64Data = rawBuffer.toString("base64");
+    const dataUrl = `data:${mimeType};base64,${base64Data}`;
+    const contentHash2 = await computeFileHash(fullPath);
+    if (contentHash2) {
+      context.sessionManager.recordFileRead(
+        context.sessionId,
+        fullPath,
+        contentHash2,
+        relative3(context.workdir, fullPath)
+      );
+    }
+    const answer = await describeImageFromDataUrl(dataUrl, visionModel, {
+      question,
+      signal: context.signal
+    });
+    if (isVisionFallbackFailure(answer)) {
+      return helpers.error(answer);
+    }
+    return helpers.success(answer, false, {
+      metadata: {
+        mimeType,
+        size,
+        base64Data,
+        dataUrl,
+        path: fullPath,
+        question,
+        description: answer
+      }
+    });
+  }
+);
+
+export {
+  requestUserConfirmation,
+  buildSignal,
+  requireSession,
+  validateActionWithPermission,
+  createTool,
+  computeFileHash,
+  validateFileForWrite,
+  detectEncoding,
+  decodeContent,
+  encodeContent,
+  readFileTool,
+  loadResolvedVisionModel,
+  processContextImages,
+  isDescribeImageEligible,
+  describeImageTool
+};
+//# sourceMappingURL=chunk-U6FHHT2B.js.map