whale-code 6.5.11 → 6.6.0

package/dist/shared/tool-dispatch-parallel.test.js

@@ -1,378 +0,0 @@
-/**
- * Tests for tool-dispatch.ts — parallel execution, loop detection, bail-out
- */
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { dispatchTools } from "./tool-dispatch.js";
-import { LoopDetector, AGENT_DEFAULTS } from "./agent-core.js";
-// ============================================================================
-// Helpers
-// ============================================================================
-function makeToolCall(overrides) {
-  return {
-    id: overrides?.id ?? `tool_${Math.random().toString(36).slice(2, 8)}`,
-    name: overrides?.name ?? "test_tool",
-    input: overrides?.input ?? {}
-  };
-}
-function successExecutor(output = "ok") {
-  return async (_name, _input) => ({
-    success: true,
-    output
-  });
-}
-function failExecutor(output = "something went wrong") {
-  return async (_name, _input) => ({
-    success: false,
-    output
-  });
-}
-function defaultOpts(overrides) {
-  return {
-    loopDetector: new LoopDetector(),
-    ...overrides
-  };
-}
-// ============================================================================
-// Tests
-// ============================================================================
-describe("dispatchTools — parallel execution", () => {
-  let detector;
-  beforeEach(() => {
-    detector = new LoopDetector();
-  });
-  it("executes tools in parallel up to maxConcurrent", async () => {
-    const concurrencyTracker = [];
-    let concurrent = 0;
-    const calls = Array.from({
-      length: 10
-    }, (_, i) => makeToolCall({
-      id: `p${i}`,
-      name: `tool_${i}`,
-      input: {
-        i
-      }
-    }));
-    const executor = async name => {
-      concurrent++;
-      concurrencyTracker.push(concurrent);
-      await new Promise(r => setTimeout(r, 20));
-      concurrent--;
-      return {
-        success: true,
-        output: `done_${name}`
-      };
-    };
-    const {
-      results
-    } = await dispatchTools(calls, executor, defaultOpts({
-      loopDetector: detector,
-      maxConcurrent: 3
-    }));
-    expect(results).toHaveLength(10);
-    expect(Math.max(...concurrencyTracker)).toBeLessThanOrEqual(3);
-  });
-  it("executes sequentially when maxConcurrent is 1", async () => {
-    const executionOrder = [];
-    const calls = [makeToolCall({
-      id: "s1",
-      name: "tool_a",
-      input: {
-        order: 1
-      }
-    }), makeToolCall({
-      id: "s2",
-      name: "tool_b",
-      input: {
-        order: 2
-      }
-    }), makeToolCall({
-      id: "s3",
-      name: "tool_c",
-      input: {
-        order: 3
-      }
-    })];
-    const executor = async name => {
-      executionOrder.push(name);
-      return {
-        success: true,
-        output: "ok"
-      };
-    };
-    await dispatchTools(calls, executor, defaultOpts({
-      loopDetector: detector,
-      maxConcurrent: 1
-    }));
-    expect(executionOrder).toEqual(["tool_a", "tool_b", "tool_c"]);
-  });
-  it("defaults to maxConcurrent of 7", async () => {
-    let maxConcurrent = 0;
-    let concurrent = 0;
-    const calls = Array.from({
-      length: 14
-    }, (_, i) => makeToolCall({
-      id: `d${i}`,
-      name: `tool_${i}`,
-      input: {
-        i
-      }
-    }));
-    const executor = async () => {
-      concurrent++;
-      if (concurrent > maxConcurrent) maxConcurrent = concurrent;
-      await new Promise(r => setTimeout(r, 20));
-      concurrent--;
-      return {
-        success: true,
-        output: "ok"
-      };
-    };
-    await dispatchTools(calls, executor, defaultOpts({
-      loopDetector: detector
-    }));
-    expect(maxConcurrent).toBeLessThanOrEqual(7);
-    expect(maxConcurrent).toBeGreaterThanOrEqual(2);
-  });
-});
-describe("dispatchTools — loop detection", () => {
-  let detector;
-  beforeEach(() => {
-    detector = new LoopDetector();
-  });
-  it("blocks tool calls that the loop detector rejects", async () => {
-    const effectiveLimit = Math.min(AGENT_DEFAULTS.loopIdenticalCallLimit, AGENT_DEFAULTS.loopFileReadLimit);
-    const calls = [];
-    for (let i = 0; i < effectiveLimit + 2; i++) {
-      calls.push(makeToolCall({
-        id: `loop${i}`,
-        name: "read_file",
-        input: {
-          path: "/same"
-        }
-      }));
-    }
-    const executorSpy = vi.fn(async () => ({
-      success: true,
-      output: "ok"
-    }));
-    const {
-      results
-    } = await dispatchTools(calls, executorSpy, defaultOpts({
-      loopDetector: detector
-    }));
-    const blockedResults = results.filter(r => {
-      if (typeof r.content !== "string") return false;
-      try {
-        return JSON.parse(r.content).error;
-      } catch {
-        return false;
-      }
-    });
-    expect(blockedResults.length).toBeGreaterThanOrEqual(1);
-    const lastBlocked = blockedResults[blockedResults.length - 1];
-    const parsed = JSON.parse(lastBlocked.content);
-    expect(parsed.error).toMatch(/identical call|already read/);
-    expect(executorSpy).toHaveBeenCalledTimes(effectiveLimit);
-  });
-  it("records results back to the loop detector", async () => {
-    const tc = makeToolCall({
-      id: "lr1",
-      name: "bash",
-      input: {
-        cmd: "fail"
-      }
-    });
-    await dispatchTools([tc], failExecutor("error occurred"), defaultOpts({
-      loopDetector: detector
-    }));
-    const stats = detector.getSessionStats();
-    expect(stats.totalErrors).toBe(1);
-  });
-  it("tracks consecutive errors per action, not per tool name", async () => {
-    const detailedInput = {
-      action: "music_compose_detailed",
-      prompt: "test"
-    };
-    for (let i = 0; i < AGENT_DEFAULTS.loopConsecutiveErrorLimit; i++) {
-      detector.recordCall("voice", detailedInput);
-      detector.recordResult("voice", false, detailedInput);
-    }
-    const blockedCheck = detector.recordCall("voice", {
-      action: "music_compose_detailed",
-      prompt: "new"
-    });
-    expect(blockedCheck.blocked).toBe(true);
-    expect(blockedCheck.reason).toContain("music_compose_detailed");
-    const speakCheck = detector.recordCall("voice", {
-      action: "speak",
-      text: "hello"
-    });
-    expect(speakCheck.blocked).toBe(false);
-    const composeCheck = detector.recordCall("voice", {
-      action: "music_compose",
-      prompt: "beat"
-    });
-    expect(composeCheck.blocked).toBe(false);
-  });
-  it("blocks previously failed strategies in subsequent dispatches", async () => {
-    const input = {
-      path: "/specific/file",
-      content: "data"
-    };
-    await dispatchTools([makeToolCall({
-      id: "fs1",
-      name: "edit_file",
-      input
-    })], failExecutor("permission denied"), defaultOpts({
-      loopDetector: detector
-    }));
-    detector.resetTurn();
-    const executorSpy = vi.fn(async () => ({
-      success: true,
-      output: "ok"
-    }));
-    const {
-      results
-    } = await dispatchTools([makeToolCall({
-      id: "fs2",
-      name: "edit_file",
-      input
-    })], executorSpy, defaultOpts({
-      loopDetector: detector
-    }));
-    const content = results[0].content;
-    const parsed = JSON.parse(content);
-    expect(parsed.error).toContain("failed in a previous turn");
-    expect(executorSpy).not.toHaveBeenCalled();
-  });
-});
-describe("dispatchTools — bail-out", () => {
-  let detector;
-  beforeEach(() => {
-    detector = new LoopDetector();
-  });
-  it("returns bailOut=true after consecutive failed turns", async () => {
-    for (let turn = 0; turn < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit; turn++) {
-      const tc = makeToolCall({
-        id: `bail${turn}`,
-        name: `tool_${turn}`,
-        input: {
-          turn
-        }
-      });
-      const {
-        bailOut,
-        bailMessage
-      } = await dispatchTools([tc], failExecutor("error"), defaultOpts({
-        loopDetector: detector
-      }));
-      if (turn < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit - 1) {
-        expect(bailOut).toBe(false);
-      } else {
-        expect(bailOut).toBe(true);
-        expect(bailMessage).toContain("consecutive turns");
-      }
-      detector.resetTurn();
-    }
-  });
-  it("prepends SYSTEM WARNING to last result content on bail-out", async () => {
-    for (let turn = 0; turn < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit - 1; turn++) {
-      const tc = makeToolCall({
-        id: `pre${turn}`,
-        name: `tool_${turn}`,
-        input: {
-          turn
-        }
-      });
-      await dispatchTools([tc], failExecutor("error"), defaultOpts({
-        loopDetector: detector
-      }));
-      detector.resetTurn();
-    }
-    const tc = makeToolCall({
-      id: "final_bail",
-      name: "final_tool",
-      input: {
-        last: true
-      }
-    });
-    const {
-      results,
-      bailOut
-    } = await dispatchTools([tc], failExecutor("final error"), defaultOpts({
-      loopDetector: detector
-    }));
-    expect(bailOut).toBe(true);
-    const content = results[0].content;
-    expect(content).toContain("[SYSTEM WARNING]");
-    expect(content).toContain("consecutive turns");
-  });
-  it("does not bail after successful turns", async () => {
-    for (let turn = 0; turn < 5; turn++) {
-      const tc = makeToolCall({
-        id: `ok${turn}`,
-        name: "good_tool",
-        input: {
-          turn
-        }
-      });
-      const {
-        bailOut
-      } = await dispatchTools([tc], successExecutor("ok"), defaultOpts({
-        loopDetector: detector
-      }));
-      expect(bailOut).toBe(false);
-      detector.resetTurn();
-    }
-  });
-  it("does not prepend SYSTEM WARNING when last result has array content (image)", async () => {
-    for (let turn = 0; turn < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit - 1; turn++) {
-      const tc = makeToolCall({
-        id: `pre2${turn}`,
-        name: `tool_${turn}`,
-        input: {
-          turn
-        }
-      });
-      await dispatchTools([tc], failExecutor("error"), defaultOpts({
-        loopDetector: detector
-      }));
-      detector.resetTurn();
-    }
-    const calls = [makeToolCall({
-      id: "fail_img",
-      name: "failing_tool",
-      input: {
-        fail: true
-      }
-    }), makeToolCall({
-      id: "img_bail",
-      name: "image_tool",
-      input: {
-        img: true
-      }
-    })];
-    const executor = async name => {
-      if (name === "failing_tool") {
-        return {
-          success: false,
-          output: "err"
-        };
-      }
-      return {
-        success: true,
-        output: "__IMAGE__image/jpeg__/9j/4AAQ"
-      };
-    };
-    const {
-      results,
-      bailOut
-    } = await dispatchTools(calls, executor, defaultOpts({
-      loopDetector: detector
-    }));
-    expect(bailOut).toBe(true);
-    const lastContent = results[results.length - 1].content;
-    expect(Array.isArray(lastContent)).toBe(true);
-  });
-});

