openfox 2.0.135 → 2.0.136

package/dist/{chunk-ESZQTFQP.js → chunk-EXLCFEML.js}

@@ -1,3 +1,10 @@
+import {
+  findSkillById,
+  getAllInstructions,
+  getEnabledSkillMetadata,
+  isSkillEnabled,
+  loadAllSkills
+} from "./chunk-Q33DL67W.js";
 import {
   getGitBranch,
   isGitRepository,
@@ -6,12 +13,30 @@ import {
 import {
   getGateConfig,
   isTaskConflictError,
-  isTaskGateError,
-  serverT
-} from "./chunk-OZWHRBDY.js";
+  isTaskGateError
+} from "./chunk-QBWJCO5K.js";
 import {
   getSessionDisabledServers
-} from "./chunk-S67WIWUG.js";
+} from "./chunk-DG2YSWMC.js";
+import {
+  buildSignal,
+  computeFileHash,
+  createTool,
+  decodeContent,
+  describeImageTool,
+  detectEncoding,
+  encodeContent,
+  loadResolvedVisionModel,
+  processContextImages,
+  readFileTool,
+  requestUserConfirmation,
+  requireSession,
+  validateActionWithPermission,
+  validateFileForWrite
+} from "./chunk-U6FHHT2B.js";
+import {
+  serverT
+} from "./chunk-4SBVW4UH.js";
 import {
   TurnMetrics,
   clearLLMFailure,
@@ -25,7 +50,12 @@ import {
   recordLLMFailure,
   sleepThroughRetryBackoff,
   streamLLMPure
-} from "./chunk-7ET46SNE.js";
+} from "./chunk-HEYU7FAY.js";
+import {
+  COMPACTION_PROMPT,
+  buildBasePrompt,
+  computeEffectiveTools
+} from "./chunk-4LLGI372.js";
 import {
   startInspectProxy
 } from "./chunk-LW6MMSTD.js";
@@ -42,7 +72,7 @@ import {
   spawnShellProcess,
   startProcessCommand,
   stopProcess
-} from "./chunk-5UMXFLET.js";
+} from "./chunk-SAGDTQXD.js";
 import {
   getMaxPerSession,
   getSessionProcessCount,
@@ -50,39 +80,25 @@ import {
 } from "./chunk-I72ACQ6R.js";
 import {
   createMcpTools
-} from "./chunk-JE7LW7Y6.js";
+} from "./chunk-VIJVLLPT.js";
 import {
   applyMcpServerUpdate
 } from "./chunk-OAN4BXEW.js";
-import {
-  findSkillById,
-  getAllInstructions,
-  getEnabledSkillMetadata,
-  isSkillEnabled,
-  loadAllSkills
-} from "./chunk-DWA4IE65.js";
-import {
-  COMPACTION_PROMPT,
-  buildBasePrompt,
-  computeEffectiveTools
-} from "./chunk-7QMWYNVF.js";
 import {
   AskUserInterrupt,
   askUserTool
-} from "./chunk-JURM3RPZ.js";
+} from "./chunk-V5AC2TV7.js";
 import {
   PathAccessDeniedError,
   extractAbsolutePathsFromCommand,
   extractSensitivePathsFromCommand,
-  registerPathConfirmation,
-  requestPathAccess,
   resolveRelativeTraversals
-} from "./chunk-I5ODJKYM.js";
+} from "./chunk-PQKLOLGC.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
   getEventStore
-} from "./chunk-QZOV4OVN.js";
+} from "./chunk-342BKOTE.js";
 import {
   buildContextMessagesFromEventHistory,
   foldContextState,
@@ -92,20 +108,19 @@ import {
   handleToolResult,
   reorderToolMessages,
   stripOrphanedToolCalls
-} from "./chunk-MEEUXRFL.js";
+} from "./chunk-XGG4XCKP.js";
 import {
   findAgentById,
   getRuntimeConfig,
   getSubAgents,
   loadAllAgentsDefault
-} from "./chunk-ORCQ3EXQ.js";
+} from "./chunk-BHVR2YS5.js";
 import {
   createChatDoneMessage,
   createChatLLMRetryFailedMessage,
   createChatLLMRetryMessage,
   createChatMessageMessage,
   createChatMessageUpdatedMessage,
-  createChatPathConfirmationMessage,
   createChatStatsMessage,
   createQueueStateMessage
 } from "./chunk-AATMPL7S.js";
