whale-code 6.5.11 → 6.6.0

package/dist/shared/api-client-config.d.ts

@@ -1,21 +0,0 @@
-/**
- * API Client — Config builder for Anthropic API requests.
- *
- * Builds all Anthropic API config from a simple profile (main, subagent, teammate).
- */
-import type { ContextProfile, APIRequestConfig } from "./types.js";
-/**
- * Build all Anthropic API config from a simple profile.
- *
- * Profiles:
- * - 'main': clear at 80K/keep 3, compact at 120K (Opus only)
- * - 'subagent': clear at 60K/keep 2, no compaction, 8192 max tokens
- * - 'teammate': clear at 80K/keep 3, no compaction
- */
-export declare function buildAPIRequest(opts: {
-    model: string;
-    contextProfile: ContextProfile;
-    thinkingEnabled?: boolean;
-    maxOutputTokens?: number;
-    contextOverrides?: import("./agent-core.js").ContextManagementOverrides;
-}): APIRequestConfig;

package/dist/shared/api-client-helpers.d.ts

@@ -1,57 +0,0 @@
-/**
- * API Client — System prompt building, caching setup, and provider service calls.
- */
-import type { CompactableMessage } from "./compaction.js";
-/**
- * Build system blocks with prompt caching.
- * Cached system prompt + optional dynamic cost context (after cache breakpoint).
- */
-export declare function buildSystemBlocks(systemPrompt: string, costContext?: string, enableCaching?: boolean): Array<Record<string, unknown>>;
-/**
- * Prepare messages and tools with prompt caching.
- * Skips cache_control injection for Gemini (uses implicit caching).
- */
-export declare function prepareWithCaching<T extends object = object, M extends {
-    role: string;
-    content: unknown;
-} = {
-    role: string;
-    content: unknown;
-}>(tools: T[], messages: M[], model?: string): {
-    tools: T[];
-    messages: M[];
-};
-/**
- * Client-side context trimming for Gemini (no server-side context management).
- * When estimated input tokens exceed threshold, replaces old tool result contents
- * with "[trimmed]" to stay within Gemini's 1M context window.
- */
-export declare function trimGeminiContext<T extends CompactableMessage>(messages: T[], estimatedTokens: number, threshold?: number, keepRecent?: number): T[];
-/**
- * Client-side context trimming for OpenAI (no server-side context management).
- * When estimated input tokens exceed threshold, replaces old tool result contents
- * with "[trimmed]" to stay within OpenAI's 200K context window.
- */
-export declare function trimOpenAIContext<T extends CompactableMessage>(messages: T[], estimatedTokens: number, threshold?: number, keepRecent?: number): T[];
-/**
- * Call server transcription endpoint (OpenAI Whisper via our Fly.io proxy).
- * Used by tool-dispatch when __AUDIO__ marker is detected in tool results.
- */
-export declare function callTranscribe(opts: {
-    proxyUrl: string;
-    token: string;
-    storeId: string;
-    audioBase64: string;
-    mediaType: string;
-}): Promise<string>;
-/**
- * Request conversation compaction from the server (Haiku summarization).
- * Used by non-Anthropic providers (OpenAI, Gemini) that lack native compaction.
- * Returns summary string or null on failure (caller keeps unsummarized history).
- */
-export declare function requestProviderCompaction(opts: {
-    proxyUrl: string;
-    token: string;
-    messages: object[];
-    systemPrompt: string;
-}): Promise<string | null>;

package/dist/shared/api-client-helpers.test.js