package/dist/webchat/__tests__/widget-messaging.test.js

@@ -1,323 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// ============================================================================
-// DOM environment mock — widget.ts is browser code (IIFE)
-// We test by simulating the DOM environment, then importing the module
-// which executes the IIFE on import.
-// ============================================================================
-
-// Track elements and event listeners
-let appendedChildren = [];
-let createdElements = {};
-let localStorageStore = {};
-let sessionStorageStore = {};
-let fetchMock;
-function createMockElement(tag) {
-  const el = {
-    tagName: tag.toUpperCase(),
-    className: "",
-    innerHTML: "",
-    textContent: "",
-    type: "",
-    placeholder: "",
-    disabled: false,
-    style: {},
-    children: [],
-    childNodes: [],
-    classList: {
-      _classes: new Set(),
-      add(c) {
-        this._classes.add(c);
-      },
-      remove(c) {
-        this._classes.delete(c);
-      },
-      contains(c) {
-        return this._classes.has(c);
-      }
-    },
-    _events: {},
-    _attributes: {},
-    addEventListener(event, handler) {
-      if (!el._events[event]) el._events[event] = [];
-      el._events[event].push(handler);
-    },
-    setAttribute(name, value) {
-      el._attributes[name] = value;
-    },
-    getAttribute(name) {
-      return el._attributes[name] || null;
-    },
-    appendChild(child) {
-      el.children.push(child);
-      el.childNodes.push(child);
-      return child;
-    },
-    remove() {
-      // no-op in mock
-    },
-    focus() {},
-    get scrollHeight() {
-      return 1000;
-    },
-    set scrollTop(_v) {},
-    get value() {
-      return el._value || "";
-    },
-    set value(v) {
-      el._value = v;
-    }
-  };
-  return el;
-}
-function setupDOM(attrs = {}) {
-  appendedChildren = [];
-  createdElements = {};
-  localStorageStore = {};
-  sessionStorageStore = {};
-  const scriptEl = createMockElement("script");
-  scriptEl.src = "https://whale-agent.fly.dev/webchat/widget.js";
-  scriptEl._attributes = {
-    "data-channel": "test-channel-123",
-    ...attrs
-  };
-  scriptEl.getAttribute = name => scriptEl._attributes[name] || null;
-  const headEl = createMockElement("head");
-  const bodyEl = createMockElement("body");
-  bodyEl.appendChild = child => {
-    appendedChildren.push(child);
-    return child;
-  };
-  globalThis.document = {
-    currentScript: scriptEl,
-    head: headEl,
-    body: bodyEl,
-    createElement(tag) {
-      const el = createMockElement(tag);
-      if (!createdElements[tag]) createdElements[tag] = [];
-      createdElements[tag].push(el);
-      return el;
-    }
-  };
-  globalThis.localStorage = {
-    getItem: key => localStorageStore[key] || null,
-    setItem: (key, value) => {
-      localStorageStore[key] = value;
-    },
-    removeItem: key => {
-      delete localStorageStore[key];
-    }
-  };
-  globalThis.sessionStorage = {
-    getItem: key => sessionStorageStore[key] || null,
-    setItem: (key, value) => {
-      sessionStorageStore[key] = value;
-    },
-    removeItem: key => {
-      delete sessionStorageStore[key];
-    }
-  };
-  globalThis.window = globalThis;
-  fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    json: () => Promise.resolve({
-      conversation_id: "conv-1",
-      agent_response: {
-        content: "Hello!"
-      }
-    })
-  });
-  globalThis.fetch = fetchMock;
-}
-function cleanupDOM() {
-  delete globalThis.document;
-  delete globalThis.localStorage;
-  delete globalThis.sessionStorage;
-  delete globalThis.WhaleChat;
-}
-
-// We need to dynamically import the widget each test, since it's an IIFE
-// that runs on import. Instead, we'll test the behavior by examining the
-// DOM state after the IIFE runs.
-
-describe("WhaleChat Widget — sendMessage", () => {
-  beforeEach(() => {
-    setupDOM();
-  });
-  afterEach(() => {
-    cleanupDOM();
-  });
-  it("sends POST to correct endpoint", async () => {
-    const serverUrl = "https://whale-agent.fly.dev";
-    const channelId = "test-channel-123";
-    const text = "Hello there";
-    await globalThis.fetch(serverUrl + "/webchat/channels/" + channelId + "/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        sender_id: "anon_123",
-        sender_name: "Visitor",
-        content: text,
-        content_type: "text"
-      })
-    });
-    expect(fetchMock).toHaveBeenCalledWith("https://whale-agent.fly.dev/webchat/channels/test-channel-123/messages", expect.objectContaining({
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    }));
-  });
-  it("does not send empty messages", () => {
-    const text = "   ".trim();
-    const isSending = false;
-    if (!text || isSending) {
-      // should not fetch
-      expect(true).toBe(true);
-      return;
-    }
-    // Should not reach here for empty text
-    expect(true).toBe(false);
-  });
-  it("does not send when already sending", () => {
-    const text = "Hello";
-    const isSending = true;
-    if (!text || isSending) {
-      expect(true).toBe(true);
-      return;
-    }
-    expect(true).toBe(false);
-  });
-});
-describe("WhaleChat Widget — formatTime", () => {
-  it("formats ISO string to locale time", () => {
-    // Replicate formatTime logic
-    function formatTime(isoString) {
-      try {
-        const d = new Date(isoString);
-        return d.toLocaleTimeString(undefined, {
-          hour: "numeric",
-          minute: "2-digit"
-        });
-      } catch {
-        return "";
-      }
-    }
-    const result = formatTime("2026-02-23T14:30:00Z");
-    // Should contain hour and minute regardless of locale
-    expect(result.length).toBeGreaterThan(0);
-  });
-  it("returns empty string for invalid date", () => {
-    function formatTime(isoString) {
-      try {
-        const d = new Date(isoString);
-        if (isNaN(d.getTime())) return "";
-        return d.toLocaleTimeString(undefined, {
-          hour: "numeric",
-          minute: "2-digit"
-        });
-      } catch {
-        return "";
-      }
-    }
-    // Note: new Date("garbage") doesn't throw but returns Invalid Date
-    const result = formatTime("not-a-date");
-    // Different JS engines may handle this differently; just ensure no crash
-    expect(typeof result).toBe("string");
-  });
-});
-describe("WhaleChat Widget — addMessageToUI", () => {
-  beforeEach(() => {
-    setupDOM();
-  });
-  afterEach(() => {
-    cleanupDOM();
-  });
-  it("creates message element with correct class", () => {
-    const msgsEl = createMockElement("div");
-    msgsEl.className = "wc-messages";
-    function addMessageToUI(msg) {
-      const el = globalThis.document.createElement("div");
-      el.className = "wc-msg " + msg.role;
-      const contentSpan = globalThis.document.createElement("span");
-      contentSpan.textContent = msg.content;
-      el.appendChild(contentSpan);
-      const timeDiv = globalThis.document.createElement("div");
-      timeDiv.className = "wc-time";
-      timeDiv.textContent = msg.time;
-      el.appendChild(timeDiv);
-      msgsEl.appendChild(el);
-    }
-    addMessageToUI({
-      role: "user",
-      content: "Hello",
-      time: "2:30 PM"
-    });
-    expect(msgsEl.children.length).toBe(1);
-    expect(msgsEl.children[0].className).toBe("wc-msg user");
-  });
-  it("creates agent message with agent class", () => {
-    const msgsEl = createMockElement("div");
-    function addMessageToUI(msg) {
-      const el = globalThis.document.createElement("div");
-      el.className = "wc-msg " + msg.role;
-      msgsEl.appendChild(el);
-    }
-    addMessageToUI({
-      role: "agent",
-      content: "Hi!",
-      time: "2:31 PM"
-    });
-    expect(msgsEl.children[0].className).toBe("wc-msg agent");
-  });
-});
-describe("WhaleChat Widget — WhaleChat API", () => {
-  function makeApi() {
-    let isOpen = false;
-    let toggleCount = 0;
-    const togglePanel = () => {
-      isOpen = !isOpen;
-      toggleCount++;
-    };
-    return {
-      version: "1.0.0",
-      open() {
-        if (!isOpen) togglePanel();
-      },
-      close() {
-        if (isOpen) togglePanel();
-      },
-      isOpen() {
-        return isOpen;
-      },
-      get toggleCount() {
-        return toggleCount;
-      }
-    };
-  }
-  it("exposes version, open, close, isOpen on window.WhaleChat", () => {
-    const api = makeApi();
-    expect(api.version).toBe("1.0.0");
-    expect(api.isOpen()).toBe(false);
-    api.open();
-    expect(api.isOpen()).toBe(true);
-    api.close();
-    expect(api.isOpen()).toBe(false);
-  });
-  it("open() is idempotent when already open", () => {
-    const api = makeApi();
-    api.open();
-    api.open();
-    expect(api.toggleCount).toBe(1);
-    expect(api.isOpen()).toBe(true);
-  });
-  it("close() is idempotent when already closed", () => {
-    const api = makeApi();
-    api.close();
-    api.close();
-    expect(api.toggleCount).toBe(0);
-    expect(api.isOpen()).toBe(false);
-  });
-});