whale-code 6.5.6 → 6.5.7

package/dist/server/providers/__tests__/registry.test.js

@@ -0,0 +1,183 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+// Mock getProvider from shared/constants
+vi.mock("../../../shared/constants.js", () => ({
+  getProvider: modelId => {
+    if (modelId === "auto") return "anthropic";
+    if (modelId.includes(".anthropic.") || modelId.startsWith("anthropic.")) return "bedrock";
+    if (modelId.startsWith("gemini-")) return "gemini";
+    if (modelId.startsWith("gpt-") || /^o\d/.test(modelId)) return "openai";
+    return "anthropic";
+  }
+}));
+
+// We need to reset the registry state between tests since it uses a module-level Map.
+// Re-import after each reset.
+let registerProvider;
+let getProviderAdapter;
+let hasProvider;
+let getRegisteredProviders;
+describe("Provider Registry", () => {
+  beforeEach(async () => {
+    // Reset module to get a fresh Map
+    vi.resetModules();
+    const mod = await import("../registry.js");
+    registerProvider = mod.registerProvider;
+    getProviderAdapter = mod.getProviderAdapter;
+    hasProvider = mod.hasProvider;
+    getRegisteredProviders = mod.getRegisteredProviders;
+  });
+
+  // ---------------------------------------------------------------------------
+  // registerProvider + hasProvider
+  // ---------------------------------------------------------------------------
+
+  describe("registerProvider", () => {
+    it("registers a provider adapter", () => {
+      const adapter = {
+        name: "anthropic"
+      };
+      registerProvider("anthropic", adapter);
+      expect(hasProvider("anthropic")).toBe(true);
+    });
+    it("overwrites an existing provider with the same name", () => {
+      const adapter1 = {
+        name: "anthropic",
+        version: 1
+      };
+      const adapter2 = {
+        name: "anthropic",
+        version: 2
+      };
+      registerProvider("anthropic", adapter1);
+      registerProvider("anthropic", adapter2);
+      const result = getProviderAdapter("anthropic");
+      expect(result.version).toBe(2);
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // hasProvider
+  // ---------------------------------------------------------------------------
+
+  describe("hasProvider", () => {
+    it("returns false for unregistered provider", () => {
+      expect(hasProvider("nonexistent")).toBe(false);
+    });
+    it("returns true for registered provider", () => {
+      registerProvider("gemini", {
+        name: "gemini"
+      });
+      expect(hasProvider("gemini")).toBe(true);
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // getRegisteredProviders
+  // ---------------------------------------------------------------------------
+
+  describe("getRegisteredProviders", () => {
+    it("returns empty array when no providers registered", () => {
+      expect(getRegisteredProviders()).toEqual([]);
+    });
+    it("returns all registered provider names", () => {
+      registerProvider("anthropic", {
+        name: "anthropic"
+      });
+      registerProvider("openai", {
+        name: "openai"
+      });
+      registerProvider("gemini", {
+        name: "gemini"
+      });
+      expect(getRegisteredProviders()).toEqual(["anthropic", "openai", "gemini"]);
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // getProviderAdapter
+  // ---------------------------------------------------------------------------
+
+  describe("getProviderAdapter", () => {
+    it("returns adapter by direct provider name", () => {
+      const adapter = {
+        name: "openai"
+      };
+      registerProvider("openai", adapter);
+      expect(getProviderAdapter("openai")).toBe(adapter);
+    });
+    it("resolves a model ID to its provider adapter", () => {
+      const adapter = {
+        name: "gemini"
+      };
+      registerProvider("gemini", adapter);
+      // "gemini-2.5-pro" should resolve to "gemini" via getProvider
+      expect(getProviderAdapter("gemini-2.5-pro")).toBe(adapter);
+    });
+    it("resolves anthropic model IDs correctly", () => {
+      const adapter = {
+        name: "anthropic"
+      };
+      registerProvider("anthropic", adapter);
+      expect(getProviderAdapter("claude-sonnet-4-6")).toBe(adapter);
+    });
+    it("resolves openai model IDs (gpt-*)", () => {
+      const adapter = {
+        name: "openai"
+      };
+      registerProvider("openai", adapter);
+      expect(getProviderAdapter("gpt-5")).toBe(adapter);
+    });
+    it("resolves openai reasoning model IDs (o-series)", () => {
+      const adapter = {
+        name: "openai"
+      };
+      registerProvider("openai", adapter);
+      expect(getProviderAdapter("o3")).toBe(adapter);
+    });
+    it("resolves bedrock model IDs", () => {
+      const adapter = {
+        name: "bedrock"
+      };
+      registerProvider("bedrock", adapter);
+      expect(getProviderAdapter("anthropic.claude-sonnet-4-6")).toBe(adapter);
+    });
+    it("falls back to anthropic for unknown model IDs", () => {
+      const adapter = {
+        name: "anthropic"
+      };
+      registerProvider("anthropic", adapter);
+      // Unknown model ID resolves to "anthropic" via getProvider default
+      expect(getProviderAdapter("some-unknown-model")).toBe(adapter);
+    });
+    it("throws if no adapters are registered at all", () => {
+      expect(() => getProviderAdapter("claude-sonnet-4-6")).toThrow(/No provider adapter registered/);
+    });
+    it("falls back to anthropic when resolved provider is not registered", () => {
+      // Register only anthropic, request a gemini model
+      const adapter = {
+        name: "anthropic"
+      };
+      registerProvider("anthropic", adapter);
+      expect(getProviderAdapter("gemini-2.5-flash")).toBe(adapter);
+    });
+    it("throws when resolved provider is not registered and no anthropic fallback", () => {
+      registerProvider("openai", {
+        name: "openai"
+      });
+      // "gemini-2.5-pro" resolves to "gemini" which isn't registered, and no "anthropic" fallback
+      expect(() => getProviderAdapter("gemini-2.5-pro")).toThrow(/No provider adapter registered/);
+    });
+    it("error message includes registered providers", () => {
+      registerProvider("openai", {
+        name: "openai"
+      });
+      try {
+        getProviderAdapter("gemini-2.5-pro");
+      } catch (err) {
+        expect(err.message).toContain("openai");
+        expect(err.message).toContain("gemini-2.5-pro");
+      }
+    });
+  });
+});

package/dist/server/providers/__tests__/shared.test.js

@@ -0,0 +1,297 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock @supabase/supabase-js
+const mockRpc = vi.fn();
+const mockCreateClient = vi.fn(() => ({
+  rpc: mockRpc
+}));
+vi.mock("@supabase/supabase-js", () => ({
+  createClient: (_url, _key) => mockCreateClient()
+}));
+import { jsonResponse, writeSSEHeaders, emitError, resolveProviderCredentials } from "../shared.js";
+
+// ---------------------------------------------------------------------------
+// Helper: create a mock ServerResponse
+// ---------------------------------------------------------------------------
+function createMockRes() {
+  return {
+    writeHead: vi.fn(),
+    end: vi.fn(),
+    write: vi.fn(),
+    flushHeaders: vi.fn(),
+    headersSent: false
+  };
+}
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*"
+};
+
+// ============================================================================
+// jsonResponse
+// ============================================================================
+
+describe("jsonResponse", () => {
+  it("writes JSON with correct status and content type", () => {
+    const res = createMockRes();
+    jsonResponse(res, 200, {
+      ok: true
+    }, corsHeaders);
+    expect(res.writeHead).toHaveBeenCalledWith(200, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    });
+    expect(res.end).toHaveBeenCalledWith(JSON.stringify({
+      ok: true
+    }));
+  });
+  it("sends error status codes", () => {
+    const res = createMockRes();
+    jsonResponse(res, 400, {
+      error: "bad request"
+    }, corsHeaders);
+    expect(res.writeHead).toHaveBeenCalledWith(400, expect.objectContaining({
+      "Content-Type": "application/json"
+    }));
+  });
+  it("merges CORS headers", () => {
+    const res = createMockRes();
+    const customCors = {
+      "Access-Control-Allow-Origin": "https://app.example.com",
+      "X-Custom": "yes"
+    };
+    jsonResponse(res, 200, {}, customCors);
+    expect(res.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({
+      "Access-Control-Allow-Origin": "https://app.example.com",
+      "X-Custom": "yes"
+    }));
+  });
+});
+
+// ============================================================================
+// writeSSEHeaders
+// ============================================================================
+
+describe("writeSSEHeaders", () => {
+  it("writes SSE headers with correct content type", () => {
+    const res = createMockRes();
+    writeSSEHeaders(res, corsHeaders);
+    expect(res.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    }));
+  });
+  it("calls flushHeaders", () => {
+    const res = createMockRes();
+    writeSSEHeaders(res, corsHeaders);
+    expect(res.flushHeaders).toHaveBeenCalled();
+  });
+  it("includes CORS headers", () => {
+    const res = createMockRes();
+    writeSSEHeaders(res, {
+      "Access-Control-Allow-Origin": "https://example.com"
+    });
+    expect(res.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({
+      "Access-Control-Allow-Origin": "https://example.com"
+    }));
+  });
+});
+
+// ============================================================================
+// emitError
+// ============================================================================
+
+describe("emitError", () => {
+  const sanitize = e => e?.message || String(e);
+  it("sends JSON error when headers NOT yet sent", () => {
+    const res = createMockRes();
+    res.headersSent = false;
+    emitError(res, new Error("fail"), corsHeaders, sanitize);
+    expect(res.writeHead).toHaveBeenCalledWith(502, expect.objectContaining({
+      "Content-Type": "application/json"
+    }));
+    const body = JSON.parse(res.end.mock.calls[0][0]);
+    expect(body.error).toContain("fail");
+  });
+  it("sends SSE error events when headers already sent", () => {
+    const res = createMockRes();
+    res.headersSent = true;
+    emitError(res, new Error("stream failure"), corsHeaders, sanitize);
+
+    // Should write error, message_delta, message_stop, and [DONE]
+    expect(res.write).toHaveBeenCalledTimes(4);
+    const calls = res.write.mock.calls.map(c => c[0]);
+    // First: error event
+    expect(calls[0]).toContain('"type":"error"');
+    // Second: message_delta with stop_reason "error"
+    expect(calls[1]).toContain('"type":"message_delta"');
+    expect(calls[1]).toContain('"stop_reason":"error"');
+    // Third: message_stop
+    expect(calls[2]).toContain('"type":"message_stop"');
+    // Fourth: [DONE]
+    expect(calls[3]).toContain("[DONE]");
+  });
+  it("includes usage tokens in message_delta when headers already sent", () => {
+    const res = createMockRes();
+    res.headersSent = true;
+    emitError(res, new Error("err"), corsHeaders, sanitize, {
+      inputTokens: 100,
+      outputTokens: 50,
+      thinkingTokens: 25,
+      cacheReadTokens: 10
+    });
+    const deltaCall = res.write.mock.calls[1][0];
+    const parsed = JSON.parse(deltaCall.replace("data: ", "").trim());
+    expect(parsed.usage.input_tokens).toBe(100);
+    expect(parsed.usage.output_tokens).toBe(50);
+    expect(parsed.usage.thinking_tokens).toBe(25);
+    expect(parsed.usage.cache_read_input_tokens).toBe(10);
+  });
+  it("omits thinking_tokens when zero", () => {
+    const res = createMockRes();
+    res.headersSent = true;
+    emitError(res, new Error("err"), corsHeaders, sanitize, {
+      inputTokens: 100,
+      outputTokens: 50,
+      thinkingTokens: 0
+    });
+    const deltaCall = res.write.mock.calls[1][0];
+    const parsed = JSON.parse(deltaCall.replace("data: ", "").trim());
+    expect(parsed.usage.thinking_tokens).toBeUndefined();
+  });
+  it("uses custom provider name in error message", () => {
+    const res = createMockRes();
+    res.headersSent = false;
+    emitError(res, new Error("timeout"), corsHeaders, sanitize, {
+      provider: "gemini"
+    });
+    const body = JSON.parse(res.end.mock.calls[0][0]);
+    expect(body.error).toContain("gemini");
+  });
+  it("defaults provider to 'proxy'", () => {
+    const res = createMockRes();
+    res.headersSent = false;
+    emitError(res, new Error("default"), corsHeaders, sanitize);
+    const body = JSON.parse(res.end.mock.calls[0][0]);
+    expect(body.error).toContain("proxy");
+  });
+  it("handles non-Error objects", () => {
+    const res = createMockRes();
+    res.headersSent = false;
+    emitError(res, "string error", corsHeaders, sanitize);
+    const body = JSON.parse(res.end.mock.calls[0][0]);
+    expect(body.error).toContain("string error");
+  });
+});
+
+// ============================================================================
+// resolveProviderCredentials
+// ============================================================================
+
+describe("resolveProviderCredentials", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockRpc.mockReset();
+    // Set env vars
+    process.env.SUPABASE_URL = "https://test.supabase.co";
+    process.env.SUPABASE_SERVICE_ROLE_KEY = "test-key";
+  });
+  it("resolves Google credentials", async () => {
+    mockRpc.mockResolvedValue({
+      data: "google-api-key-123",
+      error: null
+    });
+    const result = await resolveProviderCredentials("google", "store1");
+    expect(result.google).toEqual({
+      apiKey: "google-api-key-123"
+    });
+  });
+  it("resolves OpenAI credentials", async () => {
+    mockRpc.mockResolvedValue({
+      data: "sk-openai-key",
+      error: null
+    });
+    const result = await resolveProviderCredentials("openai", "store1");
+    expect(result.openai).toEqual({
+      apiKey: "sk-openai-key"
+    });
+  });
+  it("resolves Bedrock credentials", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: "AKID123",
+      error: null
+    }).mockResolvedValueOnce({
+      data: "secret456",
+      error: null
+    }).mockResolvedValueOnce({
+      data: "us-west-2",
+      error: null
+    });
+    const result = await resolveProviderCredentials("bedrock", "store1");
+    expect(result.bedrock).toEqual({
+      accessKeyId: "AKID123",
+      secretAccessKey: "secret456",
+      region: "us-west-2"
+    });
+  });
+  it("defaults bedrock region to us-east-1 when not found", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: "AKID123",
+      error: null
+    }).mockResolvedValueOnce({
+      data: "secret456",
+      error: null
+    }).mockResolvedValueOnce({
+      data: null,
+      error: null
+    });
+
+    // Use unique storeId to avoid cache hit from previous bedrock test
+    const result = await resolveProviderCredentials("bedrock", "store-region-test");
+    expect(result.bedrock?.region).toBe("us-east-1");
+  });
+  it("handles RPC errors gracefully for google", async () => {
+    mockRpc.mockResolvedValue({
+      data: null,
+      error: {
+        message: "not found"
+      }
+    });
+
+    // Use unique storeId to avoid cache hit
+    const result = await resolveProviderCredentials("google", "store-error-test");
+    expect(result.google).toBeUndefined();
+  });
+  it("handles RPC exceptions gracefully for openai", async () => {
+    mockRpc.mockRejectedValue(new Error("network error"));
+
+    // Use unique storeId to avoid cache hit
+    const result = await resolveProviderCredentials("openai", "store-exception-test");
+    expect(result.openai).toBeUndefined();
+  });
+  it("uses cached credentials within TTL", async () => {
+    mockRpc.mockResolvedValue({
+      data: "key1",
+      error: null
+    });
+
+    // First call
+    await resolveProviderCredentials("google", "store2");
+    // Second call should use cache (different mock return to prove)
+    mockRpc.mockResolvedValue({
+      data: "key2",
+      error: null
+    });
+    const result = await resolveProviderCredentials("google", "store2");
+    expect(result.google?.apiKey).toBe("key1");
+  });
+  it("uses default store key when storeId is undefined", async () => {
+    mockRpc.mockResolvedValue({
+      data: "default-key",
+      error: null
+    });
+    const result = await resolveProviderCredentials("google", undefined);
+    expect(result.google?.apiKey).toBe("default-key");
+  });
+});

