@tyvm/knowhow 0.0.159 → 0.0.161

package/tests/clients/anthropic.test.ts

@@ -1,202 +0,0 @@
-import { GenericAnthropicClient } from "../../src/clients/anthropic";
-
-// We only need to test transformMessages, which doesn't require an API key
-function createClient() {
-  return new GenericAnthropicClient("fake-key");
-}
-
-describe("GenericAnthropicClient.transformMessages", () => {
-  let client: GenericAnthropicClient;
-
-  beforeEach(() => {
-    client = createClient();
-  });
-
-  it("should handle a simple user message", () => {
-    const messages = [
-      { role: "user" as const, content: "Hello" },
-    ];
-    const result = client.transformMessages(messages);
-    expect(result).toHaveLength(1);
-    expect(result[0].role).toBe("user");
-    expect(result[0].content).toBe("Hello");
-  });
-
-  it("should filter out system messages", () => {
-    const messages = [
-      { role: "system" as const, content: "You are helpful" },
-      { role: "user" as const, content: "Hello" },
-    ];
-    const result = client.transformMessages(messages);
-    expect(result).toHaveLength(1);
-    expect(result[0].role).toBe("user");
-  });
-
-  it("should inject tool_use assistant block when processing tool result", () => {
-    // Simulates: assistant responds with tool_call (content: ""), then tool result comes back
-    const messages = [
-      { role: "user" as const, content: "Use a tool" },
-      {
-        role: "assistant" as const,
-        content: "",
-        tool_calls: [
-          {
-            id: "toolu_abc123",
-            type: "function" as const,
-            function: {
-              name: "listAvailableTools",
-              arguments: "{}",
-            },
-          },
-        ],
-      },
-      {
-        role: "tool" as const,
-        tool_call_id: "toolu_abc123",
-        name: "listAvailableTools",
-        content: '{"enabled": ["finalAnswer"], "disabled": []}',
-      },
-    ];
-
-    const result = client.transformMessages(messages);
-
-    // Should have: user msg, assistant tool_use block, user tool_result block
-    expect(result.length).toBeGreaterThanOrEqual(2);
-
-    // Find the assistant message with tool_use
-    const assistantMsg = result.find(
-      (m) =>
-        m.role === "assistant" &&
-        Array.isArray(m.content) &&
-        (m.content as any[]).some((c) => c.type === "tool_use")
-    );
-    expect(assistantMsg).toBeDefined();
-    const toolUseBlock = (assistantMsg!.content as any[]).find(
-      (c) => c.type === "tool_use"
-    );
-    expect(toolUseBlock.id).toBe("toolu_abc123");
-    expect(toolUseBlock.name).toBe("listAvailableTools");
-
-    // Find the user message with tool_result
-    const userToolResult = result.find(
-      (m) =>
-        m.role === "user" &&
-        Array.isArray(m.content) &&
-        (m.content as any[]).some((c) => c.type === "tool_result")
-    );
-    expect(userToolResult).toBeDefined();
-    const toolResultBlock = (userToolResult!.content as any[]).find(
-      (c) => c.type === "tool_result"
-    );
-    expect(toolResultBlock.tool_use_id).toBe("toolu_abc123");
-  });
-
-  it("should not have undefined tool_use_id when assistant message has empty content with tool_calls", () => {
-    // This is the failing scenario: assistant has content: "" (falsy) but has tool_calls
-    const messages = [
-      { role: "user" as const, content: "Use a tool" },
-      {
-        role: "assistant" as const,
-        content: "",  // empty string - would be filtered by `msg.content` check
-        tool_calls: [
-          {
-            id: "toolu_abc123",
-            type: "function" as const,
-            function: {
-              name: "listAvailableTools",
-              arguments: "{}",
-            },
-          },
-        ],
-      },
-      {
-        role: "tool" as const,
-        tool_call_id: "toolu_abc123",
-        name: "listAvailableTools",
-        content: '{"enabled": ["finalAnswer"]}',
-      },
-    ];
-
-    const result = client.transformMessages(messages);
-
-    // Find the user message with tool_result - tool_use_id must NOT be undefined
-    const userToolResult = result.find(
-      (m) =>
-        m.role === "user" &&
-        Array.isArray(m.content) &&
-        (m.content as any[]).some((c) => c.type === "tool_result")
-    );
-    expect(userToolResult).toBeDefined();
-    const toolResultBlock = (userToolResult!.content as any[]).find(
-      (c) => c.type === "tool_result"
-    );
-    // This should be "toolu_abc123", NOT undefined
-    expect(toolResultBlock.tool_use_id).toBe("toolu_abc123");
-    expect(toolResultBlock.tool_use_id).not.toBeUndefined();
-  });
-
-  it("should handle multiple sequential tool calls", () => {
-    const messages = [
-      { role: "user" as const, content: "Do two things" },
-      {
-        role: "assistant" as const,
-        content: "",
-        tool_calls: [
-          {
-            id: "toolu_111",
-            type: "function" as const,
-            function: { name: "toolOne", arguments: "{}" },
-          },
-        ],
-      },
-      {
-        role: "tool" as const,
-        tool_call_id: "toolu_111",
-        name: "toolOne",
-        content: "result one",
-      },
-      {
-        role: "assistant" as const,
-        content: "",
-        tool_calls: [
-          {
-            id: "toolu_222",
-            type: "function" as const,
-            function: { name: "toolTwo", arguments: "{}" },
-          },
-        ],
-      },
-      {
-        role: "tool" as const,
-        tool_call_id: "toolu_222",
-        name: "toolTwo",
-        content: "result two",
-      },
-    ];
-
-    const result = client.transformMessages(messages);
-
-    // Both tool results should have correct tool_use_ids
-    const toolResults = result
-      .filter((m) => m.role === "user" && Array.isArray(m.content))
-      .flatMap((m) => (m.content as any[]).filter((c) => c.type === "tool_result"));
-
-    expect(toolResults).toHaveLength(2);
-    const ids = toolResults.map((r) => r.tool_use_id);
-    expect(ids).toContain("toolu_111");
-    expect(ids).toContain("toolu_222");
-    expect(ids).not.toContain(undefined);
-  });
-
-  it("should not crash when response is undefined (Cannot use in operator bug)", () => {
-    // Test that the base agent undefined response check doesn't throw
-    // This tests the guard we added to base.ts
-    const undefinedLike = undefined as any;
-    // Should not throw "Cannot use 'in' operator to search for 'response' in undefined"
-    expect(() => {
-      if (undefinedLike != null && "response" in undefinedLike) {
-        // This should not be reached
-      }
-    }).not.toThrow();
-  });
-});

