whale-code 6.5.6 → 6.5.8

package/dist/server/__tests__/strip-base64.test.js

@@ -0,0 +1,256 @@
+/**
+ * Tests for stripLargeBase64Fields — the function that prunes old base64
+ * image data from conversation JSON before JSON.parse.
+ *
+ * Extracted here as a standalone copy so we can verify the logic end-to-end
+ * without needing to spin up an HTTP server.
+ */
+import { describe, it, expect } from "vitest";
+
+// ── Exact copy of the production function from index.ts ──────────────────────
+function stripLargeBase64Fields(raw, keepFrom) {
+  const MIN_DATA_LEN = 8_000;
+
+  // Pass 1: Strip "data":"<large base64>" fields
+  let result = raw;
+  {
+    const DATA_MARKER = '"data":"';
+    const parts = [];
+    let pos = 0;
+    while (pos < keepFrom) {
+      const idx = result.indexOf(DATA_MARKER, pos);
+      if (idx === -1 || idx >= keepFrom) {
+        parts.push(result.slice(pos, keepFrom));
+        pos = keepFrom;
+        break;
+      }
+      parts.push(result.slice(pos, idx + DATA_MARKER.length));
+      pos = idx + DATA_MARKER.length;
+      let end = pos;
+      while (end < result.length && result[end] !== '"') end++;
+      if (end - pos >= MIN_DATA_LEN && end <= keepFrom) {
+        parts.push('"');
+        pos = end + 1; // skip past the original closing quote (already replaced)
+      }
+    }
+    parts.push(result.slice(keepFrom));
+    result = parts.join("");
+  }
+
+  // Pass 2: Strip __IMAGE__ text markers
+  {
+    const IMG_MARKER = "__IMAGE__";
+    const adjustedKeepFrom = Math.min(keepFrom, result.length);
+    const parts = [];
+    let pos = 0;
+    while (pos < adjustedKeepFrom) {
+      const idx = result.indexOf(IMG_MARKER, pos);
+      if (idx === -1 || idx >= adjustedKeepFrom) {
+        parts.push(result.slice(pos, adjustedKeepFrom));
+        pos = adjustedKeepFrom;
+        break;
+      }
+      parts.push(result.slice(pos, idx));
+      let end = idx;
+      while (end < result.length && result[end] !== '"') end++;
+      if (end - idx >= MIN_DATA_LEN && end <= adjustedKeepFrom) {
+        parts.push("[image pruned]");
+        pos = end;
+      } else {
+        parts.push(result.slice(idx, idx + IMG_MARKER.length));
+        pos = idx + IMG_MARKER.length;
+      }
+    }
+    parts.push(result.slice(adjustedKeepFrom));
+    result = parts.join("");
+  }
+  return result;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/** Generate a fake base64 string of a given length */
+function fakeBase64(len) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  return Array.from({
+    length: len
+  }, (_, i) => chars[i % chars.length]).join("");
+}
+
+/** Build an Anthropic-style conversation body with image content blocks */
+function buildConversationBody(imageCount, imageSize) {
+  const messages = [];
+
+  // Assistant turn with tool_use blocks
+  const toolUses = Array.from({
+    length: imageCount
+  }, (_, i) => ({
+    type: "tool_use",
+    id: `toolu_${i}`,
+    name: "read",
+    input: {
+      path: `/tmp/photo_${i}.png`
+    }
+  }));
+  messages.push({
+    role: "assistant",
+    content: toolUses
+  });
+
+  // User turn with tool_result blocks containing images
+  const toolResults = Array.from({
+    length: imageCount
+  }, (_, i) => ({
+    type: "tool_result",
+    tool_use_id: `toolu_${i}`,
+    content: [{
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: "image/png",
+        data: fakeBase64(imageSize)
+      }
+    }]
+  }));
+  messages.push({
+    role: "user",
+    content: toolResults
+  });
+
+  // Current user message
+  messages.push({
+    role: "user",
+    content: "Now update the products with these photos"
+  });
+  return {
+    mode: "proxy",
+    messages,
+    model: "claude-opus-4-6",
+    max_tokens: 16384,
+    stream: true
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("stripLargeBase64Fields", () => {
+  it("produces valid JSON after stripping a single large data field", () => {
+    const b64 = fakeBase64(50_000);
+    const raw = JSON.stringify({
+      messages: [{
+        role: "user",
+        content: [{
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: b64
+          }
+        }]
+      }]
+    });
+
+    // keepFrom must be past the closing quote of the data field for stripping to occur
+    const keepFrom = raw.length; // entire body is prune zone
+    const stripped = stripLargeBase64Fields(raw, keepFrom);
+
+    // Must be valid JSON
+    const parsed = JSON.parse(stripped);
+    expect(parsed.messages).toBeDefined();
+
+    // The data field should be empty (stripped)
+    const dataValue = parsed.messages[0].content[0].source.data;
+    expect(dataValue).toBe("");
+    expect(stripped.length).toBeLessThan(raw.length);
+  });
+  it("preserves data field when its closing quote is in the keep zone", () => {
+    const b64 = fakeBase64(50_000);
+    const raw = JSON.stringify({
+      messages: [{
+        role: "user",
+        content: [{
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: b64
+          }
+        }]
+      }]
+    });
+
+    // keepFrom in the middle of the data value — closing quote is in keep zone
+    const keepFrom = Math.max(0, raw.length - 1024);
+    const stripped = stripLargeBase64Fields(raw, keepFrom);
+
+    // Should be valid JSON — data is preserved because it spans the boundary
+    const parsed = JSON.parse(stripped);
+    expect(parsed.messages[0].content[0].source.data).toBe(b64);
+  });
+  it("produces valid JSON after stripping multiple large data fields", () => {
+    const body = buildConversationBody(8, 100_000); // 8 images, 100KB each
+    const raw = JSON.stringify(body);
+    expect(raw.length).toBeGreaterThan(800_000); // ~800KB+
+
+    const keepFrom = Math.max(0, raw.length - 50_000);
+    const stripped = stripLargeBase64Fields(raw, keepFrom);
+    const parsed = JSON.parse(stripped);
+    expect(parsed.mode).toBe("proxy");
+    expect(parsed.messages).toHaveLength(3);
+
+    // All image data in the prune zone should be empty
+    const toolResults = parsed.messages[1].content;
+    let strippedCount = 0;
+    for (const tr of toolResults) {
+      if (tr.content?.[0]?.source?.data === "") strippedCount++;
+    }
+    expect(strippedCount).toBeGreaterThan(0);
+    expect(stripped.length).toBeLessThan(raw.length / 2);
+  });
+  it("preserves data fields in the keep zone (tail)", () => {
+    const b64 = fakeBase64(50_000);
+    const raw = JSON.stringify({
+      messages: [{
+        role: "user",
+        content: [{
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: b64
+          }
+        }]
+      }]
+    });
+
+    // keepFrom at the very start — everything is in the keep zone
+    const keepFrom = 0;
+    const stripped = stripLargeBase64Fields(raw, keepFrom);
+
+    // Should be unchanged
+    expect(stripped).toBe(raw);
+    expect(JSON.parse(stripped)).toBeDefined();
+  });
+  it("preserves small data fields (< 8000 chars)", () => {
+    const b64 = fakeBase64(500); // small image
+    const raw = JSON.stringify({
+      messages: [{
+        role: "user",
+        content: [{
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: b64
+          }
+        }]
+      }]
+    });
+    const keepFrom = raw.length; // entire body is prune zone
+    const stripped = stripLargeBase64Fields(raw, keepFrom);
+
+    // Small data should be preserved
+    const parsed = JSON.parse(stripped);
+    expect(parsed.messages[0].content[0].source.data).toBe(b64);
+  });
+});