@@ -1,261 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildSystemBlocks, prepareWithCaching, trimOpenAIContext, trimGeminiContext } from "./api-client.js";
-
-// ============================================================================
-// buildSystemBlocks
-// ============================================================================
-
-describe("buildSystemBlocks", () => {
-  it("returns system prompt with cache_control when caching enabled", () => {
-    const blocks = buildSystemBlocks("You are helpful.", undefined, true);
-    expect(blocks).toHaveLength(1);
-    expect(blocks[0]).toEqual({
-      type: "text",
-      text: "You are helpful.",
-      cache_control: {
-        type: "ephemeral"
-      }
-    });
-  });
-  it("returns system prompt without cache_control when caching disabled", () => {
-    const blocks = buildSystemBlocks("You are helpful.", undefined, false);
-    expect(blocks).toHaveLength(1);
-    expect(blocks[0]).toEqual({
-      type: "text",
-      text: "You are helpful."
-    });
-  });
-  it("defaults to caching enabled", () => {
-    const blocks = buildSystemBlocks("Hello.");
-    expect(blocks[0]).toHaveProperty("cache_control", {
-      type: "ephemeral"
-    });
-  });
-  it("appends cost context as a second block", () => {
-    const blocks = buildSystemBlocks("System prompt.", "Session cost: $0.05");
-    expect(blocks).toHaveLength(2);
-    expect(blocks[0].text).toBe("System prompt.");
-    expect(blocks[1]).toEqual({
-      type: "text",
-      text: "Session cost: $0.05"
-    });
-  });
-  it("cost context block does not have cache_control (dynamic content)", () => {
-    const blocks = buildSystemBlocks("System.", "Cost: $1.00", true);
-    expect(blocks[1]).not.toHaveProperty("cache_control");
-  });
-  it("omits cost context block when undefined", () => {
-    const blocks = buildSystemBlocks("System.", undefined, true);
-    expect(blocks).toHaveLength(1);
-  });
-  it("omits cost context block when empty string (falsy)", () => {
-    const blocks = buildSystemBlocks("System.", "", true);
-    expect(blocks).toHaveLength(1);
-  });
-});
-
-// ============================================================================
-// prepareWithCaching
-// ============================================================================
-
-describe("prepareWithCaching", () => {
-  it("delegates to addPromptCaching and returns cached tools and messages", () => {
-    const tools = [{
-      name: "tool1"
-    }, {
-      name: "tool2"
-    }];
-    const messages = [{
-      role: "user",
-      content: "first"
-    }, {
-      role: "assistant",
-      content: "second"
-    }, {
-      role: "user",
-      content: "third"
-    }];
-    const result = prepareWithCaching(tools, messages);
-
-    // Last tool should have cache_control
-    expect(result.tools[result.tools.length - 1]).toHaveProperty("cache_control", {
-      type: "ephemeral"
-    });
-    // First tool should not
-    expect(result.tools[0]).not.toHaveProperty("cache_control");
-  });
-  it("does not mutate original arrays", () => {
-    const tools = [{
-      name: "t1"
-    }];
-    const messages = [{
-      role: "user",
-      content: "a"
-    }, {
-      role: "assistant",
-      content: "b"
-    }];
-    prepareWithCaching(tools, messages);
-    expect(tools[0]).not.toHaveProperty("cache_control");
-    expect(messages[0]).toEqual({
-      role: "user",
-      content: "a"
-    });
-  });
-  it("handles empty tools and messages", () => {
-    const result = prepareWithCaching([], []);
-    expect(result.tools).toEqual([]);
-    expect(result.messages).toEqual([]);
-  });
-});
-
-// ============================================================================
-// trimOpenAIContext
-// ============================================================================
-
-describe("trimOpenAIContext", () => {
-  function makeMessages(toolResultCount) {
-    const msgs = [];
-    for (let i = 0; i < toolResultCount; i++) {
-      msgs.push({
-        role: "assistant",
-        content: [{
-          type: "tool_use",
-          id: `t${i}`,
-          name: "bash",
-          input: {}
-        }]
-      });
-      msgs.push({
-        role: "user",
-        content: [{
-          type: "tool_result",
-          tool_use_id: `t${i}`,
-          content: `Result ${i}`
-        }]
-      });
-    }
-    return msgs;
-  }
-  it("returns same reference when below threshold", () => {
-    const msgs = makeMessages(10);
-    const result = trimOpenAIContext(msgs, 100_000); // 100K < 150K default threshold
-    expect(result).toBe(msgs); // exact same reference
-  });
-  it("returns same reference when above threshold but few tool results", () => {
-    const msgs = makeMessages(3); // 3 tool results <= keepRecent=5
-    const result = trimOpenAIContext(msgs, 200_000);
-    expect(result).toBe(msgs);
-  });
-  it("trims oldest tool results when above threshold", () => {
-    const msgs = makeMessages(10);
-    const result = trimOpenAIContext(msgs, 200_000, 150_000, 5);
-    expect(result).not.toBe(msgs); // new array
-    // Should have 5 trimmed (oldest) and 5 kept
-    let trimmedCount = 0;
-    let keptCount = 0;
-    for (const msg of result) {
-      if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === "tool_result") {
-            if (block.content === "[trimmed]") trimmedCount++;else keptCount++;
-          }
-        }
-      }
-    }
-    expect(trimmedCount).toBe(5);
-    expect(keptCount).toBe(5);
-  });
-  it("preserves most recent tool results (not oldest)", () => {
-    const msgs = makeMessages(8);
-    const result = trimOpenAIContext(msgs, 200_000, 150_000, 5);
-    // Last 5 tool results should be preserved
-    const toolResults = [];
-    for (const msg of result) {
-      if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === "tool_result") {
-            toolResults.push(block);
-          }
-        }
-      }
-    }
-    // First 3 should be trimmed, last 5 should be kept
-    expect(toolResults[0].content).toBe("[trimmed]");
-    expect(toolResults[1].content).toBe("[trimmed]");
-    expect(toolResults[2].content).toBe("[trimmed]");
-    expect(toolResults[3].content).toBe("Result 3");
-    expect(toolResults[7].content).toBe("Result 7");
-  });
-  it("respects custom threshold and keepRecent", () => {
-    const msgs = makeMessages(6);
-    const result = trimOpenAIContext(msgs, 100_000, 50_000, 2); // lower threshold, keep 2
-    let trimmedCount = 0;
-    for (const msg of result) {
-      if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === "tool_result" && block.content === "[trimmed]") trimmedCount++;
-        }
-      }
-    }
-    expect(trimmedCount).toBe(4); // 6 - 2 = 4 trimmed
-  });
-  it("handles messages with non-array content", () => {
-    const msgs = [{
-      role: "user",
-      content: "Hello"
-    }, ...makeMessages(6)];
-    // Should not crash on string content
-    const result = trimOpenAIContext(msgs, 200_000, 150_000, 3);
-    expect(result[0].content).toBe("Hello");
-  });
-});
-
-// ============================================================================
-// trimGeminiContext
-// ============================================================================
-
-describe("trimGeminiContext", () => {
-  function makeMessages(toolResultCount) {
-    const msgs = [];
-    for (let i = 0; i < toolResultCount; i++) {
-      msgs.push({
-        role: "assistant",
-        content: [{
-          type: "tool_use",
-          id: `t${i}`,
-          name: "bash",
-          input: {}
-        }]
-      });
-      msgs.push({
-        role: "user",
-        content: [{
-          type: "tool_result",
-          tool_use_id: `t${i}`,
-          content: `Result ${i}`
-        }]
-      });
-    }
-    return msgs;
-  }
-  it("returns same reference when below 950K threshold", () => {
-    const msgs = makeMessages(10);
-    const result = trimGeminiContext(msgs, 700_000);
-    expect(result).toBe(msgs);
-  });
-  it("trims when above 950K threshold", () => {
-    const msgs = makeMessages(10);
-    const result = trimGeminiContext(msgs, 960_000);
-    expect(result).not.toBe(msgs);
-    let trimmedCount = 0;
-    for (const msg of result) {
-      if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === "tool_result" && block.content === "[trimmed]") trimmedCount++;
-        }
-      }
-    }
-    expect(trimmedCount).toBe(5); // 10 - 5 (keepRecent default) = 5
-  });
-});