package/tests/clients/contextLimits.test.ts

@@ -1,97 +0,0 @@
-/**
- * Tests that all models included in the Models object (anthropic, openai, google, xai)
- * have a corresponding context limit recorded in ContextLimits.
- */
-import { Models } from "../../src/types";
-import { ContextLimits, getModelContextLimit, DEFAULT_CONTEXT_LIMIT } from "../../src/clients/contextLimits";
-import {
-  OpenAiTextPricing,
-  GeminiTextPricing,
-  AnthropicTextPricing,
-  XaiTextPricing,
-  FireworksTextPricing,
-  FireworksEmbeddingPricing,
-} from "../../src/clients/pricing";
-
-// Model ids explicitly marked deprecated across all pricing tables. Deprecated
-// models are allowed to be absent from ContextLimits — they can be trimmed from
-// Models.* / the context-limit map without breaking anything, since cost
-// tracking reads the *TextPricing tables directly by model id.
-const deprecatedModelIds = new Set<string>(
-  Object.entries({
-    ...OpenAiTextPricing,
-    ...GeminiTextPricing,
-    ...AnthropicTextPricing,
-    ...XaiTextPricing,
-    ...FireworksTextPricing,
-    ...FireworksEmbeddingPricing,
-  } as Record<string, { deprecated?: boolean }>)
-    .filter(([, p]) => p && p.deprecated === true)
-    .map(([id]) => id)
-);
-
-describe("ContextLimits", () => {
-  describe("coverage - all Models.* values have a recorded context limit", () => {
-    const providers = Object.keys(Models) as Array<keyof typeof Models>;
-
-    for (const provider of providers) {
-      describe(`Models.${provider}`, () => {
-        const providerModels = Models[provider] as Record<string, string>;
-        const modelEntries = Object.entries(providerModels);
-
-        it(`should have at least one model defined for ${provider}`, () => {
-          expect(modelEntries.length).toBeGreaterThan(0);
-        });
-
-        for (const [key, modelId] of modelEntries) {
-          const testFn = deprecatedModelIds.has(modelId) ? it.skip : it;
-          testFn(`${provider}.${key} (${modelId}) should have a context limit`, () => {
-            const limit = ContextLimits[modelId];
-            expect(limit).toBeDefined();
-            expect(typeof limit).toBe("number");
-            // Non-text models (image/video/audio) are recorded as 0; text models must be > 0
-            expect(limit).toBeGreaterThanOrEqual(0);
-            expect(Number.isFinite(limit)).toBe(true);
-          });
-        }
-      });
-    }
-  });
-
-  describe("getModelContextLimit", () => {
-    it("returns the correct limit for a known OpenAI model", () => {
-      expect(getModelContextLimit(Models.openai.GPT_4o)).toBe(128_000);
-    });
-
-    it("returns the correct limit for a known Anthropic model", () => {
-      expect(getModelContextLimit(Models.anthropic.Opus4)).toBe(200_000);
-    });
-
-    it("returns the correct limit for a known Google model", () => {
-      expect(getModelContextLimit(Models.google.Gemini_15_Pro)).toBe(2_000_000);
-    });
-
-    it("returns the correct limit for a known xAI model", () => {
-      expect(getModelContextLimit(Models.xai.Grok3Beta)).toBe(131_072);
-    });
-
-    it("returns DEFAULT_CONTEXT_LIMIT for an unknown model", () => {
-      expect(getModelContextLimit("unknown-model-xyz")).toBe(DEFAULT_CONTEXT_LIMIT);
-    });
-
-    it("DEFAULT_CONTEXT_LIMIT is a positive number", () => {
-      expect(DEFAULT_CONTEXT_LIMIT).toBeGreaterThan(0);
-    });
-  });
-
-  describe("ContextLimits values are all valid numbers", () => {
-    it("all recorded limits are non-negative finite numbers", () => {
-      for (const [model, limit] of Object.entries(ContextLimits)) {
-        expect(typeof limit).toBe("number");
-        // 0 is allowed for non-text models (image/video/audio)
-        expect(limit).toBeGreaterThanOrEqual(0);
-        expect(Number.isFinite(limit)).toBe(true);
-      }
-    });
-  });
-});

