Claude Code. Any Model. The most powerful AI coding agent now speaks every language.
fix(muse): pin the muse@ base URL before the registry base check
Jack Rudenkobe348bb6f1cd
diff --git a/ai-docs/architecture/providers/meta-muse-code.md b/ai-docs/architecture/providers/meta-muse-code.mdindex 3d0f7a60..671fdd93 100644--- a/ai-docs/architecture/providers/meta-muse-code.md+++ b/ai-docs/architecture/providers/meta-muse-code.md@@ -238,7 +238,8 @@ module runs (measured on Bun 1.4.0), so any repository the user runs claudish invariables and receive the login, which may be the one copied from the Muse Code CLI's Keychainitem. No environment-based switch can be trusted, so there is none. The catalog wire handler alsopins the base URL to `${MUSE_CODE_BASE_URL}/v1`, ignoring both the registry's base URL and a user-base-URL override for `meta-muse-code`. Tests use the mint's injected `fetch` seam.+base-URL override for `meta-muse-code`, even when the registry omits the Responses base URL.+An ignored user base URL is logged with the pinned host. Tests use the mint's injected `fetch` seam.## The mint is the entitlement evidencediff --git a/packages/cli/src/providers/wire-handler.muse-pin.test.ts b/packages/cli/src/providers/wire-handler.muse-pin.test.tsnew file mode 100644index 00000000..58ed68a3--- /dev/null+++ b/packages/cli/src/providers/wire-handler.muse-pin.test.ts@@ -0,0 +1,155 @@+import { afterEach, beforeEach, expect, spyOn, test } from "bun:test";+import { mkdtempSync, rmSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { Hono } from "hono";+import { credentials } from "../auth/credentials/authority.js";+import * as logger from "../logger.js";+import museCatalog from "../test-fixtures/catalog-v3/muse-code-g-20261021063612126-17350b71.json";+import {+ type DiskCacheV3,+ _clearAllModelsCacheMemo,+ writeAllModelsCache,+} from "./all-models-cache.js";+import { _resetCatalogClient } from "./catalog-client.js";+import {+ type ResolvedConnection,+ connectionBaseUrl,+ resolveConnection,+} from "./connection-resolver.js";+import "./model-discovery-builtins.js";+import * as discovery from "./model-discovery.js";+import { getProviderByName, toRemoteProvider } from "./provider-definitions.js";+import type { ProfileContext } from "./provider-profiles.js";+import { resolveRemoteProvider } from "./remote-provider-registry.js";+import { buildKnownWireHandler } from "./wire-handler.js";++// MTL-189 follow-up: B — log ignored overrides and pin absent URLs (generation g-20261021063612126-17350b71).+const originalFetch = globalThis.fetch;+const originalCredential = credentials.get("meta-muse-code");+const originalFetcher = discovery.getModelDiscoveryFetcher("muse-code-models");+let dir: string;+let ctx: ProfileContext;+let connection: ResolvedConnection;+let logSpy: ReturnType<typeof spyOn<typeof logger, "log">>;++beforeEach(() => {+ dir = mkdtempSync(join(tmpdir(), "muse-wire-pin-"));+ const cachePath = join(dir, "catalog.json");+ _resetCatalogClient();+ _clearAllModelsCacheMemo();+ writeAllModelsCache(structuredClone(museCatalog) as DiskCacheV3, cachePath);+ const resolved = resolveConnection("meta-muse-code", "muse-wonder-full-1.0", cachePath);+ if (!resolved.ok) throw new Error(`Muse connection missing: ${resolved.reason}`);+ connection = resolved.connection;+ ctx = {+ provider: toRemoteProvider(getProviderByName("meta-muse-code")!),+ modelName: connection.externalModelId,+ targetModel: `muse@${connection.externalModelId}`,+ apiKey: "",+ port: 0,+ catalogCachePath: cachePath,+ sharedOpts: {},+ };+ credentials.register({+ catalogName: "meta-muse-code",+ isAvailable: async () => true,+ getRequestAuth: async () => ({+ headers: { Authorization: "Bearer TEST_MUSE_TOKEN" },+ arm: "oauth",+ }),+ });+ discovery.invalidateModelDiscovery("meta-muse-code");+ discovery.registerModelDiscoveryFetcher("muse-code-models", async () => ({+ kind: "models",+ models: [{ id: connection.externalModelId, contextWindow: 1007997, reported: "chat" }],+ }));+ globalThis.fetch = Object.assign(+ async () => {+ throw new Error("Unexpected network in Muse pin test");+ },+ { preconnect: () => {} }+ ) as typeof fetch;+ logSpy = spyOn(logger, "log").mockImplementation(() => {});+});++afterEach(() => {+ logSpy.mockRestore();+ globalThis.fetch = originalFetch;+ if (originalCredential) credentials.register(originalCredential);+ credentials.invalidate("meta-muse-code");+ if (originalFetcher) discovery.registerModelDiscoveryFetcher("muse-code-models", originalFetcher);+ discovery.invalidateModelDiscovery("meta-muse-code");+ _resetCatalogClient();+ _clearAllModelsCacheMemo();+ rmSync(dir, { recursive: true, force: true });+});++test("logs that the user base URL was ignored for meta-muse-code", async () => {+ ctx.provider = { ...ctx.provider, baseUrl: "https://override.invalid/v1" };+ if (connection.wire.status !== "known") throw new Error("Expected known Muse wire");+ const handler = buildKnownWireHandler(ctx, "meta-muse-code", connection, connection.wire);+ try {+ expect(handler).not.toBeNull();+ expect(logSpy.mock.calls.map(([line]) => line)).toContainEqual(+ expect.stringMatching(/(?=.*meta-muse-code)(?=.*base[ -]?url)(?=.*ignor)/i)+ );+ } finally {+ await handler?.shutdown();+ }+});++test("does not log an ignored user base URL when Muse uses its definition default", async () => {+ const resolved = resolveRemoteProvider("[email protected]");+ if (!resolved) throw new Error("Expected resolved Muse provider");+ ctx = { ...ctx, provider: resolved.provider, modelName: resolved.modelName };+ expect(ctx.provider.baseUrl).toBe(getProviderByName("meta-muse-code")!.baseUrl);+ if (connection.wire.status !== "known") throw new Error("Expected known Muse wire");+ const handler = buildKnownWireHandler(ctx, "meta-muse-code", connection, connection.wire);+ try {+ expect(handler).not.toBeNull();+ expect(logSpy.mock.calls.map(([line]) => line)).not.toContainEqual(+ expect.stringMatching(/(?=.*meta-muse-code)(?=.*base[ -]?url)(?=.*ignor)/i)+ );+ } finally {+ await handler?.shutdown();+ }+});++test("builds a pinned Responses handler when the registry publishes no base URL", async () => {+ const withoutBase = structuredClone(connection);+ const responses: { baseUrl?: string } = withoutBase.profile.apis.responses!;+ delete responses.baseUrl;+ expect(connectionBaseUrl(withoutBase, "responses")).toBeUndefined();+ if (withoutBase.wire.status !== "known") throw new Error("Expected known Muse wire");+ const urls: string[] = [];+ globalThis.fetch = Object.assign(+ async (input: string | URL | Request) => {+ urls.push(input instanceof Request ? input.url : String(input));+ return new Response("data: [DONE]\n\n", {+ headers: { "content-type": "text/event-stream" },+ });+ },+ { preconnect: () => {} }+ ) as typeof fetch;+ const handler = buildKnownWireHandler(ctx, "meta-muse-code", withoutBase, withoutBase.wire);+ try {+ expect(handler).not.toBeNull();+ if (!handler) return;+ const app = new Hono();+ app.post("/", (c) =>+ handler.handle(c, {+ model: ctx.targetModel,+ max_tokens: 64,+ stream: true,+ messages: [{ role: "user", content: "PONG" }],+ })+ );+ const response = await app.request("http://localhost/", { method: "POST" });+ await response.text();+ expect(response.status).toBe(200);+ expect(urls).toEqual(["https://api.meta.ai/v1/responses"]);+ } finally {+ await handler?.shutdown();+ }+});diff --git a/packages/cli/src/providers/wire-handler.ts b/packages/cli/src/providers/wire-handler.tsindex 6ca095c7..14ff5683 100644--- a/packages/cli/src/providers/wire-handler.ts+++ b/packages/cli/src/providers/wire-handler.ts@@ -374,14 +374,21 @@ export function buildKnownWireHandler(connection: ResolvedConnection,wire: KnownWire): ModelHandler | null {- const registryBase = connectionBaseUrl(connection, wire.api);+ const registryBase = requestBaseUrl(connection, wire.api);if (!registryBase) return null;const definition = getProviderByName(definitionName);// Muse keys stay on Meta, regardless of registry or user base URLs.const { baseUrl, overridden } =definitionName === "meta-muse-code"- ? { baseUrl: `${MUSE_CODE_BASE_URL}/v1`, overridden: false }+ ? { baseUrl: registryBase, overridden: false }: effectiveBaseUrl(registryBase, definition?.baseUrl, ctx.provider.baseUrl);+ if (+ definitionName === "meta-muse-code" &&+ ctx.provider.baseUrl &&+ ctx.provider.baseUrl !== definition?.baseUrl+ ) {+ log(`[Wire] meta-muse-code: user base URL ignored → ${baseUrl}`);+ }const url = wireRequestUrl(baseUrl, wire.api, connection.externalModelId);if (overridden) log(`[Wire] ${definitionName}: base URL overridden by user config → ${baseUrl}`);