whale-code 6.5.5 → 6.5.6

package/dist/cli/services/server-tools.js

@@ -8,6 +8,7 @@
  * All business logic lives server-side — CLI is a thin client.
  * Claude formats the JSON results for the user (no client-side formatter).
  */
+
 import { createClient } from "@supabase/supabase-js";
 import { writeFileSync, readFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -18,226 +19,271 @@ import { tmpdir } from "node:os";
 import { resolveConfig } from "./config-store.js";
 import { getValidToken, createAuthenticatedClient } from "./auth-service.js";
 import { formatServerResponse } from "./format-server-response.js";
+
+// ============================================================================
+// EXECUTION CONTEXT — set by agent-loop before tool dispatch
+// Provides trace + user identity for server-side telemetry correlation.
+// ============================================================================
+
 let executionContext = {};
+
 /**
  * Set the execution context for server tool calls.
  * Called by agent-loop.ts before each turn so tool calls carry trace/user identity.
  */
 export function setServerToolContext(ctx) {
-    executionContext = ctx;
+  executionContext = ctx;
 }
 // ============================================================================
 // SUPABASE CLIENT (tiered: service role > user JWT)
 // Used only for loading tool definitions from ai_tool_registry.
 // Tool execution goes through the edge function.
 // ============================================================================
+
 let cachedClient = null;
 let cachedStoreId = "";
 let cachedAuthMethod = "none";
 let cachedToken = "";
 async function getSupabaseClient() {
-    const config = resolveConfig();
-    // Tier 1: Service role key (full access, MCP server mode) — never expires
-    if (config.supabaseUrl && config.supabaseKey) {
-        if (cachedClient && cachedAuthMethod === "service_role") {
-            return { client: cachedClient, storeId: cachedStoreId };
-        }
-        cachedClient = createClient(config.supabaseUrl, config.supabaseKey, {
-            auth: { persistSession: false, autoRefreshToken: false },
-        });
-        cachedStoreId = config.storeId || "";
-        cachedAuthMethod = "service_role";
-        return { client: cachedClient, storeId: cachedStoreId };
+  const config = resolveConfig();
+
+  // Tier 1: Service role key (full access, MCP server mode) — never expires
+  if (config.supabaseUrl && config.supabaseKey) {
+    if (cachedClient && cachedAuthMethod === "service_role") {
+      return {
+        client: cachedClient,
+        storeId: cachedStoreId
+      };
     }
-    // Tier 2: User JWT (CLI login) — recreate client when token refreshes
-    const token = await getValidToken();
-    if (token) {
-        if (cachedClient && cachedToken === token) {
-            cachedStoreId = config.storeId || "";
-            return { client: cachedClient, storeId: cachedStoreId };
-        }
-        cachedClient = createAuthenticatedClient(token);
-        cachedToken = token;
-        cachedStoreId = config.storeId || "";
-        cachedAuthMethod = "jwt";
-        return { client: cachedClient, storeId: cachedStoreId };
+    cachedClient = createClient(config.supabaseUrl, config.supabaseKey, {
+      auth: {
+        persistSession: false,
+        autoRefreshToken: false
+      }
+    });
+    cachedStoreId = config.storeId || "";
+    cachedAuthMethod = "service_role";
+    return {
+      client: cachedClient,
+      storeId: cachedStoreId
+    };
+  }
+
+  // Tier 2: User JWT (CLI login) — recreate client when token refreshes
+  const token = await getValidToken();
+  if (token) {
+    if (cachedClient && cachedToken === token) {
+      cachedStoreId = config.storeId || "";
+      return {
+        client: cachedClient,
+        storeId: cachedStoreId
+      };
     }
-    cachedClient = null;
-    cachedToken = "";
-    cachedAuthMethod = "none";
-    return null;
+    cachedClient = createAuthenticatedClient(token);
+    cachedToken = token;
+    cachedStoreId = config.storeId || "";
+    cachedAuthMethod = "jwt";
+    return {
+      client: cachedClient,
+      storeId: cachedStoreId
+    };
+  }
+  cachedClient = null;
+  cachedToken = "";
+  cachedAuthMethod = "none";
+  return null;
 }
 export function resetServerToolClient() {
-    cachedClient = null;
-    cachedStoreId = "";
-    cachedToken = "";
-    cachedAuthMethod = "none";
-    connectionVerified = false;
-    // Also clear tool cache so next load fetches fresh
-    loadedTools = [];
-    loadedToolNames.clear();
-    toolsLoadedAt = 0;
+  cachedClient = null;
+  cachedStoreId = "";
+  cachedToken = "";
+  cachedAuthMethod = "none";
+  connectionVerified = false;
+  // Also clear tool cache so next load fetches fresh
+  loadedTools = [];
+  loadedToolNames.clear();
+  toolsLoadedAt = 0;
 }
+
 // ============================================================================
 // CONNECTION CHECK
 // ============================================================================
+
 let connectionVerified = false;
 export async function checkConnection() {
-    if (connectionVerified)
-        return true;
-    const conn = await getSupabaseClient();
-    if (!conn)
-        return false;
-    try {
-        // Quick health check — query a small table
-        const { error } = await conn.client.from("stores").select("id").limit(1);
-        connectionVerified = !error;
-        return connectionVerified;
-    }
-    catch {
-        return false;
-    }
+  if (connectionVerified) return true;
+  const conn = await getSupabaseClient();
+  if (!conn) return false;
+  try {
+    // Quick health check — query a small table
+    const {
+      error
+    } = await conn.client.from("stores").select("id").limit(1);
+    connectionVerified = !error;
+    return connectionVerified;
+  } catch {
+    return false;
+  }
 }
+
 // ============================================================================
 // TOOL DEFINITIONS — loaded from ai_tool_registry (single source of truth)
 // ============================================================================
+
 let loadedTools = [];
 let loadedToolNames = new Set();
 let toolsLoadedAt = 0;
 const TOOL_CACHE_TTL = 60_000; // 1 minute
+
 /**
  * Load server tool definitions from ai_tool_registry.
  * Same query as the MCP server (index.ts). Cached for 60s.
  * Filters out tool_mode='code' (those are local CLI tools).
  */
 export async function loadServerToolDefinitions(force = false) {
-    // Return cache if fresh
-    if (!force && loadedTools.length > 0 && Date.now() - toolsLoadedAt < TOOL_CACHE_TTL) {
-        return loadedTools;
-    }
-    const conn = await getSupabaseClient();
-    if (!conn)
-        return [];
-    try {
-        const { data, error } = await conn.client
-            .from("ai_tool_registry")
-            .select("name, description, definition")
-            .eq("is_active", true)
-            .neq("tool_mode", "code");
-        if (error) {
-            console.error("[server-tools] Failed to load from ai_tool_registry:", error.message);
-            return loadedTools; // Return stale cache on error
-        }
-        loadedTools = (data || []).map(t => ({
-            name: t.name,
-            description: t.description || t.definition?.description || `Execute ${t.name}`,
-            input_schema: t.definition?.input_schema || { type: "object", properties: {} },
-        }));
-        // Rebuild the name set
-        loadedToolNames.clear();
-        for (const tool of loadedTools) {
-            loadedToolNames.add(tool.name);
-        }
-        toolsLoadedAt = Date.now();
-        connectionVerified = true;
-        return loadedTools;
+  // Return cache if fresh
+  if (!force && loadedTools.length > 0 && Date.now() - toolsLoadedAt < TOOL_CACHE_TTL) {
+    return loadedTools;
+  }
+  const conn = await getSupabaseClient();
+  if (!conn) return [];
+  try {
+    const {
+      data,
+      error
+    } = await conn.client.from("ai_tool_registry").select("name, description, definition").eq("is_active", true).neq("tool_mode", "code");
+    if (error) {
+      console.error("[server-tools] Failed to load from ai_tool_registry:", error.message);
+      return loadedTools; // Return stale cache on error
     }
-    catch (err) {
-        console.error("[server-tools] Error loading tool definitions:", err);
-        return loadedTools;
+    loadedTools = (data || []).map(t => ({
+      name: t.name,
+      description: t.description || t.definition?.description || `Execute ${t.name}`,
+      input_schema: t.definition?.input_schema || {
+        type: "object",
+        properties: {}
+      }
+    }));
+
+    // Rebuild the name set
+    loadedToolNames.clear();
+    for (const tool of loadedTools) {
+      loadedToolNames.add(tool.name);
     }
+    toolsLoadedAt = Date.now();
+    connectionVerified = true;
+    return loadedTools;
+  } catch (err) {
+    console.error("[server-tools] Error loading tool definitions:", err);
+    return loadedTools;
+  }
 }
+
 /**
  * Check if a tool name is a server tool.
  * After first load, checks against the dynamically loaded set.
  */
 export function isServerTool(name) {
-    return loadedToolNames.has(name);
+  return loadedToolNames.has(name);
 }
+
 /**
  * Get currently loaded definitions (for /tools listing).
  * Returns whatever is cached — call loadServerToolDefinitions() first to populate.
  */
 export function getAllServerToolDefinitions() {
-    return loadedTools;
+  return loadedTools;
 }
+
 // ============================================================================
 // SERVER STATUS
 // ============================================================================
+
 export async function getServerStatus() {
-    const { loadConfig } = await import("./config-store.js");
-    const config = loadConfig();
-    // Loading tools also verifies connection
-    const tools = await loadServerToolDefinitions();
-    return {
-        connected: tools.length > 0,
-        storeId: config.store_id || "",
-        storeName: config.store_name || "",
-        toolCount: tools.length,
-        authMethod: cachedAuthMethod,
-    };
+  const {
+    loadConfig
+  } = await import("./config-store.js");
+  const config = loadConfig();
+
+  // Loading tools also verifies connection
+  const tools = await loadServerToolDefinitions();
+  return {
+    connected: tools.length > 0,
+    storeId: config.store_id || "",
+    storeName: config.store_name || "",
+    toolCount: tools.length,
+    authMethod: cachedAuthMethod
+  };
 }
+
 // ============================================================================
 // EXECUTE SERVER TOOL — proxied to edge function
 // ============================================================================
+
 /** Media fields that contain base64-encoded binary data */
 const MEDIA_FIELDS = {
-    audio_base64: { ext: "mp3", label: "audio" },
-    stems_zip_base64: { ext: "zip", label: "stems" },
+  audio_base64: {
+    ext: "mp3",
+    label: "audio"
+  },
+  stems_zip_base64: {
+    ext: "zip",
+    label: "stems"
+  }
 };
+
 /** Tools that produce downloadable media files via file_url */
 const MEDIA_TOOLS = new Set(["voice", "image_gen", "video_gen"]);
+
 /**
  * Download a single file_url to a local path, replacing the URL in the data.
  * inputArgs is the original tool call args — used to derive descriptive filenames
  * when the result data doesn't include the text/prompt.
  */
 async function downloadSingleMedia(data, toolName, outDir, inputArgs) {
-    const fileUrl = data.file_url;
-    if (typeof fileUrl !== "string" || !fileUrl.startsWith("http"))
-        return;
-    // Derive a descriptive filename
-    // Check result data first, then fall back to input args for text/prompt
-    let label = "";
-    const text = (data.prompt || data.text || inputArgs?.text || inputArgs?.prompt);
-    if (text) {
-        label = text.substring(0, 40).replace(/[^a-zA-Z0-9]+/g, "-").replace(/-+$/, "").toLowerCase();
-    }
-    const action = data.action || inputArgs?.action || toolName;
-    // Detect format: explicit field > file extension from URL > tool-based default
-    let format = data.format;
-    if (!format) {
-        try {
-            const urlPath = new URL(fileUrl).pathname;
-            const urlExt = urlPath.split(".").pop();
-            if (urlExt && urlExt.length <= 4)
-                format = urlExt;
-        }
-        catch { /* invalid URL — use default */ }
-    }
-    if (!format)
-        format = toolName === "image_gen" ? "png" : toolName === "video_gen" ? "mp4" : "mp3";
-    const ts = Date.now();
-    const nameParts = [action, label, String(ts)].filter(Boolean);
-    const filename = `${nameParts.join("-")}.${format}`;
-    const localPath = join(outDir, filename);
+  const fileUrl = data.file_url;
+  if (typeof fileUrl !== "string" || !fileUrl.startsWith("http")) return;
+
+  // Derive a descriptive filename
+  // Check result data first, then fall back to input args for text/prompt
+  let label = "";
+  const text = data.prompt || data.text || inputArgs?.text || inputArgs?.prompt;
+  if (text) {
+    label = text.substring(0, 40).replace(/[^a-zA-Z0-9]+/g, "-").replace(/-+$/, "").toLowerCase();
+  }
+  const action = data.action || inputArgs?.action || toolName;
+  // Detect format: explicit field > file extension from URL > tool-based default
+  let format = data.format;
+  if (!format) {
     try {
-        const resp = await fetch(fileUrl);
-        if (!resp.ok) {
-            data.download_error = `Failed to download: HTTP ${resp.status}`;
-            return;
-        }
-        const buffer = Buffer.from(await resp.arrayBuffer());
-        writeFileSync(localPath, buffer);
-        // Keep file_url for downstream tools (email, workflows) that need public URLs
-        data.local_file = localPath;
-        data.file_size = buffer.length;
-        delete data.download;
-    }
-    catch (err) {
-        data.download_error = `Download failed: ${err.message || err}`;
+      const urlPath = new URL(fileUrl).pathname;
+      const urlExt = urlPath.split(".").pop();
+      if (urlExt && urlExt.length <= 4) format = urlExt;
+    } catch {/* invalid URL — use default */}
+  }
+  if (!format) format = toolName === "image_gen" ? "png" : toolName === "video_gen" ? "mp4" : "mp3";
+  const ts = Date.now();
+  const nameParts = [action, label, String(ts)].filter(Boolean);
+  const filename = `${nameParts.join("-")}.${format}`;
+  const localPath = join(outDir, filename);
+  try {
+    const resp = await fetch(fileUrl);
+    if (!resp.ok) {
+      data.download_error = `Failed to download: HTTP ${resp.status}`;
+      return;
     }
+    const buffer = Buffer.from(await resp.arrayBuffer());
+    writeFileSync(localPath, buffer);
+
+    // Keep file_url for downstream tools (email, workflows) that need public URLs
+    data.local_file = localPath;
+    data.file_size = buffer.length;
+    delete data.download;
+  } catch (err) {
+    data.download_error = `Download failed: ${err.message || err}`;
+  }
 }
+
 /**
  * Download remote media (file_url) to the user's working directory.
  * This ensures the LLM never needs to handle URLs — it just reports local paths.
@@ -247,79 +293,87 @@ async function downloadSingleMedia(data, toolName, outDir, inputArgs) {
  * (file_url inside images[] or previews[] arrays).
  */
 async function downloadRemoteMedia(data, toolName, inputArgs) {
-    // Save to cwd — the user's working directory, not a hidden temp folder
-    const outDir = process.cwd();
-    // Single file at top level (voice speak, image_gen generate, etc.)
-    if (typeof data.file_url === "string" && data.file_url.startsWith("http")) {
-        await downloadSingleMedia(data, toolName, outDir, inputArgs);
+  // Save to cwd — the user's working directory, not a hidden temp folder
+  const outDir = process.cwd();
+
+  // Single file at top level (voice speak, image_gen generate, etc.)
+  if (typeof data.file_url === "string" && data.file_url.startsWith("http")) {
+    await downloadSingleMedia(data, toolName, outDir, inputArgs);
+  }
+
+  // Batch arrays — image_gen batch returns images[], voice_design returns previews[]
+  if (Array.isArray(data.images)) {
+    for (const img of data.images) {
+      if (img && typeof img === "object" && typeof img.file_url === "string") {
+        await downloadSingleMedia(img, toolName, outDir);
+      }
     }
-    // Batch arrays — image_gen batch returns images[], voice_design returns previews[]
-    if (Array.isArray(data.images)) {
-        for (const img of data.images) {
-            if (img && typeof img === "object" && typeof img.file_url === "string") {
-                await downloadSingleMedia(img, toolName, outDir);
-            }
-        }
-    }
-    if (Array.isArray(data.previews)) {
-        for (const preview of data.previews) {
-            if (preview && typeof preview === "object" && typeof preview.file_url === "string") {
-                await downloadSingleMedia(preview, toolName, outDir);
-            }
-        }
+  }
+  if (Array.isArray(data.previews)) {
+    for (const preview of data.previews) {
+      if (preview && typeof preview === "object" && typeof preview.file_url === "string") {
+        await downloadSingleMedia(preview, toolName, outDir);
+      }
     }
+  }
 }
+
 /**
  * Extract base64 media from tool results, save to temp files, and replace
  * with file paths. This prevents truncation from destroying binary data
  * that the model needs to save for the user.
  */
 function extractMediaToFiles(data, toolName) {
-    const outDir = join(tmpdir(), "whale-audio");
-    let dirCreated = false;
-    for (const [field, { ext, label }] of Object.entries(MEDIA_FIELDS)) {
-        const b64 = data[field];
-        if (typeof b64 !== "string" || b64.length < 100)
-            continue;
-        if (!dirCreated) {
-            mkdirSync(outDir, { recursive: true });
-            dirCreated = true;
-        }
-        const ts = Date.now();
-        const filename = `${toolName}-${label}-${ts}.${ext}`;
-        const filePath = join(outDir, filename);
-        try {
-            writeFileSync(filePath, Buffer.from(b64, "base64"));
-            // Replace base64 with file path so model can reference it
-            data[field] = `(saved to ${filePath})`;
-            data[`${label}_file`] = filePath;
-        }
-        catch {
-            // Leave original data if write fails
-        }
+  const outDir = join(tmpdir(), "whale-audio");
+  let dirCreated = false;
+  for (const [field, {
+    ext,
+    label
+  }] of Object.entries(MEDIA_FIELDS)) {
+    const b64 = data[field];
+    if (typeof b64 !== "string" || b64.length < 100) continue;
+    if (!dirCreated) {
+      mkdirSync(outDir, {
+        recursive: true
+      });
+      dirCreated = true;
     }
-    // Handle voice_design previews array
-    if (Array.isArray(data.previews)) {
-        if (!dirCreated) {
-            mkdirSync(outDir, { recursive: true });
-        }
-        for (let i = 0; i < data.previews.length; i++) {
-            const preview = data.previews[i];
-            if (!preview?.audio_base64 || typeof preview.audio_base64 !== "string")
-                continue;
-            const ts = Date.now();
-            const filePath = join(outDir, `${toolName}-preview-${i}-${ts}.mp3`);
-            try {
-                writeFileSync(filePath, Buffer.from(preview.audio_base64, "base64"));
-                preview.audio_base64 = `(saved to ${filePath})`;
-                preview.audio_file = filePath;
-            }
-            catch {
-                // Leave original
-            }
-        }
+    const ts = Date.now();
+    const filename = `${toolName}-${label}-${ts}.${ext}`;
+    const filePath = join(outDir, filename);
+    try {
+      writeFileSync(filePath, Buffer.from(b64, "base64"));
+      // Replace base64 with file path so model can reference it
+      data[field] = `(saved to ${filePath})`;
+      data[`${label}_file`] = filePath;
+    } catch {
+      // Leave original data if write fails
+    }
+  }
+
+  // Handle voice_design previews array
+  if (Array.isArray(data.previews)) {
+    if (!dirCreated) {
+      mkdirSync(outDir, {
+        recursive: true
+      });
     }
+    for (let i = 0; i < data.previews.length; i++) {
+      const preview = data.previews[i];
+      if (!preview?.audio_base64 || typeof preview.audio_base64 !== "string") continue;
+      const ts = Date.now();
+      const filePath = join(outDir, `${toolName}-preview-${i}-${ts}.mp3`);
+      try {
+        writeFileSync(filePath, Buffer.from(preview.audio_base64, "base64"));
+        preview.audio_base64 = `(saved to ${filePath})`;
+        preview.audio_file = filePath;
+      } catch {
+        // Leave original
+      }
+    }
+  }
 }
+
 /**
  * Execute a server tool via the Fly.io server or Supabase edge function (mode: "tool").
  * Returns the raw JSON — Claude formats it for the user.
@@ -329,387 +383,506 @@ function extractMediaToFiles(data, toolName) {
  * and emits `tool_output` events via the optional emitter for real-time CLI rendering.
  */
 export async function executeServerTool(name, input, emitter) {
-    const config = resolveConfig();
-    if (!config.serverUrl) {
-        return { success: false, output: "No server URL configured — server tools unavailable." };
+  const config = resolveConfig();
+  if (!config.serverUrl) {
+    return {
+      success: false,
+      output: "No server URL configured — server tools unavailable."
+    };
+  }
+
+  // Auth token: service role key preferred, user JWT fallback
+  let authToken = config.supabaseKey;
+  if (!authToken) {
+    authToken = (await getValidToken()) || "";
+  }
+  if (!authToken) {
+    return {
+      success: false,
+      output: "No auth token — server tools unavailable. Run: whale login"
+    };
+  }
+
+  // ── Pre-process file_paths for voice tool ──
+  // Reads local files and base64-encodes them so the LLM never handles binary data.
+  // CRITICAL: We must NOT mutate `input` — the agent loop keeps a reference to it
+  // in the conversation history. If we inject base64 into `input`, it leaks into
+  // the LLM context and blows the 200K token limit.
+  let serverArgs = input;
+  if (name === "voice" && (input.file_paths || input.file_path)) {
+    let paths = [];
+    if (Array.isArray(input.file_paths)) {
+      paths = input.file_paths;
+    } else if (typeof input.file_path === "string") {
+      paths = [input.file_path];
     }
-    // Auth token: service role key preferred, user JWT fallback
-    let authToken = config.supabaseKey;
-    if (!authToken) {
-        authToken = await getValidToken() || "";
+    const MAX_TOTAL_BYTES = 7_000_000; // 7MB raw = ~9.3MB base64, under 10MB server limit
+    const MAX_SINGLE_FILE = 2_000_000; // 2MB per file (~2 min at 128kbps) — enough for good clone
+    const samples = [];
+    let totalBytes = 0;
+    for (const p of paths) {
+      try {
+        let buf = readFileSync(p);
+        // IVC: trim to 2MB per file. PVC: no trim (needs 30+ min for best quality)
+        const isPVC = input.action === "pvc_upload";
+        if (!isPVC && buf.length > MAX_SINGLE_FILE) {
+          buf = buf.subarray(0, MAX_SINGLE_FILE);
+        }
+        totalBytes += buf.length;
+        const maxTotal = isPVC ? 25_000_000 : MAX_TOTAL_BYTES;
+        if (totalBytes > maxTotal) break; // use what we have
+        samples.push(buf.toString("base64"));
+      } catch (err) {
+        // Skip unreadable files instead of killing the entire batch
+        continue;
+      }
     }
-    if (!authToken) {
-        return { success: false, output: "No auth token — server tools unavailable. Run: whale login" };
+    if (samples.length === 0) {
+      return {
+        success: false,
+        output: "No valid audio files found in the provided paths."
+      };
     }
-    // ── Pre-process file_paths for voice tool ──
-    // Reads local files and base64-encodes them so the LLM never handles binary data.
-    // CRITICAL: We must NOT mutate `input` — the agent loop keeps a reference to it
-    // in the conversation history. If we inject base64 into `input`, it leaks into
-    // the LLM context and blows the 200K token limit.
-    let serverArgs = input;
-    if (name === "voice" && (input.file_paths || input.file_path)) {
-        let paths = [];
-        if (Array.isArray(input.file_paths)) {
-            paths = input.file_paths;
-        }
-        else if (typeof input.file_path === "string") {
-            paths = [input.file_path];
-        }
-        const MAX_TOTAL_BYTES = 7_000_000; // 7MB raw = ~9.3MB base64, under 10MB server limit
-        const MAX_SINGLE_FILE = 2_000_000; // 2MB per file (~2 min at 128kbps) — enough for good clone
-        const samples = [];
-        let totalBytes = 0;
-        for (const p of paths) {
-            try {
-                let buf = readFileSync(p);
-                // IVC: trim to 2MB per file. PVC: no trim (needs 30+ min for best quality)
-                const isPVC = input.action === "pvc_upload";
-                if (!isPVC && buf.length > MAX_SINGLE_FILE) {
-                    buf = buf.subarray(0, MAX_SINGLE_FILE);
-                }
-                totalBytes += buf.length;
-                const maxTotal = isPVC ? 25_000_000 : MAX_TOTAL_BYTES;
-                if (totalBytes > maxTotal)
-                    break; // use what we have
-                samples.push(buf.toString("base64"));
-            }
-            catch (err) {
-                // Skip unreadable files instead of killing the entire batch
-                continue;
-            }
-        }
-        if (samples.length === 0) {
-            return { success: false, output: "No valid audio files found in the provided paths." };
-        }
-        // Build a SEPARATE args object for the server — never touch `input`
-        const { file_paths: _fp, file_path: _f, ...rest } = input;
-        serverArgs = { ...rest };
-        if (input.action === "clone_voice" || input.action === "pvc_upload") {
-            serverArgs.audio_samples = samples;
-        }
-        else if (input.action === "voice_design") {
-            serverArgs.reference_audio_base64 = samples[0];
-        }
-        else {
-            serverArgs.audio_base64 = samples[0];
-        }
+
+    // Build a SEPARATE args object for the server — never touch `input`
+    const {
+      file_paths: _fp,
+      file_path: _f,
+      ...rest
+    } = input;
+    serverArgs = {
+      ...rest
+    };
+    if (input.action === "clone_voice" || input.action === "pvc_upload") {
+      serverArgs.audio_samples = samples;
+    } else if (input.action === "voice_design") {
+      serverArgs.reference_audio_base64 = samples[0];
+    } else {
+      serverArgs.audio_base64 = samples[0];
     }
-    // ── Pre-process file_path(s) for media upload tool ──
-    // Same pattern as voice: read local files in-process so base64 never flows
-    // through shell output (which truncates at ~100K chars) or conversation context.
-    // Also intercept file_url that's actually a local path (agents confuse the two).
-    if (name === "media" && (input.action === "upload" || input.action === "bulk_upload")) {
-        const fileUrl = input.file_url;
-        if (fileUrl && (fileUrl.startsWith("/") || /^[A-Z]:\\/i.test(fileUrl)) && !input.file_path && !input.file_paths) {
-            input = { ...input, file_path: fileUrl };
-            delete input.file_url;
-        }
+  }
+
+  // ── Pre-process file_path(s) for media upload tool ──
+  // Same pattern as voice: read local files in-process so base64 never flows
+  // through shell output (which truncates at ~100K chars) or conversation context.
+  // Also intercept file_url that's actually a local path (agents confuse the two).
+  if (name === "media" && (input.action === "upload" || input.action === "bulk_upload")) {
+    const fileUrl = input.file_url;
+    if (fileUrl && (fileUrl.startsWith("/") || /^[A-Z]:\\/i.test(fileUrl)) && !input.file_path && !input.file_paths) {
+      input = {
+        ...input,
+        file_path: fileUrl
+      };
+      delete input.file_url;
     }
-    if (name === "media" && (input.action === "upload" || input.action === "bulk_upload") && (input.file_path || input.file_paths)) {
-        let paths = [];
-        if (Array.isArray(input.file_paths)) {
-            paths = input.file_paths;
-        }
-        else if (typeof input.file_path === "string") {
-            paths = [input.file_path];
-        }
-        if (paths.length > 0) {
-            const MAX_FILE_SIZE = 10_000_000; // 10MB per file
-            const MAX_BATCH_BYTES = 50_000_000; // 50MB total batch
-            const MAX_BATCH_COUNT = 50;
-            if (paths.length === 1) {
-                // ── Single file → standard upload action ──
-                const filePath = paths[0];
-                try {
-                    const buf = readFileSync(filePath);
-                    if (buf.length > MAX_FILE_SIZE) {
-                        return { success: false, output: `File too large: ${(buf.length / 1_000_000).toFixed(1)}MB (max 10MB). Compress or resize first.` };
-                    }
-                    const { file_path: _fp, file_paths: _fps, ...rest } = input;
-                    serverArgs = { ...rest, action: "upload", base64: buf.toString("base64") };
-                    if (!serverArgs.file_name) {
-                        const basename = filePath.split("/").pop() || filePath.split("\\").pop() || "";
-                        if (basename)
-                            serverArgs.file_name = basename;
-                    }
-                }
-                catch (err) {
-                    return { success: false, output: `Cannot read file "${filePath}": ${err.message || err}` };
-                }
-            }
-            else {
-                // ── Multiple files → bulk_upload action ──
-                const files = [];
-                const errors = [];
-                let totalBytes = 0;
-                for (const filePath of paths.slice(0, MAX_BATCH_COUNT)) {
-                    try {
-                        const buf = readFileSync(filePath);
-                        if (buf.length > MAX_FILE_SIZE) {
-                            errors.push(`${filePath.split("/").pop()}: ${(buf.length / 1_000_000).toFixed(1)}MB exceeds 10MB limit, skipped`);
-                            continue;
-                        }
-                        totalBytes += buf.length;
-                        if (totalBytes > MAX_BATCH_BYTES) {
-                            errors.push(`Batch limit reached (50MB) — remaining files skipped`);
-                            break;
-                        }
-                        const basename = filePath.split("/").pop() || filePath.split("\\").pop() || "file";
-                        files.push({ base64: buf.toString("base64"), file_name: basename });
-                    }
-                    catch (err) {
-                        errors.push(`${filePath.split("/").pop()}: ${err.message || "unreadable"}`);
-                    }
-                }
-                if (paths.length > MAX_BATCH_COUNT) {
-                    errors.push(`Only first ${MAX_BATCH_COUNT} files processed (${paths.length} provided)`);
-                }
-                if (files.length === 0) {
-                    return { success: false, output: `No valid files to upload. Errors:\n${errors.join("\n")}` };
-                }
-                const { file_path: _fp, file_paths: _fps, ...rest } = input;
-                serverArgs = { ...rest, action: "bulk_upload", files, _read_errors: errors.length > 0 ? errors : undefined };
-            }
-        }
+  }
+  if (name === "media" && (input.action === "upload" || input.action === "bulk_upload") && (input.file_path || input.file_paths)) {
+    let paths = [];
+    if (Array.isArray(input.file_paths)) {
+      paths = input.file_paths;
+    } else if (typeof input.file_path === "string") {
+      paths = [input.file_path];
     }
-    // ── Pre-process file_path for media replace tool ──
-    // Same pattern as upload: read local file in-process, base64-encode for server.
-    if (name === "media" && input.action === "replace" && (input.file_path || (typeof input.file_url === "string" && input.file_url.startsWith("/")))) {
-        const localPath = (input.file_path || input.file_url);
+    if (paths.length > 0) {
+      const MAX_FILE_SIZE = 10_000_000; // 10MB per file
+      const MAX_BATCH_BYTES = 50_000_000; // 50MB total batch
+      const MAX_BATCH_COUNT = 50;
+      if (paths.length === 1) {
+        // ── Single file → standard upload action ──
+        const filePath = paths[0];
         try {
-            const buf = readFileSync(localPath);
-            if (buf.length > 10_000_000) {
-                return { success: false, output: `File too large: ${(buf.length / 1_000_000).toFixed(1)}MB (max 10MB). Compress or resize first.` };
+          const buf = readFileSync(filePath);
+          if (buf.length > MAX_FILE_SIZE) {
+            return {
+              success: false,
+              output: `File too large: ${(buf.length / 1_000_000).toFixed(1)}MB (max 10MB). Compress or resize first.`
+            };
+          }
+          const {
+            file_path: _fp,
+            file_paths: _fps,
+            ...rest
+          } = input;
+          serverArgs = {
+            ...rest,
+            action: "upload",
+            base64: buf.toString("base64")
+          };
+          if (!serverArgs.file_name) {
+            const basename = filePath.split("/").pop() || filePath.split("\\").pop() || "";
+            if (basename) serverArgs.file_name = basename;
+          }
+        } catch (err) {
+          return {
+            success: false,
+            output: `Cannot read file "${filePath}": ${err.message || err}`
+          };
+        }
+      } else {
+        // ── Multiple files → bulk_upload action ──
+        const files = [];
+        const errors = [];
+        let totalBytes = 0;
+        for (const filePath of paths.slice(0, MAX_BATCH_COUNT)) {
+          try {
+            const buf = readFileSync(filePath);
+            if (buf.length > MAX_FILE_SIZE) {
+              errors.push(`${filePath.split("/").pop()}: ${(buf.length / 1_000_000).toFixed(1)}MB exceeds 10MB limit, skipped`);
+              continue;
             }
-            const { file_path: _fp, file_url: _fu, ...rest } = input;
-            serverArgs = { ...rest, base64: buf.toString("base64") };
-            if (!serverArgs.file_name) {
-                const basename = localPath.split("/").pop() || localPath.split("\\").pop() || "";
-                if (basename)
-                    serverArgs.file_name = basename;
+            totalBytes += buf.length;
+            if (totalBytes > MAX_BATCH_BYTES) {
+              errors.push(`Batch limit reached (50MB) — remaining files skipped`);
+              break;
             }
-        }
-        catch (err) {
-            return { success: false, output: `Cannot read file "${localPath}": ${err.message || err}` };
-        }
+            const basename = filePath.split("/").pop() || filePath.split("\\").pop() || "file";
+            files.push({
+              base64: buf.toString("base64"),
+              file_name: basename
+            });
+          } catch (err) {
+            errors.push(`${filePath.split("/").pop()}: ${err.message || "unreadable"}`);
+          }
+        }
+        if (paths.length > MAX_BATCH_COUNT) {
+          errors.push(`Only first ${MAX_BATCH_COUNT} files processed (${paths.length} provided)`);
+        }
+        if (files.length === 0) {
+          return {
+            success: false,
+            output: `No valid files to upload. Errors:\n${errors.join("\n")}`
+          };
+        }
+        const {
+          file_path: _fp,
+          file_paths: _fps,
+          ...rest
+        } = input;
+        serverArgs = {
+          ...rest,
+          action: "bulk_upload",
+          files,
+          _read_errors: errors.length > 0 ? errors : undefined
+        };
+      }
     }
-    // ── Pre-process image_path for remove_bg tool ──
-    // Same pattern: read local image, send as image_base64.
-    if (name === "remove_bg" && (input.image_path || (typeof input.image_url === "string" && input.image_url.startsWith("/")))) {
-        const imgPath = (input.image_path || input.image_url);
-        try {
-            const buf = readFileSync(imgPath);
-            if (buf.length > 10_000_000) {
-                return { success: false, output: `Image too large: ${(buf.length / 1_000_000).toFixed(1)}MB (max 10MB).` };
-            }
-            const { image_path: _ip, image_url: _iu, ...rest } = input;
-            serverArgs = { ...rest, image_base64: buf.toString("base64") };
-        }
-        catch (err) {
-            return { success: false, output: `Cannot read image "${imgPath}": ${err.message || err}` };
-        }
+  }
+
+  // ── Pre-process file_path for media replace tool ──
+  // Same pattern as upload: read local file in-process, base64-encode for server.
+  if (name === "media" && input.action === "replace" && (input.file_path || typeof input.file_url === "string" && input.file_url.startsWith("/"))) {
+    const localPath = input.file_path || input.file_url;
+    try {
+      const buf = readFileSync(localPath);
+      if (buf.length > 10_000_000) {
+        return {
+          success: false,
+          output: `File too large: ${(buf.length / 1_000_000).toFixed(1)}MB (max 10MB). Compress or resize first.`
+        };
+      }
+      const {
+        file_path: _fp,
+        file_url: _fu,
+        ...rest
+      } = input;
+      serverArgs = {
+        ...rest,
+        base64: buf.toString("base64")
+      };
+      if (!serverArgs.file_name) {
+        const basename = localPath.split("/").pop() || localPath.split("\\").pop() || "";
+        if (basename) serverArgs.file_name = basename;
+      }
+    } catch (err) {
+      return {
+        success: false,
+        output: `Cannot read file "${localPath}": ${err.message || err}`
+      };
     }
-    // ── Pre-process file_path in email attachments ──
-    // Reads local files referenced in attachments[].file_path, converts to base64 content.
-    if (name === "email" && input.action === "send" && Array.isArray(input.attachments)) {
-        const rawAtts = input.attachments;
-        const hasLocalFiles = rawAtts.some(a => a.file_path || (typeof a.url === "string" && a.url.startsWith("/")));
-        if (hasLocalFiles) {
-            const processed = [];
-            for (const att of rawAtts) {
-                const localPath = att.file_path || (typeof att.url === "string" && att.url.startsWith("/") ? att.url : null);
-                if (localPath) {
-                    try {
-                        const buf = readFileSync(localPath);
-                        if (buf.length > 10_000_000) {
-                            return { success: false, output: `Attachment too large: ${localPath.split("/").pop()} is ${(buf.length / 1_000_000).toFixed(1)}MB (max 10MB).` };
-                        }
-                        const filename = att.filename || localPath.split("/").pop() || "attachment";
-                        processed.push({ filename, content: buf.toString("base64") });
-                    }
-                    catch (err) {
-                        return { success: false, output: `Cannot read attachment "${localPath}": ${err.message || err}` };
-                    }
-                }
-                else if (att.content && att.filename) {
-                    processed.push({ filename: att.filename, content: att.content });
-                }
-                else if (att.url && att.filename) {
-                    processed.push(att); // URL-based, let server fetch it
-                }
-            }
-            const { attachments: _a, ...rest } = input;
-            serverArgs = { ...rest, attachments: processed };
-        }
+  }
+
+  // ── Pre-process image_path for remove_bg tool ──
+  // Same pattern: read local image, send as image_base64.
+  if (name === "remove_bg" && (input.image_path || typeof input.image_url === "string" && input.image_url.startsWith("/"))) {
+    const imgPath = input.image_path || input.image_url;
+    try {
+      const buf = readFileSync(imgPath);
+      if (buf.length > 10_000_000) {
+        return {
+          success: false,
+          output: `Image too large: ${(buf.length / 1_000_000).toFixed(1)}MB (max 10MB).`
+        };
+      }
+      const {
+        image_path: _ip,
+        image_url: _iu,
+        ...rest
+      } = input;
+      serverArgs = {
+        ...rest,
+        image_base64: buf.toString("base64")
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Cannot read image "${imgPath}": ${err.message || err}`
+      };
     }
-    // ── Pre-process file_path for kali upload ──
-    // Reads local file and sends content as base64 to the kali box.
-    if (name === "kali" && input.action === "upload" && (input.file_path || input.local_path)) {
-        const localPath = (input.file_path || input.local_path);
-        if (localPath && !input.content) {
-            try {
-                const buf = readFileSync(localPath);
-                if (buf.length > 50_000_000) {
-                    return { success: false, output: `File too large for kali upload: ${(buf.length / 1_000_000).toFixed(1)}MB (max 50MB).` };
-                }
-                const { file_path: _fp, local_path: _lp, ...rest } = input;
-                serverArgs = { ...rest, content: buf.toString("base64"), encoding: "base64" };
-                // Auto-set remote path from filename if not provided
-                if (!serverArgs.path) {
-                    const basename = localPath.split("/").pop() || "upload";
-                    serverArgs.path = `/tmp/${basename}`;
-                }
-            }
-            catch (err) {
-                return { success: false, output: `Cannot read file "${localPath}": ${err.message || err}` };
+  }
+
+  // ── Pre-process file_path in email attachments ──
+  // Reads local files referenced in attachments[].file_path, converts to base64 content.
+  if (name === "email" && input.action === "send" && Array.isArray(input.attachments)) {
+    const rawAtts = input.attachments;
+    const hasLocalFiles = rawAtts.some(a => a.file_path || typeof a.url === "string" && a.url.startsWith("/"));
+    if (hasLocalFiles) {
+      const processed = [];
+      for (const att of rawAtts) {
+        const localPath = att.file_path || (typeof att.url === "string" && att.url.startsWith("/") ? att.url : null);
+        if (localPath) {
+          try {
+            const buf = readFileSync(localPath);
+            if (buf.length > 10_000_000) {
+              return {
+                success: false,
+                output: `Attachment too large: ${localPath.split("/").pop()} is ${(buf.length / 1_000_000).toFixed(1)}MB (max 10MB).`
+              };
             }
-        }
-    }
-    // ── Streaming path for kali exec actions ──
-    // Uses NDJSON streaming to show live stdout/stderr in the CLI while the command runs.
-    const isStreamable = name === "kali" && emitter &&
-        (input.action === "exec" || input.action === "exec_stream");
-    if (isStreamable) {
-        try {
-            const serverUrl = config.serverUrl;
-            const response = await fetch(serverUrl, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "Authorization": `Bearer ${authToken}`,
-                },
-                body: JSON.stringify({
-                    mode: "tool_stream",
-                    tool_name: name,
-                    args: serverArgs,
-                    store_id: config.storeId || undefined,
-                    trace_id: executionContext.traceId || undefined,
-                    conversation_id: executionContext.conversationId || undefined,
-                    userId: executionContext.userId || undefined,
-                    userEmail: executionContext.userEmail || undefined,
-                    source: executionContext.source || "whale-code",
-                }),
+            const filename = att.filename || localPath.split("/").pop() || "attachment";
+            processed.push({
+              filename,
+              content: buf.toString("base64")
             });
-            if (!response.ok) {
-                const text = await response.text().catch(() => "");
-                return { success: false, output: `Server tool stream error: HTTP ${response.status}: ${text.substring(0, 500)}` };
-            }
-            if (!response.body) {
-                return { success: false, output: "Server returned no response body for tool_stream" };
-            }
-            // Read NDJSON stream — emit progress events, collect final result
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            let buffer = "";
-            let finalResult = null;
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                let newlineIdx;
-                while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
-                    const line = buffer.substring(0, newlineIdx).trim();
-                    buffer = buffer.substring(newlineIdx + 1);
-                    if (!line)
-                        continue;
-                    try {
-                        const parsed = JSON.parse(line);
-                        if (parsed.type === "progress" && parsed.progress) {
-                            const p = parsed.progress;
-                            if ((p.type === "stdout" || p.type === "stderr") && p.data) {
-                                emitter.emitToolOutput(name, p.data);
-                            }
-                        }
-                        else if (parsed.type === "status" && parsed.progress) {
-                            emitter.emitToolProgress(name, parsed.progress);
-                        }
-                        else if (parsed.type === "result") {
-                            finalResult = parsed;
-                        }
-                    }
-                    catch { /* skip malformed lines */ }
-                }
-            }
-            // Process remaining buffer
-            const remaining = buffer.trim();
-            if (remaining) {
-                try {
-                    const parsed = JSON.parse(remaining);
-                    if (parsed.type === "result")
-                        finalResult = parsed;
-                }
-                catch { /* skip */ }
-            }
-            if (finalResult) {
-                if (finalResult.success && finalResult.data) {
-                    const output = typeof finalResult.data === "string"
-                        ? finalResult.data
-                        : formatServerResponse(finalResult.data, name);
-                    return { success: true, output };
-                }
-                return { success: false, output: finalResult.error || `Server tool "${name}" returned success=false` };
-            }
-            return { success: false, output: "No result received from streaming tool execution" };
-        }
-        catch (err) {
-            return { success: false, output: `Server tool stream error: ${err.message || err}` };
-        }
+          } catch (err) {
+            return {
+              success: false,
+              output: `Cannot read attachment "${localPath}": ${err.message || err}`
+            };
+          }
+        } else if (att.content && att.filename) {
+          processed.push({
+            filename: att.filename,
+            content: att.content
+          });
+        } else if (att.url && att.filename) {
+          processed.push(att); // URL-based, let server fetch it
+        }
+      }
+      const {
+        attachments: _a,
+        ...rest
+      } = input;
+      serverArgs = {
+        ...rest,
+        attachments: processed
+      };
     }
-    // ── Standard path: non-streaming tools ──
+  }
+
+  // ── Pre-process file_path for kali upload ──
+  // Reads local file and sends content as base64 to the kali box.
+  if (name === "kali" && input.action === "upload" && (input.file_path || input.local_path)) {
+    const localPath = input.file_path || input.local_path;
+    if (localPath && !input.content) {
+      try {
+        const buf = readFileSync(localPath);
+        if (buf.length > 50_000_000) {
+          return {
+            success: false,
+            output: `File too large for kali upload: ${(buf.length / 1_000_000).toFixed(1)}MB (max 50MB).`
+          };
+        }
+        const {
+          file_path: _fp,
+          local_path: _lp,
+          ...rest
+        } = input;
+        serverArgs = {
+          ...rest,
+          content: buf.toString("base64"),
+          encoding: "base64"
+        };
+        // Auto-set remote path from filename if not provided
+        if (!serverArgs.path) {
+          const basename = localPath.split("/").pop() || "upload";
+          serverArgs.path = `/tmp/${basename}`;
+        }
+      } catch (err) {
+        return {
+          success: false,
+          output: `Cannot read file "${localPath}": ${err.message || err}`
+        };
+      }
+    }
+  }
+
+  // ── Streaming path for kali exec actions ──
+  // Uses NDJSON streaming to show live stdout/stderr in the CLI while the command runs.
+  const isStreamable = name === "kali" && emitter && (input.action === "exec" || input.action === "exec_stream");
+  if (isStreamable) {
     try {
-        const serverUrl = config.serverUrl;
-        const response = await fetch(serverUrl, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${authToken}`,
-            },
-            body: JSON.stringify({
-                mode: "tool",
-                tool_name: name,
-                args: serverArgs,
-                store_id: config.storeId || undefined,
-                trace_id: executionContext.traceId || undefined,
-                conversation_id: executionContext.conversationId || undefined,
-                userId: executionContext.userId || undefined,
-                userEmail: executionContext.userEmail || undefined,
-                source: executionContext.source || "whale-code",
-            }),
+      const serverUrl = config.serverUrl;
+      const response = await fetch(serverUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${authToken}`
+        },
+        body: JSON.stringify({
+          mode: "tool_stream",
+          tool_name: name,
+          args: serverArgs,
+          store_id: config.storeId || undefined,
+          trace_id: executionContext.traceId || undefined,
+          conversation_id: executionContext.conversationId || undefined,
+          userId: executionContext.userId || undefined,
+          userEmail: executionContext.userEmail || undefined,
+          source: executionContext.source || "whale-code"
+        })
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        return {
+          success: false,
+          output: `Server tool stream error: HTTP ${response.status}: ${text.substring(0, 500)}`
+        };
+      }
+      if (!response.body) {
+        return {
+          success: false,
+          output: "Server returned no response body for tool_stream"
+        };
+      }
+
+      // Read NDJSON stream — emit progress events, collect final result
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let finalResult = null;
+      while (true) {
+        const {
+          done,
+          value
+        } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, {
+          stream: true
         });
-        const result = await response.json();
-        if (result.success) {
-            if (result.data && typeof result.data === "object") {
-                const dataObj = result.data;
-                // Auto-download remote media files to local temp paths
-                if (MEDIA_TOOLS.has(name)) {
-                    await downloadRemoteMedia(dataObj, name, input);
-                }
-                // Legacy: extract base64 media to temp files
-                extractMediaToFiles(dataObj, name);
-            }
-            let output = typeof result.data === "string"
-                ? result.data
-                : formatServerResponse(result.data, name);
-            // Safety cap only — Anthropic context_management handles normal limits.
-            // Old limit was 30K which caused constant truncation and extra tool calls.
-            const SAFETY_MAX_SERVER_CHARS = 500_000;
-            if (output.length > SAFETY_MAX_SERVER_CHARS) {
-                output = output.slice(0, SAFETY_MAX_SERVER_CHARS)
-                    + `\n\n... (safety truncated — ${output.length.toLocaleString()} chars total)`;
+        let newlineIdx;
+        while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.substring(0, newlineIdx).trim();
+          buffer = buffer.substring(newlineIdx + 1);
+          if (!line) continue;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed.type === "progress" && parsed.progress) {
+              const p = parsed.progress;
+              if ((p.type === "stdout" || p.type === "stderr") && p.data) {
+                emitter.emitToolOutput(name, p.data);
+              }
+            } else if (parsed.type === "status" && parsed.progress) {
+              emitter.emitToolProgress(name, parsed.progress);
+            } else if (parsed.type === "result") {
+              finalResult = parsed;
             }
-            return { success: true, output };
-        }
-        // Extract error from nested data if top-level error is missing
-        let errorMsg = result.error;
-        if (!errorMsg && result.data && typeof result.data === "object") {
-            const nested = result.data.error;
-            if (typeof nested === "string")
-                errorMsg = nested;
+          } catch {/* skip malformed lines */}
         }
-        return { success: false, output: errorMsg || `Server tool "${name}" returned success=false with no error message` };
+      }
+
+      // Process remaining buffer
+      const remaining = buffer.trim();
+      if (remaining) {
+        try {
+          const parsed = JSON.parse(remaining);
+          if (parsed.type === "result") finalResult = parsed;
+        } catch {/* skip */}
+      }
+      if (finalResult) {
+        if (finalResult.success && finalResult.data) {
+          const output = typeof finalResult.data === "string" ? finalResult.data : formatServerResponse(finalResult.data, name);
+          return {
+            success: true,
+            output
+          };
+        }
+        return {
+          success: false,
+          output: finalResult.error || `Server tool "${name}" returned success=false`
+        };
+      }
+      return {
+        success: false,
+        output: "No result received from streaming tool execution"
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Server tool stream error: ${err.message || err}`
+      };
+    }
+  }
+
+  // ── Standard path: non-streaming tools ──
+  try {
+    const serverUrl = config.serverUrl;
+    const response = await fetch(serverUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${authToken}`
+      },
+      body: JSON.stringify({
+        mode: "tool",
+        tool_name: name,
+        args: serverArgs,
+        store_id: config.storeId || undefined,
+        trace_id: executionContext.traceId || undefined,
+        conversation_id: executionContext.conversationId || undefined,
+        userId: executionContext.userId || undefined,
+        userEmail: executionContext.userEmail || undefined,
+        source: executionContext.source || "whale-code"
+      })
+    });
+    const result = await response.json();
+    if (result.success) {
+      if (result.data && typeof result.data === "object") {
+        const dataObj = result.data;
+        // Auto-download remote media files to local temp paths
+        if (MEDIA_TOOLS.has(name)) {
+          await downloadRemoteMedia(dataObj, name, input);
+        }
+        // Legacy: extract base64 media to temp files
+        extractMediaToFiles(dataObj, name);
+      }
+      let output = typeof result.data === "string" ? result.data : formatServerResponse(result.data, name);
+
+      // Safety cap only — Anthropic context_management handles normal limits.
+      // Old limit was 30K which caused constant truncation and extra tool calls.
+      const SAFETY_MAX_SERVER_CHARS = 500_000;
+      if (output.length > SAFETY_MAX_SERVER_CHARS) {
+        output = output.slice(0, SAFETY_MAX_SERVER_CHARS) + `\n\n... (safety truncated — ${output.length.toLocaleString()} chars total)`;
+      }
+      return {
+        success: true,
+        output
+      };
     }
-    catch (err) {
-        return { success: false, output: `Server tool error: ${err.message || err}` };
+
+    // Extract error from nested data if top-level error is missing
+    let errorMsg = result.error;
+    if (!errorMsg && result.data && typeof result.data === "object") {
+      const nested = result.data.error;
+      if (typeof nested === "string") errorMsg = nested;
     }
+    return {
+      success: false,
+      output: errorMsg || `Server tool "${name}" returned success=false with no error message`
+    };
+  } catch (err) {
+    return {
+      success: false,
+      output: `Server tool error: ${err.message || err}`
+    };
+  }
 }
+//# sourceMappingURL=server-tools.js.map