package/tests/clients/fireworks.test.ts

@@ -1,65 +0,0 @@
-import http from "../../src/utils/http";
-import { GenericFireworksClient } from "../../src/clients/fireworks";
-import { FireworksModels } from "../../src/clients/pricing/fireworks";
-
-jest.mock("../../src/utils/http", () => ({
-  __esModule: true,
-  default: { post: jest.fn() },
-}));
-
-const post = http.post as jest.MockedFunction<typeof http.post>;
-
-describe("GenericFireworksClient", () => {
-  beforeEach(() => {
-    post.mockReset();
-    post.mockResolvedValue({
-      data: {
-        choices: [{ message: { role: "assistant", content: "ok" } }],
-        model: FireworksModels.DeepseekV4Flash,
-        usage: { prompt_tokens: 2, completion_tokens: 1, total_tokens: 3 },
-      },
-    } as any);
-  });
-
-  it("removes non-Fireworks options and tool return metadata", async () => {
-    const client = new GenericFireworksClient("test-key");
-
-    await client.createChatCompletion({
-      model: FireworksModels.DeepseekV4Flash,
-      messages: [{ role: "user", content: "hello" }],
-      max_tokens: 100,
-      reasoning_summary: true,
-      long_ttl_cache: true,
-      tools: [{
-        type: "function",
-        function: {
-          name: "lookup",
-          description: "Look something up",
-          parameters: { type: "object", properties: {} },
-          returns: { type: "string" },
-        } as any,
-      }],
-    });
-
-    expect(post).toHaveBeenCalledTimes(1);
-    const [url, body, requestOptions] = post.mock.calls[0];
-    expect(url).toBe("https://api.fireworks.ai/inference/v1/chat/completions");
-    expect(requestOptions).toMatchObject({
-      headers: { Authorization: "Bearer test-key" },
-    });
-    expect(body).toMatchObject({
-      model: FireworksModels.DeepseekV4Flash,
-      messages: [{ role: "user", content: "hello" }],
-      max_tokens: 100,
-      tool_choice: "auto",
-    });
-    const serializedBody = JSON.parse(JSON.stringify(body));
-    expect(serializedBody).not.toHaveProperty("reasoning_summary");
-    expect(serializedBody).not.toHaveProperty("long_ttl_cache");
-    expect(serializedBody.tools[0].function).toEqual({
-      name: "lookup",
-      description: "Look something up",
-      parameters: { type: "object", properties: {} },
-    });
-  });
-});