package/dist/server/providers/gemini-conversion.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gemini format conversion utilities — message and schema conversion.
+ * Extracted from gemini.ts for single-responsibility.
+ */
+import type { Content, FunctionDeclaration } from "@google/genai";
+/** Convert Anthropic messages to Gemini Content format */
+export declare function anthropicToGeminiMessages(messages: any[]): Content[];
+/**
+ * Sanitize JSON Schema -> Gemini OpenAPI Schema:
+ * - Convert type values to uppercase (string -> STRING)
+ * - Stringify all enum values
+ * - Remove unsupported JSON Schema keys (carefully -- don't strip property names)
+ * - Ensure arrays have items, objects have properties
+ * - Filter required to only include defined properties
+ */
+export declare function sanitizeSchemaForGemini(schema: any): any;
+export declare function anthropicToGeminiFunctions(tools: any[]): FunctionDeclaration[];

package/dist/server/providers/gemini-conversion.js

@@ -0,0 +1,185 @@
+/**
+ * Gemini format conversion utilities — message and schema conversion.
+ * Extracted from gemini.ts for single-responsibility.
+ */
+
+// ============================================================================
+// MESSAGE CONVERSION
+// ============================================================================
+
+/** Convert Anthropic messages to Gemini Content format */
+export function anthropicToGeminiMessages(messages) {
+  const raw = [];
+  // Track tool_use_id -> name for tool_result conversion
+  const toolIdMap = new Map();
+  for (const msg of messages) {
+    const role = msg.role === "assistant" ? "model" : "user";
+    const parts = [];
+    if (typeof msg.content === "string") {
+      parts.push({
+        text: msg.content
+      });
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text" && block.text) {
+          parts.push({
+            text: block.text
+          });
+        } else if (block.type === "tool_use") {
+          toolIdMap.set(block.id, block.name);
+          parts.push({
+            functionCall: {
+              name: block.name,
+              args: block.input || {}
+            },
+            // Preserve Gemini thought signature for function call round-trips
+            ...(block.thought_signature ? {
+              thoughtSignature: block.thought_signature
+            } : {})
+          });
+        } else if (block.type === "image" && block.source?.data) {
+          parts.push({
+            inlineData: {
+              mimeType: block.source.media_type,
+              data: block.source.data
+            }
+          });
+        } else if (block.type === "tool_result") {
+          const toolName = toolIdMap.get(block.tool_use_id) || block.tool_use_id;
+          let resultContent = "";
+          if (typeof block.content === "string") {
+            resultContent = block.content;
+          } else if (Array.isArray(block.content)) {
+            resultContent = block.content.filter(c => c.type === "text").map(c => c.text).join("\n");
+          }
+          parts.push({
+            functionResponse: {
+              name: toolName,
+              response: {
+                result: resultContent
+              }
+            }
+          });
+        }
+      }
+    }
+    if (parts.length > 0) {
+      raw.push({
+        role,
+        parts
+      });
+    }
+  }
+
+  // Gemini requires strictly alternating user/model turns.
+  // After context compaction or multi-step tool use, consecutive same-role turns
+  // can appear — Gemini rejects these with INVALID_ARGUMENT.
+  // Fix: merge consecutive same-role turns by concatenating their parts.
+  const contents = [];
+  for (const turn of raw) {
+    const prev = contents[contents.length - 1];
+    if (prev && prev.role === turn.role) {
+      // Merge into the previous turn
+      prev.parts = [...(prev.parts || []), ...(turn.parts || [])];
+    } else {
+      contents.push({
+        role: turn.role,
+        parts: turn.parts
+      });
+    }
+  }
+  return contents;
+}
+
+// ============================================================================
+// SCHEMA SANITIZATION
+// ============================================================================
+
+/** Gemini uses uppercase OpenAPI schema types, not lowercase JSON Schema types. */
+const GEMINI_TYPE_MAP = {
+  string: "STRING",
+  number: "NUMBER",
+  integer: "INTEGER",
+  boolean: "BOOLEAN",
+  array: "ARRAY",
+  object: "OBJECT"
+};
+
+/**
+ * Keys that are JSON Schema-only and not supported by Gemini's OpenAPI Schema.
+ * IMPORTANT: Only strip keys that can't collide with property names in our tools.
+ */
+const GEMINI_SCHEMA_ONLY_KEYS = new Set(["$schema", "additionalProperties", "propertyNames", "minProperties", "maxProperties", "anyOf", "oneOf", "allOf", "not", "const"]);
+
+/** Keys to strip only from schema definition objects (objects with a "type" field) */
+const GEMINI_SCHEMA_VALIDATION_KEYS = new Set(["exclusiveMinimum", "exclusiveMaximum", "minItems", "maxItems", "minLength", "maxLength", "minimum", "maximum", "pattern", "default"]);
+
+/**
+ * Sanitize JSON Schema -> Gemini OpenAPI Schema:
+ * - Convert type values to uppercase (string -> STRING)
+ * - Stringify all enum values
+ * - Remove unsupported JSON Schema keys (carefully -- don't strip property names)
+ * - Ensure arrays have items, objects have properties
+ * - Filter required to only include defined properties
+ */
+export function sanitizeSchemaForGemini(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map(s => sanitizeSchemaForGemini(s));
+  const result = {};
+  const isSchemaNode = "type" in schema;
+  for (const [key, value] of Object.entries(schema)) {
+    // Always strip structural JSON Schema keys
+    if (GEMINI_SCHEMA_ONLY_KEYS.has(key)) continue;
+    // Strip validation keys only from schema nodes (not property name maps)
+    if (isSchemaNode && GEMINI_SCHEMA_VALIDATION_KEYS.has(key)) continue;
+    if (key === "type" && typeof value === "string") {
+      result[key] = GEMINI_TYPE_MAP[value] || value.toUpperCase();
+    } else if (key === "enum" && Array.isArray(value)) {
+      result[key] = value.map(v => String(v));
+    } else if (key === "properties" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      // Properties map: keys are property names, values are schema definitions
+      const props = {};
+      for (const [propName, propSchema] of Object.entries(value)) {
+        props[propName] = sanitizeSchemaForGemini(propSchema);
+      }
+      result[key] = props;
+    } else {
+      result[key] = sanitizeSchemaForGemini(value);
+    }
+  }
+
+  // Gemini requires array items to have a type
+  if (result.type === "ARRAY") {
+    if (!result.items || typeof result.items === "object" && Object.keys(result.items).length === 0) {
+      result.items = {
+        type: "STRING"
+      };
+    }
+  }
+
+  // Gemini requires object types to have properties
+  if (result.type === "OBJECT" && !result.properties) {
+    result.properties = {};
+  }
+
+  // Gemini only allows enum on STRING type -- force type to STRING if enum is present
+  if (result.enum && Array.isArray(result.enum) && result.type && result.type !== "STRING") {
+    result.type = "STRING";
+  }
+
+  // Filter required to only include properties that actually exist
+  if (result.required && Array.isArray(result.required) && result.properties) {
+    const validProps = new Set(Object.keys(result.properties));
+    result.required = result.required.filter(r => validProps.has(r));
+    if (result.required.length === 0) delete result.required;
+  }
+  return result;
+}
+export function anthropicToGeminiFunctions(tools) {
+  return tools.map(t => ({
+    name: t.name,
+    description: typeof t.description === "string" ? t.description.slice(0, 4096) : "",
+    parameters: sanitizeSchemaForGemini(t.input_schema || {})
+  }));
+}
+//# sourceMappingURL=gemini-conversion.js.map