@mycadet/assistant 0.12.7-dev.202610111049.d2b52a8 → 0.12.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycadet/assistant",
-  "version": "0.12.7-dev.202610111049.d2b52a8",
+  "version": "0.12.8",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/config-loader-cloud-defaults.test.ts

@@ -39,7 +39,6 @@ afterAll(() => {
 });
 
 import { invalidateConfigCache, loadConfig } from "../config/loader.js";
-import { applyContextDefaultsToRawConfig } from "../runtime/routes/conversation-query-routes.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -372,235 +371,3 @@ describe("cloud-managed config defaults", () => {
     }
   });
 });
-
-/**
- * Regression guard for the `handleGetConfig` route handler in
- * `assistant/src/runtime/routes/conversation-query-routes.ts`. That handler
- * returns the raw on-disk JSON to clients (macOS, web, CLI) via
- * `GET /v1/config`, but first layers deployment-context defaults on top
- * via the `applyContextDefaultsToRawConfig` helper.
- *
- * macOS's `loadServiceModes(config:)` only updates `inferenceMode` when
- * `services.inference.mode` is present in the response — without the fill
- * pass, freshly-hatched cloud assistants would have no `services`
- * key on disk (only `llm.profiles` from `seedInferenceProfiles`) and macOS
- * would fall back to its `@Published` default of "your-own". The helper is
- * also responsible for guarding against `loadRawConfig()` returning a
- * non-object payload from a malformed-but-parseable `config.json`.
- */
-describe("GET /v1/config handler — context-default fill on raw response", () => {
-  const originalIsPlatform = process.env.IS_CLOUD;
-
-  afterEach(() => {
-    if (originalIsPlatform === undefined) {
-      delete process.env.IS_CLOUD;
-    } else {
-      process.env.IS_CLOUD = originalIsPlatform;
-    }
-  });
-
-  test("IS_CLOUD=true, raw config has no services key → response includes managed defaults", () => {
-    process.env.IS_CLOUD = "true";
-
-    // Mirrors the real-world fresh-hatch state: lifecycle wrote
-    // `llm.profiles` to disk, but never persisted any service modes.
-    const raw: Record<string, unknown> = {
-      llm: {
-        profiles: {
-          balanced: { provider: "anthropic", model: "claude-sonnet-4.5" },
-        },
-        activeProfile: "balanced",
-      },
-    };
-
-    const result = applyContextDefaultsToRawConfig(raw) as Record<
-      string,
-      unknown
-    >;
-    const services = result["services"] as Record<
-      string,
-      { mode?: string; provider?: string }
-    >;
-    expect(services).toBeDefined();
-    for (const svc of MANAGED_SERVICES) {
-      expect(services[svc]!.mode).toBe("managed");
-    }
-    // image-generation is filled by provider, not mode.
-    expect(services["image-generation"]!.provider).toBe("cadet");
-    expect(services["image-generation"]!.mode).toBeUndefined();
-  });
-
-  test("IS_CLOUD=true, raw config has explicit services.image-generation.mode='your-own' → preserved", () => {
-    process.env.IS_CLOUD = "true";
-
-    // A legacy raw shape: mode with no provider leaf. Migration 134 rewrites
-    // it (pinning provider gemini) before any real request reaches this
-    // function, so the fill's only obligation here is to be non-destructive:
-    // existing keys pass through untouched, absent leaves get the cloud
-    // default.
-    const raw: Record<string, unknown> = {
-      services: {
-        "image-generation": { mode: "your-own" },
-      },
-    };
-
-    const result = applyContextDefaultsToRawConfig(raw) as Record<
-      string,
-      unknown
-    >;
-    const services = result["services"] as Record<
-      string,
-      { mode?: string; provider?: string }
-    >;
-    expect(services["image-generation"]!.mode).toBe("your-own");
-    expect(services["image-generation"]!.provider).toBe("cadet");
-    // web-search is not context-filled: a filled `mode` would override BYOK
-    // configs on every load.
-    expect(services["web-search"]).toBeUndefined();
-    // inference.mode is a legacy backwards-compat wire field — synthesized
-    // here for old macOS clients (SettingsStore.swift) that still read it.
-    expect(services["inference"]!.mode).toBe("managed");
-  });
-
-  test("IS_CLOUD=false, raw config has no services key → response is unchanged", () => {
-    process.env.IS_CLOUD = "false";
-
-    const raw: Record<string, unknown> = {
-      llm: {
-        profiles: {
-          balanced: { provider: "anthropic", model: "claude-sonnet-4.5" },
-        },
-      },
-    };
-
-    const result = applyContextDefaultsToRawConfig(raw) as Record<
-      string,
-      unknown
-    >;
-    expect(result["services"]).toBeUndefined();
-  });
-
-  test("IS_CLOUD=true, raw config has an explicit image-generation provider → preserved, no mode injected", () => {
-    process.env.IS_CLOUD = "true";
-
-    // User set image-generation.provider explicitly. The fill targets that
-    // same leaf (`provider: "cadet"`), so the explicit value wins and no
-    // mode is injected.
-    const raw: Record<string, unknown> = {
-      services: {
-        "image-generation": { provider: "openai" },
-      },
-    };
-
-    const result = applyContextDefaultsToRawConfig(raw) as Record<
-      string,
-      unknown
-    >;
-    const services = result["services"] as Record<
-      string,
-      { mode?: string; provider?: string }
-    >;
-    expect(services["image-generation"]!.provider).toBe("openai");
-    expect(services["image-generation"]!.mode).toBeUndefined();
-    // services.inference.mode is synthesized as a legacy wire-only field for
-    // older macOS clients during the rollout window (Phase 1.2 schema removal
-    // landed before the macOS Providers UI ships).
-    expect(services["inference"]!.mode).toBe("managed");
-  });
-
-  test("IS_CLOUD=true, raw config has no inference subtree → synthesizes legacy mode='managed'", () => {
-    process.env.IS_CLOUD = "true";
-
-    const raw: Record<string, unknown> = {
-      llm: {
-        profiles: {
-          balanced: { provider: "anthropic", model: "claude-sonnet-4.5" },
-        },
-      },
-    };
-
-    const result = applyContextDefaultsToRawConfig(raw) as Record<
-      string,
-      unknown
-    >;
-    const services = result["services"] as Record<string, { mode: string }>;
-    expect(services["inference"]!.mode).toBe("managed");
-  });
-
-  test("IS_CLOUD=true, raw config has explicit services.inference.mode='your-own' → preserved (legacy override)", () => {
-    process.env.IS_CLOUD = "true";
-
-    // Pre-migration upgrade: workspace config still carries the legacy
-    // mode value. The synthesis only fills when absent, so an explicit
-    // disk value wins until migration 076 strips it.
-    const raw: Record<string, unknown> = {
-      services: {
-        inference: { mode: "your-own" },
-      },
-    };
-
-    const result = applyContextDefaultsToRawConfig(raw) as Record<
-      string,
-      unknown
-    >;
-    const services = result["services"] as Record<string, { mode: string }>;
-    expect(services["inference"]!.mode).toBe("your-own");
-  });
-
-  test("IS_CLOUD=false, raw config has no inference subtree → no synthesis", () => {
-    process.env.IS_CLOUD = "false";
-
-    const raw: Record<string, unknown> = {
-      llm: {},
-    };
-
-    const result = applyContextDefaultsToRawConfig(raw) as Record<
-      string,
-      unknown
-    >;
-    expect(result["services"]).toBeUndefined();
-  });
-
-  // -------------------------------------------------------------------------
-  // Malformed-but-parseable config.json — must not 500 the GET endpoint.
-  //
-  // `loadRawConfig()` is typed `Record<string, unknown>` but `JSON.parse`
-  // will happily return `null`, primitives, or arrays for a syntactically
-  // valid file like `null` / `42` / `[]`. The helper must return those
-  // payloads unchanged rather than throwing inside
-  // `fillContextDefaultsForMissingKeys`.
-  // -------------------------------------------------------------------------
-
-  test("IS_CLOUD=true, raw config is null → returned unchanged (no throw)", () => {
-    process.env.IS_CLOUD = "true";
-    expect(applyContextDefaultsToRawConfig(null)).toBe(null);
-  });
-
-  test("IS_CLOUD=true, raw config is a primitive number → returned unchanged (no throw)", () => {
-    process.env.IS_CLOUD = "true";
-    expect(applyContextDefaultsToRawConfig(42)).toBe(42);
-  });
-
-  test("IS_CLOUD=true, raw config is an array → returned unchanged (no throw)", () => {
-    process.env.IS_CLOUD = "true";
-    const raw: unknown[] = [{ foo: "bar" }];
-    const result = applyContextDefaultsToRawConfig(raw);
-    expect(result).toBe(raw);
-    // No `services` key was synthesized onto the array.
-    expect((result as { services?: unknown }).services).toBeUndefined();
-  });
-
-  test("IS_CLOUD=true, raw config is a string → returned unchanged (no throw)", () => {
-    process.env.IS_CLOUD = "true";
-    expect(applyContextDefaultsToRawConfig("not-an-object")).toBe(
-      "not-an-object",
-    );
-  });
-
-  test("IS_CLOUD=false, raw config is null → returned unchanged (no throw)", () => {
-    // Sanity check: when there are no context defaults to apply, the helper
-    // also short-circuits cleanly on non-object payloads.
-    process.env.IS_CLOUD = "false";
-    expect(applyContextDefaultsToRawConfig(null)).toBe(null);
-  });
-});