package/tests/clients/openai.images.test.ts

@@ -1,105 +0,0 @@
-import { GenericOpenAiClient } from "../../src/clients/openai";
-import { Message } from "../../src/clients/types";
-
-describe("GenericOpenAiClient image message conversion", () => {
-  const imageUrl = "data:image/jpeg;base64,/9j/4AAQSkZJRg==";
-  let client: GenericOpenAiClient;
-
-  beforeEach(() => {
-    client = new GenericOpenAiClient("test-key");
-  });
-
-  it("moves tool image output to a user message for Chat Completions", () => {
-    const messages: Message[] = [{
-      role: "tool",
-      tool_call_id: "call_1",
-      name: "loadImageAsBase64",
-      content: [{
-        type: "image_url",
-        image_url: { url: imageUrl, detail: "high" },
-      }],
-    }];
-
-    const converted = client.toChatCompletionMessages(messages);
-
-    expect(converted).toEqual([
-      {
-        role: "tool",
-        tool_call_id: "call_1",
-        content: [{
-          type: "text",
-          text: "Image output attached in the following user message.",
-        }],
-      },
-      {
-        role: "user",
-        content: [{
-          type: "image_url",
-          image_url: { url: imageUrl, detail: "high" },
-        }],
-      },
-    ]);
-  });
-
-  it("uses input_image parts for the Responses API", () => {
-    const converted = client.toResponseContent([
-      { type: "text", text: "Screenshot" },
-      { type: "image_url", image_url: { url: imageUrl, detail: "low" } },
-    ]);
-
-    expect(converted).toEqual([
-      { type: "input_text", text: "Screenshot" },
-      { type: "input_image", image_url: imageUrl, detail: "low" },
-    ]);
-  });
-
-  it.each([
-    { type: "audio_url", audio_url: { url: "data:audio/wav;base64,UklGRg==" } },
-    { type: "video_url", video_url: { url: "data:video/mp4;base64,AAAAIGZ0eXA=" } },
-  ] as const)("rejects unsupported $type Responses API content instead of dropping it", (part) => {
-    expect(() => client.toResponseContent([
-      { type: "text", text: "Media" },
-      part,
-    ])).toThrow(
-      `OpenAI Responses API conversion does not support ${part.type} content.`
-    );
-  });
-
-  it("attaches a tool image as input_image in a Responses API request", async () => {
-    const create = jest.fn().mockResolvedValue({
-      id: "resp_1",
-      output: [],
-      usage: undefined,
-    });
-    (client as any).client = { responses: { create } };
-
-    await client.createChatResponse({
-      model: "gpt-5.4",
-      reasoning_effort: "none",
-      messages: [{
-        role: "tool",
-        tool_call_id: "call_1",
-        content: [{
-          type: "image_url",
-          image_url: { url: imageUrl, detail: "auto" },
-        }],
-      }],
-    });
-
-    expect(create.mock.calls[0][0].input).toEqual([
-      {
-        type: "function_call_output",
-        call_id: "call_1",
-        output: "Image output attached in the following user message.",
-      },
-      {
-        role: "user",
-        content: [{
-          type: "input_image",
-          image_url: imageUrl,
-          detail: "auto",
-        }],
-      },
-    ]);
-  });
-});