package/dist/server/__tests__/tool-router-agent-tools.test.js

@@ -0,0 +1,324 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be before imports
+// ---------------------------------------------------------------------------
+
+vi.mock("../../shared/agent-core.js", () => ({
+  sanitizeError: err => err instanceof Error ? err.message : String(err)
+}));
+vi.mock("../validation.js", () => ({
+  validateToolArgs: vi.fn((toolName, args) => ({
+    valid: true,
+    data: args
+  }))
+}));
+vi.mock("../lib/prompt-sanitizer.js", () => ({
+  sanitizeToolDescription: vi.fn(s => s || "")
+}));
+vi.mock("../lib/ssrf-guard.js", () => ({
+  validateUrl: vi.fn(async () => null)
+}));
+vi.mock("../lib/utils.js", () => ({
+  summarizeResult: vi.fn(() => ({
+    rows: 1
+  })),
+  withTimeout: vi.fn(async promise => promise)
+}));
+vi.mock("../handlers/inventory.js", () => ({
+  handleInventory: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleInventoryQuery: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleInventoryAudit: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/supply-chain.js", () => ({
+  handlePurchaseOrders: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleTransfers: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/catalog.js", () => ({
+  handleProducts: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleCollections: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/crm.js", () => ({
+  handleCustomers: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleOrders: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/analytics.js", () => ({
+  handleAnalytics: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/operations.js", () => ({
+  handleLocations: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleSuppliers: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleAlerts: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleAuditTrail: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleStore: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/comms.js", () => ({
+  handleEmail: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleDocuments: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/platform.js", () => ({
+  handleWebSearch: vi.fn(async () => ({
+    success: true,
+    data: {}
+  })),
+  handleTelemetry: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/browser.js", () => ({
+  handleBrowser: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/discovery.js", () => ({
+  handleDiscovery: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/voice.js", () => ({
+  handleVoice: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/workflows.js", () => ({
+  handleWorkflows: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/embeddings.js", () => ({
+  handleEmbeddings: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/llm-providers.js", () => ({
+  handleLLM: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/image-gen.js", () => ({
+  handleImageGen: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/video-gen.js", () => ({
+  handleVideoGen: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/api-keys.js", () => ({
+  handleAPIKeys: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/creations.js", () => ({
+  handleCreations: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/meta-ads.js", () => ({
+  handleMetaAds: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/kali.js", () => ({
+  handleKali: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/local-agent.js", () => ({
+  handleLocalAgent: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+vi.mock("../handlers/enrichment.js", () => ({
+  handleEnrichment: vi.fn(async () => ({
+    success: true,
+    data: {}
+  }))
+}));
+
+// ---------------------------------------------------------------------------
+// Import the module under test
+// ---------------------------------------------------------------------------
+
+import { getCachedToolDefs, getUserToolByPrefixedName, getToolsForAgent } from "../tool-router.js";
+
+// ---------------------------------------------------------------------------
+// TESTS
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+describe("getUserToolByPrefixedName", () => {
+  const rows = [{
+    id: "1",
+    name: "custom_search",
+    display_name: "Search",
+    description: "desc",
+    input_schema: {},
+    execution_type: "rpc",
+    is_read_only: true,
+    requires_approval: false,
+    http_config: null,
+    rpc_function: "fn",
+    sql_template: null,
+    allowed_tables: null,
+    max_execution_time_ms: 5000
+  }];
+  it("finds tool by prefixed name", () => {
+    const result = getUserToolByPrefixedName(rows, "user_tool__custom_search");
+    expect(result?.name).toBe("custom_search");
+  });
+  it("returns undefined for unknown tool", () => {
+    const result = getUserToolByPrefixedName(rows, "user_tool__nonexistent");
+    expect(result).toBeUndefined();
+  });
+  it("strips only the user_tool__ prefix", () => {
+    const result = getUserToolByPrefixedName(rows, "custom_search");
+    expect(result?.name).toBe("custom_search");
+  });
+});
+describe("getToolsForAgent", () => {
+  const coreTools = [{
+    name: "inventory",
+    description: "Manage inventory",
+    input_schema: {}
+  }, {
+    name: "products",
+    description: "Manage products",
+    input_schema: {}
+  }];
+  const userTools = [{
+    name: "user_tool__search",
+    description: "Custom search",
+    input_schema: {}
+  }, {
+    name: "user_tool__export",
+    description: "Custom export",
+    input_schema: {}
+  }];
+  it("returns core + all user tools when no enabled_tools filter", () => {
+    const agent = {
+      enabled_tools: []
+    };
+    const tools = getToolsForAgent(agent, coreTools, userTools);
+    expect(tools).toHaveLength(4);
+  });
+  it("filters user tools by enabled_tools", () => {
+    const agent = {
+      enabled_tools: ["user_tool__search"]
+    };
+    const tools = getToolsForAgent(agent, coreTools, userTools);
+    expect(tools).toHaveLength(3);
+    expect(tools.map(t => t.name)).toContain("user_tool__search");
+    expect(tools.map(t => t.name)).not.toContain("user_tool__export");
+  });
+  it("core tools are always included regardless of enabled_tools", () => {
+    const agent = {
+      enabled_tools: ["user_tool__search"]
+    };
+    const tools = getToolsForAgent(agent, coreTools, userTools);
+    expect(tools.map(t => t.name)).toContain("inventory");
+    expect(tools.map(t => t.name)).toContain("products");
+  });
+  it("works with no user tools", () => {
+    const agent = {
+      enabled_tools: []
+    };
+    const tools = getToolsForAgent(agent, coreTools);
+    expect(tools).toHaveLength(2);
+  });
+});
+describe("getCachedToolDefs", () => {
+  it("returns tool defs with descriptions", () => {
+    const tools = [{
+      name: "test",
+      description: "A short description",
+      input_schema: {
+        type: "object"
+      }
+    }];
+    const result = getCachedToolDefs(tools);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("test");
+    expect(result[0].description).toBe("A short description");
+  });
+  it("truncates long descriptions to 150 chars", () => {
+    const longDesc = "x".repeat(200);
+    const tools = [{
+      name: "test",
+      description: longDesc,
+      input_schema: {
+        type: "object"
+      }
+    }];
+    const result = getCachedToolDefs(tools);
+    expect(result[0].description.length).toBeLessThanOrEqual(200);
+  });
+});