@@ -115,20 +130,16 @@ import {
 } from "./chunk-TS5WKTFB.js";
 import {
   OUTPUT_LIMITS,
-  cacheSet,
-  contentHash,
-  decodeDataUrl,
-  extractPdfContent,
   extractPdfText,
   formatPdfErrorMessage,
   isPdfBuffer,
   processPdfContent
-} from "./chunk-EUOWCVU6.js";
+} from "./chunk-FSSUPWYO.js";
 import {
   SETTINGS_KEYS,
   getSetting,
   setSetting
-} from "./chunk-CTWZPN7G.js";
+} from "./chunk-QUAEH3MP.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -140,630 +151,9 @@ import {
   getGlobalConfigDir
 } from "./chunk-CQGTEGKL.js";
 
-// 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/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: getSetting2, SETTINGS_KEYS: SETTINGS_KEYS2 } = await import("./settings-ZJPM6PQV.js");
-      if (getSetting2(SETTINGS_KEYS2.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, handler2) {
-  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 handler2(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/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/tools/write.ts
 import { writeFile, mkdir } from "fs/promises";
-import { dirname, relative as relative3 } from "path";
+import { dirname, relative } from "path";
 
 // src/server/tools/diagnostics.ts
 function formatDiagnosticsForLLM(diagnostics) {
@@ -858,7 +248,7 @@ var writeFileTool = createTool(
     }
     const newHash = await computeFileHash(fullPath);
     if (newHash) {
-      context.sessionManager.updateFileHash(context.sessionId, fullPath, newHash, relative3(context.workdir, fullPath));
+      context.sessionManager.updateFileHash(context.sessionId, fullPath, newHash, relative(context.workdir, fullPath));
     }
     return helpers.success(output, false, {
       ...diagnostics.length > 0 && { diagnostics },
@@ -868,8 +258,8 @@ var writeFileTool = createTool(
 );
 
 // src/server/tools/edit.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { relative as relative4 } from "path";
+import { readFile, writeFile as writeFile2 } from "fs/promises";
+import { relative as relative2 } from "path";
 
 // src/server/tools/edit-context.ts
 var CONTEXT_LINES = 4;
@@ -1043,7 +433,7 @@ var editFileTool = createTool(
       }
       let rawBuffer;
       try {
-        rawBuffer = await readFile3(fullPath);
+        rawBuffer = await readFile(fullPath);
       } catch {
         return helpers.error(
           serverT({ en: "File not found: {{path}}", fr: "Fichier introuvable : {{path}}" }, { path: args.path })
@@ -1141,7 +531,7 @@ var editFileTool = createTool(
       }
       const newHash = await computeFileHash(fullPath);
       if (newHash) {
-        context.sessionManager.updateFileHash(context.sessionId, fullPath, newHash, relative4(context.workdir, fullPath));
+        context.sessionManager.updateFileHash(context.sessionId, fullPath, newHash, relative2(context.workdir, fullPath));
       }
       return helpers.success(output, false, {
         ...diagnostics.length > 0 && { diagnostics },
@@ -1154,7 +544,7 @@ var editFileTool = createTool(
 
 // src/server/tools/shell.ts
 import { spawn } from "child_process";
-import { resolve as resolve3, isAbsolute } from "path";
+import { resolve, isAbsolute } from "path";
 import { access } from "fs/promises";
 import stripAnsi from "strip-ansi";
 
@@ -1211,7 +601,7 @@ async function checkRtkAvailability() {
     rtkAvailable = true;
   } catch {
     try {
-      const out = await new Promise((resolve5, reject) => {
+      const out = await new Promise((resolve3, reject) => {
         const proc = spawn("rtk", ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
         let output = "";
         proc.stdout?.on("data", (d) => {
@@ -1219,7 +609,7 @@ async function checkRtkAvailability() {
         });
         proc.on("error", reject);
         proc.on("close", (code) => {
-          if (code === 0) resolve5(output.trim());
+          if (code === 0) resolve3(output.trim());
           else reject(new Error(`exit ${code}`));
         });
       });
@@ -1310,7 +700,7 @@ var runCommandTool = createTool(
     pathsToCheck.push(...resolveRelativeTraversals(args.command, workingDir));
     const sensitivePaths = extractSensitivePathsFromCommand(args.command);
     for (const sensitivePath of sensitivePaths) {
-      const resolved = isAbsolute(sensitivePath) ? sensitivePath : resolve3(workingDir, sensitivePath);
+      const resolved = isAbsolute(sensitivePath) ? sensitivePath : resolve(workingDir, sensitivePath);
       pathsToCheck.push(resolved);
     }
     await helpers.checkPathAccess(pathsToCheck, args.command);
@@ -1365,7 +755,7 @@ ${result.stderr}`;
 async function tryRtkRewrite(command) {
   if (!await checkRtkAvailability()) return command;
   try {
-    const result = await new Promise((resolve5, reject) => {
+    const result = await new Promise((resolve3, reject) => {
       const proc = spawn("rtk", ["rewrite", command], {
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 2e3
@@ -1376,7 +766,7 @@ async function tryRtkRewrite(command) {
       });
       proc.on("error", reject);
       proc.on("close", (code) => {
-        if (code === 0 || code === 3) resolve5(decodeUtf8(chunks).trim());
+        if (code === 0 || code === 3) resolve3(decodeUtf8(chunks).trim());
         else reject(new Error(`exit ${code}`));
       });
     });
@@ -1386,7 +776,7 @@ async function tryRtkRewrite(command) {
   return command;
 }
 function executeCommand(command, cwd, timeout, signal, onProgress) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve3, reject) => {
     if (checkAborted(signal)) {
       reject(new Error("Command aborted before execution"));
       return;
@@ -1422,7 +812,7 @@ function executeCommand(command, cwd, timeout, signal, onProgress) {
     });
     const settle = (exitCode, appendix) => {
       const out = (stdout + stdoutDecoder.end()).trim();
-      resolve5({
+      resolve3({
         stdout: appendix ? out ? `${out}
 
 ${appendix}` : appendix : out,
@@ -1678,8 +1068,8 @@ ${Object.entries(schema.fields).map(([f, t]) => `  ${f}: ${t}`).join("\n")}`
 );
 
 // src/server/sub-agents/manager.ts
-import { readFile as readFile4, access as access2 } from "fs/promises";
-import { join as join2, dirname as dirname2, isAbsolute as isAbsolute2 } from "path";
+import { readFile as readFile2, access as access2 } from "fs/promises";
+import { join, dirname as dirname2, isAbsolute as isAbsolute2 } from "path";
 
 // src/server/agents/model-overrides.ts
 import { z } from "zod";
@@ -1827,7 +1217,7 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
         data: { callId: error.callId, question: error.question, type: error.type, options: error.options }
       });
       append(createChatDoneEvent(assistantMsgId, "waiting_for_user"));
-      const { awaitAnswer } = await import("./ask-UBIRH3SO.js");
+      const { awaitAnswer } = await import("./ask-46J5WYRL.js");
       const answerPromise = awaitAnswer(error.callId);
       if (!answerPromise) {
         throw new Error(
@@ -2335,7 +1725,7 @@ ${CONTINUE_PROMPT}` : CONTINUE_PROMPT;
     currentMaxTokensOverride = void 0;
     if (!compacting) {
       const contextState = sessionManager.getContextState(sessionId);
-      const { shouldCompact, appendCompactionPrompt } = await import("./compactor-454UEIEX.js");
+      const { shouldCompact, appendCompactionPrompt } = await import("./compactor-LBK53WAK.js");
       if (shouldCompact(
         contextState.currentTokens,
         contextState.maxTokens,
@@ -2620,323 +2010,6 @@ function createAssemblyResult(input) {
   };
 }
 
-// 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) {
-  return context ? `${IMAGE_PROMPT}
-
-Context: ${context}` : IMAGE_PROMPT;
-}
-function buildOllamaRequest(base64Data, model, context) {
-  return {
-    model,
-    messages: [
-      {
-        role: "user",
-        content: buildPrompt(context),
-        images: [base64Data]
-      }
-    ],
-    stream: false,
-    think: false
-  };
-}
-function buildOpenAIRequest(base64Data, model, context) {
-  return {
-    model,
-    messages: [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: buildPrompt(context) },
-          { 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) : buildOllamaRequest(base64Data, visionModel.model, options?.context);
-    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);
-}
-
-// src/server/context/image-processor.ts
-async function loadVisionModelFromGlobalConfig() {
-  try {
-    const { loadGlobalConfig: loadGlobalConfig2, resolveVisionFallback } = await import("./config-LOK3LXFH.js");
-    const runtimeConfig = getRuntimeConfig();
-    const mode = runtimeConfig.mode ?? "production";
-    const globalConfig = await loadGlobalConfig2(mode);
-    return resolveVisionFallback(globalConfig);
-  } catch {
-  }
-  return void 0;
-}
-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/chat/conversation-history.ts
 function buildContextMessages(events, scope) {
   if (scope.type === "toplevel") {
@@ -3044,13 +2117,7 @@ async function processEventsForConversation(sessionId, llmClient, onEvent) {
   const eventStore = getEventStore();
   const rawEvents = eventStore.getEvents(sessionId);
   const modelVision = modelSupportsVision(llmClient.getModel());
-  const runtimeConfig = getRuntimeConfig();
-  const visionModel = runtimeConfig.llm?.visionModel ? {
-    baseUrl: runtimeConfig.llm.baseUrl,
-    model: runtimeConfig.llm.visionModel,
-    timeout: runtimeConfig.llm.timeout,
-    backend: runtimeConfig.llm.backend === "ollama" ? "ollama" : "openai"
-  } : await loadVisionModelFromGlobalConfig();
+  const visionModel = await loadResolvedVisionModel();
   const { events: processedEvents } = await processContextImages(rawEvents, {
     modelSupportsVision: modelVision,
     ...visionModel ? { visionModel } : {},
@@ -3088,10 +2155,10 @@ async function loadGitIgnoreRules(workdir) {
   if (!isAbsolute2(workdir)) return "";
   let currentDir = workdir;
   while (true) {
-    const gitignorePath = join2(currentDir, ".gitignore");
+    const gitignorePath = join(currentDir, ".gitignore");
     try {
       await access2(gitignorePath);
-      const content = await readFile4(gitignorePath, "utf-8");
+      const content = await readFile2(gitignorePath, "utf-8");
       const trimmed = content.trim();
       if (!trimmed) return "";
       const lines = trimmed.split("\n");
@@ -3374,7 +2441,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-E63MOJBO.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-EJOABHVO.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -3695,8 +2762,8 @@ var webFetchTool = createTool(
 
 // src/server/dev-server/manager.ts
 import "child_process";
-import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-import { resolve as resolve4, join as join3 } from "path";
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { resolve as resolve2, join as join2 } from "path";
 import net from "net";
 var MAX_LOG_LINES = 2e3;
 var MAX_LOG_BYTES = 1e5;
@@ -3704,7 +2771,7 @@ var DEFAULT_PROBE_PORT = 10469;
 var MAX_PORT_SCAN = 200;
 var PROBE_TIMEOUT_MS = 300;
 var getDevServerConfigPath = (workdir) => {
-  return join3(resolve4(workdir), ".openfox", "dev.json");
+  return join2(resolve2(workdir), ".openfox", "dev.json");
 };
 var ERROR_PATTERNS = [
   /EADDRINUSE/,
@@ -3753,7 +2820,7 @@ var DevServerManager = class {
     this._sessionManager = sm;
   }
   resolveWorkdir(workdir) {
-    return resolve4(workdir);
+    return resolve2(workdir);
   }
   getInstance(workdir) {
     const key = this.resolveWorkdir(workdir);
@@ -3828,7 +2895,7 @@ var DevServerManager = class {
     const tryLoad = async (dir) => {
       try {
         const configPath = getDevServerConfigPath(dir);
-        const raw = await readFile5(configPath, "utf-8");
+        const raw = await readFile3(configPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!parsed.command || !parsed.url) return null;
         return {
@@ -3854,7 +2921,7 @@ var DevServerManager = class {
   }
   async saveConfig(workdir, config) {
     const resolved = this.resolveWorkdir(workdir);
-    const dirPath = join3(resolved, ".openfox");
+    const dirPath = join2(resolved, ".openfox");
     await mkdir2(dirPath, { recursive: true });
     const configPath = getDevServerConfigPath(workdir);
     await writeFile3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
@@ -4478,11 +3545,11 @@ var mcpConfigTool = createTool(
     async function notifyContextChanged(sessionId) {
       context.sessionManager.setDynamicContextChanged(sessionId, true);
       mcpNotifyChanged?.(sessionId);
-      const { injectContextDriftReminders } = await import("./dynamic-context-LKC6JYLQ.js");
+      const { injectContextDriftReminders } = await import("./dynamic-context-RDBNQPPA.js");
       await injectContextDriftReminders(context.sessionManager, sessionId);
     }
     async function rebuildTools() {
-      const { setMcpTools: setMcpTools2 } = await import("./tools-E63MOJBO.js");
+      const { setMcpTools: setMcpTools2 } = await import("./tools-EJOABHVO.js");
       const mcpTools = createMcpTools(mcpManagerForTools);
       setMcpTools2(mcpTools);
     }
@@ -4491,7 +3558,7 @@ var mcpConfigTool = createTool(
       if (servers.length === 0) {
         return helpers.success(serverT({ en: "No MCP servers configured.", fr: "Aucun serveur MCP configur\xE9." }));
       }
-      const { getSessionDisabledServers: getSessionDisabledServers2 } = await import("./session-overrides-LYW5PJ3R.js");
+      const { getSessionDisabledServers: getSessionDisabledServers2 } = await import("./session-overrides-ANQBKV74.js");
       const disabledForSession = new Set(context.sessionId ? getSessionDisabledServers2(context.sessionId) : []);
       const visibleServers = servers.filter((server) => !disabledForSession.has(server.name));
       if (visibleServers.length === 0) {
@@ -5066,7 +4133,15 @@ var projectTasksTool = createTool(
           attachments: {
             type: "array",
             description: "Optional attachments (same shape as chat attachments)",
-            items: {}
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string", description: "Attachment ID" },
+                filename: { type: "string", description: "File name" },
+                mimeType: { type: "string", description: "MIME type" },
+                size: { type: "number", description: "File size in bytes" }
+              }
+            }
           },
           agentId: { type: "string", description: "Selected agent id" },
           providerId: { type: "string", description: "Provider id used when a session is spawned" },
@@ -5335,6 +4410,7 @@ function getBuiltInTools() {
   if (!_builtInTools) {
     _builtInTools = [
       readFileTool,
+      describeImageTool,
       writeFileTool,
       editFileTool,
       runCommandTool,
@@ -5615,4 +4691,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-ESZQTFQP.js.map
+//# sourceMappingURL=chunk-EXLCFEML.js.map