package/tests/clients/pricing.test.ts

@@ -1,206 +0,0 @@
-/**
- * Test that verifies every model supported by the Clients has a corresponding
- * pricing entry. This ensures we never release model support without knowing the price.
- *
- * Models that are image-only, video-only, TTS, transcription, realtime, or live streaming
- * are exempt from text pricing requirements — they should have their own pricing entries
- * in the appropriate pricing tables (image, video, audio, etc.).
- * 
- * Also verifies that every model in Models.* and EmbeddingModels.* has a catalog entry,
- * ensuring the catalog stays in sync with the model definitions.
- */
-
-import {
-  Models,
-  EmbeddingModels,
-  GoogleImageModels,
-  GoogleVideoModels,
-  GoogleTTSModels,
-  OpenAiImageModels,
-  OpenAiVideoModels,
-  OpenAiTTSModels,
-  OpenAiTranscriptionModels,
-  OpenAiRealtimeModels,
-  XaiImageModels,
-  XaiVideoModels,
-} from "../../src/types";
-
-import {
-  OpenAiTextPricing,
-  GeminiTextPricing,
-  AnthropicTextPricing,
-  XaiTextPricing,
-  FireworksTextPricing,
-  FireworksEmbeddingPricing,
-  ALL_MODEL_CATALOG,
-  XaiImagePricing,
-  XaiVideoPricing,
-} from "../../src/clients/pricing";
-
-describe("Model Pricing Coverage", () => {
-  /**
-   * Models that are exclusively non-text modalities (image, video, TTS, transcription,
-   * realtime/live audio) and therefore do NOT need a text token pricing entry.
-   * They still must appear in their own modality-specific pricing table (see separate tests below).
-   */
-  const nonTextModels = new Set<string>([
-    ...GoogleImageModels,
-    ...GoogleVideoModels,
-    ...GoogleTTSModels,
-    ...OpenAiImageModels,
-    ...OpenAiVideoModels,
-    ...OpenAiTTSModels,
-    ...OpenAiTranscriptionModels,
-    ...OpenAiRealtimeModels,
-    ...XaiImageModels,
-    ...XaiVideoModels,
-    // Live streaming model — not a standard text completion model
-    Models.google.Gemini_20_Flash_Live,
-  ]);
-
-  const allTextPricing: Record<string, unknown> = {
-    ...OpenAiTextPricing,
-    ...GeminiTextPricing,
-    ...AnthropicTextPricing,
-    ...XaiTextPricing,
-    ...FireworksTextPricing,
-    ...FireworksEmbeddingPricing,
-  };
-
-  describe("Text completion models have pricing", () => {
-    for (const [provider, providerModels] of Object.entries(Models)) {
-      for (const [modelKey, modelId] of Object.entries(
-        providerModels as Record<string, string>
-      )) {
-        if (nonTextModels.has(modelId)) {
-          // Skip — covered by modality-specific tests below
-          continue;
-        }
-
-        it(`${provider}.${modelKey} (${modelId}) has text pricing`, () => {
-          const entry = allTextPricing[modelId];
-          expect(entry).toBeDefined();
-          expect(entry).toEqual(
-            expect.objectContaining({ input: expect.any(Number) })
-          );
-        });
-      }
-    }
-  });
-
-  describe("Embedding models have pricing", () => {
-    const allEmbeddingPricing: Record<string, unknown> = {
-      ...OpenAiTextPricing, // OpenAI embeddings are in the text pricing table
-      ...GeminiTextPricing, // Google embeddings are in the Gemini pricing table
-    };
-
-    for (const [provider, providerModels] of Object.entries(EmbeddingModels)) {
-      for (const [modelKey, modelId] of Object.entries(
-        providerModels as Record<string, string>
-      )) {
-        it(`EmbeddingModels.${provider}.${modelKey} (${modelId}) has pricing`, () => {
-          const entry = allEmbeddingPricing[modelId];
-          expect(entry).toBeDefined();
-        });
-      }
-    }
-  });
-
-  describe("XAI image models have image pricing", () => {
-    const xaiImagePricing = XaiImagePricing as Record<string, unknown>;
-
-    for (const modelId of XaiImageModels) {
-      it(`XAI image model (${modelId}) has image pricing`, () => {
-        const entry = xaiImagePricing[modelId];
-        expect(entry).toBeDefined();
-      });
-    }
-  });
-
-  describe("XAI video models have video pricing", () => {
-    const xaiVideoPricing = XaiVideoPricing as Record<string, unknown>;
-
-    for (const modelId of XaiVideoModels) {
-      it(`XAI video model (${modelId}) has video pricing`, () => {
-        const entry = xaiVideoPricing[modelId];
-        expect(entry).toBeDefined();
-      });
-    }
-  });
-
-  describe("Google image models have pricing", () => {
-    const geminiPricing = GeminiTextPricing as Record<string, unknown>;
-
-    for (const modelId of GoogleImageModels) {
-      it(`Google image model (${modelId}) has pricing in GeminiTextPricing`, () => {
-        const entry = geminiPricing[modelId];
-        expect(entry).toBeDefined();
-      });
-    }
-  });
-
-  describe("Google video models have pricing", () => {
-    const geminiPricing = GeminiTextPricing as Record<string, unknown>;
-
-    for (const modelId of GoogleVideoModels) {
-      it(`Google video model (${modelId}) has pricing in GeminiTextPricing`, () => {
-        const entry = geminiPricing[modelId];
-        expect(entry).toBeDefined();
-      });
-    }
-
-describe("Model Catalog Coverage", () => {
-  /**
-   * Every model defined in Models.* and EmbeddingModels.* must have an entry
-   * in ALL_MODEL_CATALOG. This ensures the catalog stays in sync and is the
-   * single source of truth for model metadata and pricing.
-   *
-   * Exception: models flagged `deprecated` in their pricing entry are allowed to
-   * be absent from the catalog. Cost tracking for historical usage still works
-   * because calculateCost() reads the *TextPricing tables directly by model id,
-   * independently of the catalog — so deprecated models can be trimmed from the
-   * catalog/Models.* without breaking cost calculation.
-   */
-  const catalogIds = new Set(ALL_MODEL_CATALOG.map((m) => m.id));
-
-  // Model ids explicitly marked deprecated across all pricing tables.
-  const deprecatedModelIds = new Set<string>(
-    Object.entries({
-      ...OpenAiTextPricing,
-      ...GeminiTextPricing,
-      ...AnthropicTextPricing,
-      ...XaiTextPricing,
-      ...FireworksTextPricing,
-      ...FireworksEmbeddingPricing,
-    } as Record<string, { deprecated?: boolean }>)
-      .filter(([, p]) => p && p.deprecated === true)
-      .map(([id]) => id)
-  );
-
-  describe("All Models.* entries are in the catalog", () => {
-    for (const [provider, providerModels] of Object.entries(Models)) {
-      for (const [modelKey, modelId] of Object.entries(
-        providerModels as Record<string, string>
-      )) {
-        const testFn = deprecatedModelIds.has(modelId) ? it.skip : it;
-        testFn(`Models.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
-          expect(catalogIds.has(modelId)).toBe(true);
-        });
-      }
-    }
-  });
-
-  describe("All EmbeddingModels.* entries are in the catalog", () => {
-    for (const [provider, providerModels] of Object.entries(EmbeddingModels)) {
-      for (const [modelKey, modelId] of Object.entries(
-        providerModels as Record<string, string>
-      )) {
-        it(`EmbeddingModels.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
-          expect(catalogIds.has(modelId)).toBe(true);
-        });
-      }
-    }
-  });
-});
-  });
-});