Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

5.4 KB
Raw Blame
import { afterEach, beforeEach, expect, test } from "bun:test";
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import type { AggregatorEntry } from "../model-loader.js";
import type { DiskCacheV3 } from "./all-models-cache.js";
import type { CachedRouteRegistry, KnownWire } from "./connection-wire.js";

const id = "muse-spark-1.3";
const generation = "g-run3-connections";
// Cloud models catalog fixture, not a Meta HTTP response.
const plainWire: KnownWire = {
  status: "known",
  api: "responses",
  tokenParam: "max_output_tokens",
  toolsWithReasoning: "ok",
  reasoning: { status: "unknown" },
  speed: { status: "unknown" },
  evidence: [],
};
const contributorWire: KnownWire = {
  ...plainWire,
  api: "chat-completions",
  tokenParam: "max_tokens",
};
function connection(
  wireId: string,
  wire: KnownWire,
  routeId = "meta",
  profile = "direct-api"
): AggregatorEntry {
  return {
    sourceProviderId: routeId,
    sourceCollectorId: routeId,
    confidence: "api_official",
    routeStatus: "mapped",
    route: { routeId, routeProfileId: profile },
    externalModelId: wireId,
    wire,
  };
}
let home: string;
let path: string;
let savedKeychain: string | undefined;
let savedFetch: typeof fetch;
let cache: typeof import("./all-models-cache.js");
let catalog: typeof import("./catalog-client.js");
let resolver: typeof import("./connection-resolver.js");
beforeEach(async () => {
  // All disk access uses the explicit cache path; HOME is not an isolation seam.
  home = mkdtempSync(join(tmpdir(), "claudish-g3-"));
  path = join(home, "models.json");
  savedKeychain = process.env.CLAUDISH_DISABLE_KEYCHAIN;
  process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
  savedFetch = globalThis.fetch;
  globalThis.fetch = Object.assign(
    async () => {
      throw new Error("G3 forbids network");
    },
    { preconnect: () => {} }
  ) as typeof fetch;
  cache = await import("./all-models-cache.js");
  catalog = await import("./catalog-client.js");
  resolver = await import("./connection-resolver.js");
  cache._clearAllModelsCacheMemo();
  catalog._resetCatalogClient();
});
afterEach(() => {
  cache?._clearAllModelsCacheMemo();
  catalog?._setCatalogEntriesForTest(null);
  catalog?._resetCatalogClient();
  globalThis.fetch = savedFetch;
  if (savedKeychain === undefined) delete process.env.CLAUDISH_DISABLE_KEYCHAIN;
  else process.env.CLAUDISH_DISABLE_KEYCHAIN = savedKeychain;
  rmSync(home, { recursive: true, force: true });
});
function install(aggregators: AggregatorEntry[]) {
  const routeRegistry: CachedRouteRegistry = {
    generationId: generation,
    registry: {
      registryVersion: "3.7.0",
      routes: {
        meta: {
          profiles: {
            "direct-api": {
              kind: "direct",
              nativeModelProviders: ["meta"],
              apis: {
                responses: { baseUrl: "https://api.meta.ai/v1" },
                "chat-completions": { baseUrl: "https://api.meta.ai/v1" },
              },
            },
          },
        },
        openrouter: {
          profiles: {
            gateway: {
              kind: "gateway",
              apis: {
                responses: { baseUrl: "https://openrouter.ai/api/v1" },
              },
            },
          },
        },
      },
    },
  };
  const entries = [
    { contractVersion: 3 as const, modelId: id, provider: "meta", aliases: [], aggregators },
  ];
  const data: DiskCacheV3 = {
    version: 3,
    lastUpdated: new Date().toISOString(),
    catalogGenerationId: generation,
    entries,
    models: [{ id }],
    plans: [],
    routeRegistry,
  };
  cache.writeAllModelsCache(data, path);
  catalog._setCatalogEntriesForTest(entries);
}

test.each([id, `${id}-contributor`])(
  "G3: explicit %s uses its exact connection and request URL",
  (requested) => {
    install([connection(`${id}-contributor`, contributorWire), connection(id, plainWire)]);
    const result = resolver.resolveConnection("meta", requested, path);
    expect(result.ok).toBe(true);
    if (!result.ok) throw new Error(result.reason);
    expect(result.connection.externalModelId).toBe(requested);
    expect(result.connection.wire).toEqual(requested === id ? plainWire : contributorWire);
    expect(result.connection.generationId).toBe(generation);
    expect(
      resolver.connectionRequestUrl(
        result.connection,
        requested === id ? "responses" : "chat-completions"
      )
    ).toBe(`https://api.meta.ai/v1/${requested === id ? "responses" : "chat/completions"}`);
  }
);

test("G3: implicit selection and borrowed owner wire exclude contributor-first connection", () => {
  const gateway = connection(id, plainWire, "openrouter", "gateway");
  gateway.wire = { status: "unknown", evidence: [] };
  install([connection(`${id}-contributor`, contributorWire), connection(id, plainWire), gateway]);
  const result = resolver.resolveConnection("openrouter", id, path);
  expect(result.ok).toBe(true);
  if (!result.ok) throw new Error(result.reason);
  expect(result.connection.externalModelId).toBe(id);
  expect(result.connection.ownerWire).toEqual(plainWire);
  expect(result.connection.ownerWire).not.toEqual(contributorWire);
});

test("G3: opt-in-only Meta connection is unavailable for an implicit plain request", () => {
  install([connection(`${id}-contributor`, contributorWire)]);
  expect(resolver.resolveConnection("meta", id, path)).toEqual({
    ok: false,
    reason: "no-connection",
  });
});