package/dist/shared/api-client-proxy-happy.test.js

@@ -1,255 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { callServerProxy } from "./api-client.js";
-// ============================================================================
-// callServerProxy — happy path, body fields, error handling
-// ============================================================================
-
-describe("callServerProxy (happy path and errors)", () => {
-  let originalFetch;
-  beforeEach(() => {
-    originalFetch = globalThis.fetch;
-  });
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-  function mockFetch(impl) {
-    globalThis.fetch = vi.fn(impl);
-  }
-  function makeMockStream() {
-    return new ReadableStream({
-      start(controller) {
-        controller.enqueue(new TextEncoder().encode("data: hello\n\n"));
-        controller.close();
-      }
-    });
-  }
-  const baseConfig = {
-    proxyUrl: "https://whale-agent.fly.dev/proxy",
-    token: "test-jwt-token",
-    model: "claude-opus-4-6",
-    system: [{
-      type: "text",
-      text: "You are helpful."
-    }],
-    messages: [{
-      role: "user",
-      content: "Hello"
-    }],
-    tools: [{
-      name: "bash",
-      description: "Run commands"
-    }],
-    apiConfig: {
-      betas: ["context-management-2025-06-27"],
-      contextManagement: {
-        edits: [{
-          type: "clear_tool_uses_20250919",
-          trigger: {
-            type: "input_tokens",
-            value: 80_000
-          },
-          keep: {
-            type: "tool_uses",
-            value: 3
-          }
-        }]
-      },
-      maxTokens: 16384
-    }
-  };
-
-  // ---------- Happy path ----------
-
-  it("returns a ReadableStream on successful 200 response", async () => {
-    const stream = makeMockStream();
-    mockFetch(async () => new Response(stream, {
-      status: 200
-    }));
-    const result = await callServerProxy({
-      ...baseConfig
-    });
-    expect(result).toBeInstanceOf(ReadableStream);
-  });
-  it("sends correct headers (Content-Type and Authorization)", async () => {
-    const stream = makeMockStream();
-    mockFetch(async (_url, opts) => {
-      expect(opts.headers["Content-Type"]).toBe("application/json");
-      expect(opts.headers["Authorization"]).toBe("Bearer test-jwt-token");
-      return new Response(stream, {
-        status: 200
-      });
-    });
-    await callServerProxy({
-      ...baseConfig
-    });
-    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
-  });
-  it("sends correct body fields to the proxy", async () => {
-    const stream = makeMockStream();
-    let capturedBody;
-    mockFetch(async (_url, opts) => {
-      capturedBody = JSON.parse(opts.body);
-      return new Response(stream, {
-        status: 200
-      });
-    });
-    await callServerProxy({
-      ...baseConfig
-    });
-    expect(capturedBody.mode).toBe("proxy");
-    expect(capturedBody.model).toBe("claude-opus-4-6");
-    expect(capturedBody.stream).toBe(true);
-    expect(capturedBody.max_tokens).toBe(16384);
-    expect(capturedBody.messages).toEqual(baseConfig.messages);
-    expect(capturedBody.system).toEqual(baseConfig.system);
-    expect(capturedBody.tools).toEqual(baseConfig.tools);
-    expect(capturedBody.betas).toEqual(["context-management-2025-06-27"]);
-    expect(capturedBody.context_management).toBeDefined();
-    expect(capturedBody.context_management.edits).toHaveLength(1);
-  });
-  it("includes thinking in body when apiConfig has thinking", async () => {
-    const stream = makeMockStream();
-    let capturedBody;
-    mockFetch(async (_url, opts) => {
-      capturedBody = JSON.parse(opts.body);
-      return new Response(stream, {
-        status: 200
-      });
-    });
-    await callServerProxy({
-      ...baseConfig,
-      apiConfig: {
-        ...baseConfig.apiConfig,
-        thinking: {
-          type: "adaptive"
-        }
-      }
-    });
-    expect(capturedBody.thinking).toEqual({
-      type: "adaptive"
-    });
-  });
-  it("omits thinking from body when apiConfig has no thinking", async () => {
-    const stream = makeMockStream();
-    let capturedBody;
-    mockFetch(async (_url, opts) => {
-      capturedBody = JSON.parse(opts.body);
-      return new Response(stream, {
-        status: 200
-      });
-    });
-    await callServerProxy({
-      ...baseConfig
-    });
-    expect(capturedBody.thinking).toBeUndefined();
-  });
-  it("omits context_management when edits array is empty", async () => {
-    const stream = makeMockStream();
-    let capturedBody;
-    mockFetch(async (_url, opts) => {
-      capturedBody = JSON.parse(opts.body);
-      return new Response(stream, {
-        status: 200
-      });
-    });
-    await callServerProxy({
-      ...baseConfig,
-      apiConfig: {
-        ...baseConfig.apiConfig,
-        contextManagement: {
-          edits: []
-        }
-      }
-    });
-    expect(capturedBody.context_management).toBeUndefined();
-  });
-  it("includes store_id in body when provided", async () => {
-    const stream = makeMockStream();
-    let capturedBody;
-    mockFetch(async (_url, opts) => {
-      capturedBody = JSON.parse(opts.body);
-      return new Response(stream, {
-        status: 200
-      });
-    });
-    await callServerProxy({
-      ...baseConfig,
-      storeId: "store-uuid-123"
-    });
-    expect(capturedBody.store_id).toBe("store-uuid-123");
-  });
-  it("omits store_id from body when not provided", async () => {
-    const stream = makeMockStream();
-    let capturedBody;
-    mockFetch(async (_url, opts) => {
-      capturedBody = JSON.parse(opts.body);
-      return new Response(stream, {
-        status: 200
-      });
-    });
-    await callServerProxy({
-      ...baseConfig
-    });
-    expect(capturedBody.store_id).toBeUndefined();
-  });
-
-  // ---------- Error handling ----------
-
-  it("throws on non-OK response with status and error body", async () => {
-    mockFetch(async () => new Response("Bad Request: invalid model", {
-      status: 400
-    }));
-    await expect(callServerProxy({
-      ...baseConfig
-    })).rejects.toThrow("Proxy error (400): Bad Request: invalid model");
-  });
-  it("throws on 401 without retrying", async () => {
-    mockFetch(async () => new Response("Unauthorized", {
-      status: 401
-    }));
-    await expect(callServerProxy({
-      ...baseConfig
-    })).rejects.toThrow("Proxy error (401)");
-    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
-  });
-  it("throws on null response body even with 200 status", async () => {
-    mockFetch(async () => {
-      return new Response(null, {
-        status: 204
-      });
-    });
-    await expect(callServerProxy({
-      ...baseConfig
-    })).rejects.toThrow("Proxy error (204)");
-  });
-
-  // ---------- Non-retryable errors ----------
-
-  it("does not retry on 400 Bad Request", async () => {
-    mockFetch(async () => new Response("Bad Request", {
-      status: 400
-    }));
-    await expect(callServerProxy({
-      ...baseConfig
-    })).rejects.toThrow("Proxy error (400)");
-    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
-  });
-  it("does not retry on 403 Forbidden", async () => {
-    mockFetch(async () => new Response("Forbidden", {
-      status: 403
-    }));
-    await expect(callServerProxy({
-      ...baseConfig
-    })).rejects.toThrow("Proxy error (403)");
-    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
-  });
-  it("does not retry on 404 Not Found", async () => {
-    mockFetch(async () => new Response("Not Found", {
-      status: 404
-    }));
-    await expect(callServerProxy({
-      ...baseConfig
-    })).rejects.toThrow("Proxy error (404)");
-    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
-  });
-});