package/src/__tests__/credential-health-service.test.ts

@@ -773,7 +773,6 @@ describe("credential-health-service", () => {
 
   describe("cloud assistant credential", () => {
     const KEY = "credential/cadet/assistant_api_key";
-    const ASSISTANT_ID = "credential/cadet/platform_assistant_id";
 
     // Checked directly rather than through `checkAllCredentials`: the cloud
     // credential is not enrolled in the heartbeat pass yet, because the alert
@@ -785,16 +784,7 @@ describe("credential-health-service", () => {
       expect(await assistantKeyResult()).toBeNull();
     });
 
-    test("is missing_token when a cloud identity exists without a key", async () => {
-      secureKeyValues.set(ASSISTANT_ID, "11111111-2222-4333-8444-555555555555");
-
-      const result = await assistantKeyResult();
-      expect(result!.status).toBe("missing_token");
-      expect(result!.canAutoRecover).toBe(true);
-    });
-
     test("is healthy when the cloud accepts the stored key", async () => {
-      secureKeyValues.set(ASSISTANT_ID, "11111111-2222-4333-8444-555555555555");
       secureKeyValues.set(KEY, "stored-key");
       assistantKeyVerdict = "valid";
 
@@ -802,7 +792,6 @@ describe("credential-health-service", () => {
     });
 
     test("is revoked when the cloud rejects the stored key", async () => {
-      secureKeyValues.set(ASSISTANT_ID, "11111111-2222-4333-8444-555555555555");
       secureKeyValues.set(KEY, "stored-key");
       assistantKeyVerdict = "rejected";
 
@@ -818,7 +807,6 @@ describe("credential-health-service", () => {
     // error, transport failure) must degrade to `unreachable`, which the
     // heartbeat drops before notifying.
     test("an unsettled platform answer is unreachable, never revoked", async () => {
-      secureKeyValues.set(ASSISTANT_ID, "11111111-2222-4333-8444-555555555555");
       secureKeyValues.set(KEY, "stored-key");
       assistantKeyVerdict = "unknown";
 
@@ -826,14 +814,12 @@ describe("credential-health-service", () => {
     });
 
     test("an unreadable credential store is unreachable, never revoked", async () => {
-      secureKeyValues.set(ASSISTANT_ID, "11111111-2222-4333-8444-555555555555");
       markUnreachable(KEY);
 
       expect((await assistantKeyResult())!.status).toBe("unreachable");
     });
 
     test("is unreachable when the cloud client cannot be built", async () => {
-      secureKeyValues.set(ASSISTANT_ID, "11111111-2222-4333-8444-555555555555");
       secureKeyValues.set(KEY, "stored-key");
       cloudClientAvailable = false;
 

package/src/__tests__/credential-routes.test.ts

@@ -18,7 +18,6 @@ let syncRejects: boolean;
 let disconnectedProviders: string[];
 let credentialIdCounter: number;
 let scrubbedValues: string[];
-let scrubRejects: boolean;
 let liveRecordsUnreachable: boolean;
 
 function metaKey(service: string, field: string): string {
@@ -120,9 +119,6 @@ mock.module("../credential-execution/cloud-catalog.js", () => ({
 mock.module("../daemon/credential-transcript-scrub.js", () => ({
   scrubStoredCredentialFromTranscripts: mock(async (value: string) => {
     scrubbedValues.push(value);
-    if (scrubRejects) {
-      throw new Error("transcript sweep failed");
-    }
     return { dbMessagesScrubbed: 0, residentMessagesScrubbed: 0 };
   }),
 }));
@@ -195,7 +191,6 @@ describe("credentials routes", () => {
     disconnectedProviders = [];
     credentialIdCounter = 0;
     scrubbedValues = [];
-    scrubRejects = false;
     liveRecordsUnreachable = false;
     _resetRevealSuccessRegistryForTest();
     resetForChatMintRegistryForTest();
@@ -618,52 +613,6 @@ describe("credentials routes", () => {
       expect(scrubbedValues).toEqual([SECRET_VALUE]);
     });
 
-    test("non-secret cadet cloud fields are stored but never scrubbed", async () => {
-      /**
-       * Platform identity ids are benign UUIDs that legitimately appear in
-       * transcripts; scrubbing them would redact ordinary conversation
-       * content. Shares the exemption with the /v1/secrets credential branch
-       * via isNonSecretPlatformField.
-      for (const field of [
-        "platform_assistant_id",
-        "platform_organization_id",
-        "platform_user_id",
-      ]) {
-        const result = (await setRoute!.handler({
-          body: {
-            service: "cadet",
-            field,
-            value: "0198f4c2-1111-2222-3333-444455556666",
-          },
-        })) as SetResponse;
-        expect(result.service).toBe("cadet");
-      }
-
-      expect(scrubbedValues).toEqual([]);
-    });
-
-    test("the set still succeeds when the transcript scrub rejects", async () => {
-      /**
-       * The scrub is post-store hygiene: the credential IS stored, so a
-       * scrub failure is logged and must stay invisible to the caller.
-       */
-      // GIVEN a scrub that rejects
-      scrubRejects = true;
-
-      // WHEN a credential is stored
-      const result = (await setRoute!.handler({
-        body: { service: "vercel", field: "api_token", value: SECRET_VALUE },
-      })) as SetResponse;
-
-      // THEN the route still returns success and the secret is persisted
-      expect(result.service).toBe("vercel");
-      expect(result.credentialId).toBe("cred-1");
-      expect(secureStore.get(seedKey("vercel", "api_token"))).toBe(
-        SECRET_VALUE,
-      );
-      expect(scrubbedValues).toEqual([SECRET_VALUE]);
-    });
-
     test("leaves a non-ACP service unaffected by the OAuth-field guard", async () => {
       /**
        * The guard is scoped to the ACP service; the same field name on another

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -2,8 +2,8 @@
  * Tests for initFeatureFlagOverrides() — the async IPC call that
  * pre-populates the feature flag cache before CLI program construction.
  *
- * Uses the shared mock-gateway-ipc utility (installed in test-preload.ts)
- * which mocks node:net so no test connects to a real gateway socket.
+ * Uses the requests-mock gateway channel (transport installed in
+ * test-preload.ts) so no test connects to a real gateway socket.
  */
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 
@@ -13,21 +13,23 @@ import {
   isAssistantFeatureFlagEnabled,
   refreshOverridesFromGateway,
 } from "../config/assistant-feature-flags.js";
-import { mockGatewayIpc, resetMockGatewayIpc } from "./mock-gateway-ipc.js";
+import { mockIpc, resetRequestMockChannels } from "./requests-mock.js";
 
 beforeEach(() => {
   clearFeatureFlagOverridesCache();
-  resetMockGatewayIpc();
 });
 
 afterEach(() => {
   clearFeatureFlagOverridesCache();
-  resetMockGatewayIpc();
 });
 
 describe("initFeatureFlagOverrides", () => {
   it("populates cache from gateway IPC response", async () => {
-    mockGatewayIpc({ "foo-enabled": true, "bar-enabled": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {
+      "foo-enabled": true,
+      "bar-enabled": true,
+    });
 
     await initFeatureFlagOverrides();
 
@@ -37,7 +39,8 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("falls back gracefully when gateway socket is unavailable", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     // Disable retries — production retries the IPC fetch on failure to
     // dodge the daemon-vs-gateway startup race, but here we're explicitly
@@ -51,7 +54,11 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("respects false values from gateway IPC", async () => {
-    mockGatewayIpc({ "gated-feature": true, "disabled-feature": false });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {
+      "gated-feature": true,
+      "disabled-feature": false,
+    });
 
     await initFeatureFlagOverrides();
 
@@ -63,7 +70,8 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("does not cache empty gateway response", async () => {
-    mockGatewayIpc({});
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {});
 
     // Disable retries — this test explicitly simulates a sustained empty
     // response (gateway up but reporting zero flags) and should not wait
@@ -80,10 +88,11 @@ describe("initFeatureFlagOverrides", () => {
     // returns empty (gateway not yet ready), but a later attempt sees
     // the populated flag map. The retry loop in init should bridge this
     // gap without losing the flag.
-    mockGatewayIpc({});
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {});
     setTimeout(() => {
-      resetMockGatewayIpc();
-      mockGatewayIpc({ "retry-test-flag": true });
+      resetRequestMockChannels();
+      gateway.on("get_feature_flags", { "retry-test-flag": true });
     }, 50);
 
     await initFeatureFlagOverrides({ retryBackoffsMs: [200] });
@@ -93,14 +102,18 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("does not re-fetch when cache is already populated", async () => {
-    mockGatewayIpc({ "first-call": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "first-call": true });
 
     await initFeatureFlagOverrides();
 
     // Change what IPC would return — if the guard is broken and init
     // re-fetches, "first-call" would flip to false.
-    resetMockGatewayIpc();
-    mockGatewayIpc({ "first-call": false, "second-call": true });
+    resetRequestMockChannels();
+    gateway.on("get_feature_flags", {
+      "first-call": false,
+      "second-call": true,
+    });
 
     await initFeatureFlagOverrides();
 
@@ -114,11 +127,12 @@ describe("initFeatureFlagOverrides", () => {
 
 describe("refreshOverridesFromGateway", () => {
   it("replaces the cache with the new gateway values", async () => {
-    mockGatewayIpc({ "moving-flag": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "moving-flag": true });
     await initFeatureFlagOverrides();
 
-    resetMockGatewayIpc();
-    mockGatewayIpc({ "moving-flag": false });
+    resetRequestMockChannels();
+    gateway.on("get_feature_flags", { "moving-flag": false });
 
     expect(await refreshOverridesFromGateway()).toBe(true);
 
@@ -127,11 +141,12 @@ describe("refreshOverridesFromGateway", () => {
   });
 
   it("keeps the last known values when the refresh fails", async () => {
-    mockGatewayIpc({ "moving-flag": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "moving-flag": true });
     await initFeatureFlagOverrides();
 
-    resetMockGatewayIpc();
-    mockGatewayIpc(null, { error: true });
+    resetRequestMockChannels();
+    gateway.failConnect();
 
     expect(await refreshOverridesFromGateway()).toBe(false);
 
@@ -143,11 +158,12 @@ describe("refreshOverridesFromGateway", () => {
   });
 
   it("keeps the cache readable for the whole call", async () => {
-    mockGatewayIpc({ "moving-flag": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "moving-flag": true });
     await initFeatureFlagOverrides();
 
-    resetMockGatewayIpc();
-    mockGatewayIpc({ "moving-flag": false });
+    resetRequestMockChannels();
+    gateway.on("get_feature_flags", { "moving-flag": false });
 
     const config = {} as any;
     const inFlight = refreshOverridesFromGateway();

package/src/__tests__/llm-request-log-source-clickhouse.test.ts

@@ -302,7 +302,7 @@ describe("ClickHouseLlmRequestLogSource", () => {
     );
   });
 
-  test("missing cadet:platform_assistant_id surfaces a clear error", async () => {
+  test("a missing Cadet Cloud assistant id surfaces a clear error", async () => {
     const src = new ClickHouseLlmRequestLogSource(DEFAULT_CONFIG, {
       resolveUrl: async () => "https://ch.example.test",
       resolvePassword: async () => "x",
@@ -310,7 +310,7 @@ describe("ClickHouseLlmRequestLogSource", () => {
       fetchImpl: fakeFetchReturning(""),
     });
     await expect(src.getRequestLogById("log-1")).rejects.toThrow(
-      /cadet:platform_assistant_id credential is required/,
+      /Cadet Cloud assistant id is required/,
     );
   });
 });

package/src/__tests__/llm-schema-fallback-profile.test.ts

@@ -130,12 +130,18 @@ describe("LLMSchema fallbackProfile", () => {
       unrepresentable: "any",
       io: "input",
     });
+    // ProfileEntry carries a named meta id (#172), so zod v4 hoists it into
+    // top-level $defs and the profiles record references it by $ref — the
+    // fallbackProfile readOnly marker the docs surface lives in the $defs copy.
     expect(json).toMatchObject({
       properties: {
         profiles: {
-          additionalProperties: {
-            properties: { fallbackProfile: { readOnly: true } },
-          },
+          additionalProperties: { $ref: "#/$defs/ProfileEntry" },
+        },
+      },
+      $defs: {
+        ProfileEntry: {
+          properties: { fallbackProfile: { readOnly: true } },
         },
       },
     });