@mycadet/assistant 0.12.10 → 0.12.11

package/node_modules/@mycadet/ces-client/node_modules/@mycadet/service-contracts/src/__tests__/ingress.test.ts

@@ -10,7 +10,7 @@ import {
   trimmedNonEmptyString,
   TUNNEL_PROVIDERS,
   type TunnelRecord,
-  tunnelHostForPlatformHost,
+  tunnelHostForCloudHost,
 } from "../ingress.js";
 import {
   buildTwilioMediaStreamUrl,
@@ -19,27 +19,27 @@ import {
   resolveTwilioPublicBaseUrl,
 } from "../twilio-ingress.js";
 
-describe("tunnelHostForPlatformHost", () => {
+describe("tunnelHostForCloudHost", () => {
   test("maps the prod platform host to the prod tunnel", () => {
-    expect(tunnelHostForPlatformHost("cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("cloud.mycadet.ai")).toBe(
       "tunnel.mycadet.ai",
     );
   });
 
   test("maps env-prefixed platform hosts to their env tunnel", () => {
-    expect(tunnelHostForPlatformHost("staging-cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("staging-cloud.mycadet.ai")).toBe(
       "tunnel-staging.mycadet.ai",
     );
-    expect(tunnelHostForPlatformHost("dev-cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("dev-cloud.mycadet.ai")).toBe(
       "tunnel-dev.mycadet.ai",
     );
   });
 
   test("returns null for hosts outside the deployment convention", () => {
-    expect(tunnelHostForPlatformHost("localhost")).toBeNull();
-    expect(tunnelHostForPlatformHost("platform.example.com")).toBeNull();
+    expect(tunnelHostForCloudHost("localhost")).toBeNull();
+    expect(tunnelHostForCloudHost("platform.example.com")).toBeNull();
     expect(
-      tunnelHostForPlatformHost("staging-cloud.mycadet.ai.evil.com"),
+      tunnelHostForCloudHost("staging-cloud.mycadet.ai.evil.com"),
     ).toBeNull();
   });
 });

package/node_modules/@mycadet/ces-client/node_modules/@mycadet/service-contracts/src/ingress.ts

@@ -6,7 +6,7 @@
  * gateway speech relay and the web live-voice client so the two ends of the
  * cloud-speech transport can't drift.
  */
-export function tunnelHostForPlatformHost(host: string): string | null {
+export function tunnelHostForCloudHost(host: string): string | null {
   if (host === "cloud.mycadet.ai") {
     return "tunnel.mycadet.ai";
   }

package/node_modules/@mycadet/ces-client/src/http-credentials.ts

@@ -143,6 +143,19 @@ export interface CesHttpCredentialClient {
 // Factory
 // ---------------------------------------------------------------------------
 
+function listErrorContext(
+  response: Response,
+  path: string,
+): Record<string, unknown> {
+  const requestId = response.headers.get("x-ces-error-id");
+  return {
+    status: response.status,
+    method: "GET",
+    path,
+    ...(requestId && /^[a-f0-9-]{36}$/i.test(requestId) ? { requestId } : {}),
+  };
+}
+
 export function createCesHttpCredentialClient(
   config: CesHttpCredentialConfig,
   logger: CesHttpLogger,
@@ -298,7 +311,7 @@ export function createCesHttpCredentialClient(
         if (!res) return { accounts: [], unreachable: true };
         if (!res.ok) {
           logger.warn(
-            { status: res.status },
+            listErrorContext(res, "/v1/credentials"),
             "CES credential list returned non-OK status",
           );
           return { accounts: [], unreachable: true };
@@ -399,6 +412,10 @@ export function createCesHttpCredentialClient(
           return { records: [], unreachable: true };
         }
         if (!res.ok) {
+          logger.warn(
+            listErrorContext(res, "/v1/metadata"),
+            "CES metadata list returned non-OK status",
+          );
           return { records: [], unreachable: true };
         }
         const data = (await res.json()) as {

package/node_modules/@mycadet/gateway-client/node_modules/@mycadet/service-contracts/src/__tests__/ingress.test.ts

@@ -10,7 +10,7 @@ import {
   trimmedNonEmptyString,
   TUNNEL_PROVIDERS,
   type TunnelRecord,
-  tunnelHostForPlatformHost,
+  tunnelHostForCloudHost,
 } from "../ingress.js";
 import {
   buildTwilioMediaStreamUrl,
@@ -19,27 +19,27 @@ import {
   resolveTwilioPublicBaseUrl,
 } from "../twilio-ingress.js";
 
-describe("tunnelHostForPlatformHost", () => {
+describe("tunnelHostForCloudHost", () => {
   test("maps the prod platform host to the prod tunnel", () => {
-    expect(tunnelHostForPlatformHost("cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("cloud.mycadet.ai")).toBe(
       "tunnel.mycadet.ai",
     );
   });
 
   test("maps env-prefixed platform hosts to their env tunnel", () => {
-    expect(tunnelHostForPlatformHost("staging-cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("staging-cloud.mycadet.ai")).toBe(
       "tunnel-staging.mycadet.ai",
     );
-    expect(tunnelHostForPlatformHost("dev-cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("dev-cloud.mycadet.ai")).toBe(
       "tunnel-dev.mycadet.ai",
     );
   });
 
   test("returns null for hosts outside the deployment convention", () => {
-    expect(tunnelHostForPlatformHost("localhost")).toBeNull();
-    expect(tunnelHostForPlatformHost("platform.example.com")).toBeNull();
+    expect(tunnelHostForCloudHost("localhost")).toBeNull();
+    expect(tunnelHostForCloudHost("platform.example.com")).toBeNull();
     expect(
-      tunnelHostForPlatformHost("staging-cloud.mycadet.ai.evil.com"),
+      tunnelHostForCloudHost("staging-cloud.mycadet.ai.evil.com"),
     ).toBeNull();
   });
 });

package/node_modules/@mycadet/gateway-client/node_modules/@mycadet/service-contracts/src/ingress.ts

@@ -6,7 +6,7 @@
  * gateway speech relay and the web live-voice client so the two ends of the
  * cloud-speech transport can't drift.
  */
-export function tunnelHostForPlatformHost(host: string): string | null {
+export function tunnelHostForCloudHost(host: string): string | null {
   if (host === "cloud.mycadet.ai") {
     return "tunnel.mycadet.ai";
   }

package/node_modules/@mycadet/service-contracts/src/__tests__/ingress.test.ts

@@ -10,7 +10,7 @@ import {
   trimmedNonEmptyString,
   TUNNEL_PROVIDERS,
   type TunnelRecord,
-  tunnelHostForPlatformHost,
+  tunnelHostForCloudHost,
 } from "../ingress.js";
 import {
   buildTwilioMediaStreamUrl,
@@ -19,27 +19,27 @@ import {
   resolveTwilioPublicBaseUrl,
 } from "../twilio-ingress.js";
 
-describe("tunnelHostForPlatformHost", () => {
+describe("tunnelHostForCloudHost", () => {
   test("maps the prod platform host to the prod tunnel", () => {
-    expect(tunnelHostForPlatformHost("cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("cloud.mycadet.ai")).toBe(
       "tunnel.mycadet.ai",
     );
   });
 
   test("maps env-prefixed platform hosts to their env tunnel", () => {
-    expect(tunnelHostForPlatformHost("staging-cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("staging-cloud.mycadet.ai")).toBe(
       "tunnel-staging.mycadet.ai",
     );
-    expect(tunnelHostForPlatformHost("dev-cloud.mycadet.ai")).toBe(
+    expect(tunnelHostForCloudHost("dev-cloud.mycadet.ai")).toBe(
       "tunnel-dev.mycadet.ai",
     );
   });
 
   test("returns null for hosts outside the deployment convention", () => {
-    expect(tunnelHostForPlatformHost("localhost")).toBeNull();
-    expect(tunnelHostForPlatformHost("platform.example.com")).toBeNull();
+    expect(tunnelHostForCloudHost("localhost")).toBeNull();
+    expect(tunnelHostForCloudHost("platform.example.com")).toBeNull();
     expect(
-      tunnelHostForPlatformHost("staging-cloud.mycadet.ai.evil.com"),
+      tunnelHostForCloudHost("staging-cloud.mycadet.ai.evil.com"),
     ).toBeNull();
   });
 });

package/node_modules/@mycadet/service-contracts/src/ingress.ts

@@ -6,7 +6,7 @@
  * gateway speech relay and the web live-voice client so the two ends of the
  * cloud-speech transport can't drift.
  */
-export function tunnelHostForPlatformHost(host: string): string | null {
+export function tunnelHostForCloudHost(host: string): string | null {
   if (host === "cloud.mycadet.ai") {
     return "tunnel.mycadet.ai";
   }

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Cadet Assistant API
-  version: 0.12.10
+  version: 0.12.11
   description: Auto-generated OpenAPI specification for the Cadet Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycadet/assistant",
-  "version": "0.12.10",
+  "version": "0.12.11",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/cloud-profile-guard.test.ts

@@ -138,6 +138,42 @@ function savedProfile(name: string): Record<string, unknown> {
   >;
 }
 
+describe("partial default-provider config", () => {
+  for (const provider of ["cadet", "chatgpt"]) {
+    test(`timezone PATCH accepts a model-less ${provider} default`, async () => {
+      seedRawConfig({ llm: { default: { provider } } });
+      await patchRoute.handler({
+        body: { ui: { userTimezone: "America/New_York" } },
+      });
+      const saved = committedRaw() as {
+        ui: { userTimezone: string };
+        llm: { default: { provider: string; model?: string } };
+      };
+      expect(saved.ui.userTimezone).toBe("America/New_York");
+      expect(saved.llm.default).toEqual({ provider });
+      expectOneCommitCycle();
+    });
+    test(`PATCH can select ${provider} as default without a model`, async () => {
+      seedRawConfig({});
+      await patchRoute.handler({ body: { llm: { default: { provider } } } });
+      expect(
+        (committedRaw() as { llm: { default: { provider: string } } }).llm
+          .default,
+      ).toEqual({ provider });
+    });
+  }
+  test("Zod rejects a default model with the wrong type", async () => {
+    await expect(
+      patchRoute.handler({
+        body: {
+          llm: { default: { provider: "cadet", model: 42 } },
+        },
+      }),
+    ).rejects.toThrow(/model|expected string/i);
+    expectNothingCommitted();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // PUT /v1/config/llm/profiles/:name — replace inference profile
 // ---------------------------------------------------------------------------
@@ -210,13 +246,13 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
     ).toBeUndefined();
   });
 
-  test("rejects a routing identity with an unroutable model at the write choke point", async () => {
+  test("Zod rejects invalid fields in a replacement profile", async () => {
     await expect(
       replaceRoute.handler({
         pathParams: { name: "my-custom" },
-        body: { provider: "cadet", model: "not-a-real-model" },
+        body: { provider: "cadet", model: "claude-opus-4-8", maxTokens: 0 },
       }),
-    ).rejects.toThrow(/not served by the Cadet Cloud route/);
+    ).rejects.toThrow(/expected number to be >0/);
     expect(committedRaw()).toBeNull();
   });
 

package/src/config/schemas/llm.ts

@@ -54,9 +54,8 @@ const ALWAYS_RESOLVING_MANAGED_ONLY_PROFILE_KEYS =
  * an open string so a stored provider outside this list parses instead of
  * stripping its profile; dispatch resolves such a label as a connection
  * entry name and fails with an explainable resolution error when no row
- * carries it. Write-time membership is enforced at the profiles route and
- * the `commitConfigWrite` choke point (`unknownLlmProviderIssue`), which
- * is where entry names unlock when the entries model enables them.
+ * carries it. The generic config routes follow this open-string schema;
+ * dedicated profile routes apply their own provider selection rules.
  */
 export const KNOWN_LLM_PROVIDERS = [
   "anthropic",
@@ -153,8 +152,7 @@ export function isByokDefaultProviderChoice(
  * on that profile/call site deterministically — a call-site fragment naming
  * an identity without a model would inherit whatever model the winning
  * profile carries, which the identity may not serve. Enforced at parse time
- * (LLMSchema.superRefine), at the config write choke point
- * (commitConfigWrite), and by the profile write route.
+ * (LLMSchema.superRefine) and by the profile creation route.
  */
 export function routingIdentityModelIssue(
   provider: string,

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -1625,7 +1625,7 @@ describe("config GET serves profiles verbatim", () => {
   });
 });
 
-describe("provider membership at the write choke point", () => {
+describe("provider labels follow the open-string Zod schema", () => {
   const configPatchRoute = ROUTES.find(
     (r) => r.operationId === "config_patch",
   )!;
@@ -1659,21 +1659,23 @@ describe("provider membership at the write choke point", () => {
     expect(llm.profiles?.work?.provider).toBe("anthropic-work");
   });
 
-  test("introducing an unknown provider is rejected", async () => {
+  test("a new provider label is accepted by the schema", async () => {
     rawConfigFixture = { llm: {} };
     seedRawConfig();
-
-    await expect(
-      configPatchRoute.handler({
-        body: {
-          llm: {
-            profiles: {
-              rogue: { source: "user", provider: "not-a-provider", model: "m" },
+    await configPatchRoute.handler({
+      body: {
+        llm: {
+          profiles: {
+            work: {
+              source: "user",
+              provider: "anthropic-work",
+              model: "claude-opus-4-8",
             },
           },
         },
-      }),
-    ).rejects.toThrow(/Invalid provider/);
+      },
+    });
+    expect(persistedProfile("work").provider).toBe("anthropic-work");
   });
 });
 

package/src/runtime/routes/conversation-query-routes.ts

@@ -53,8 +53,6 @@ import {
   LLMDefaultConfigSchema,
   LLMSchema,
   ProfileEntry,
-  routingIdentityModelIssue,
-  unknownLlmProviderIssue,
 } from "../../config/schemas/llm.js";
 import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
 import { ServiceModeSchema } from "../../config/schemas/services.js";
@@ -106,7 +104,6 @@ import { getMemoryRecallLogByMessageIds } from "../../plugins/defaults/memory/me
 import { getMemoryV2ActivationLogByMessageIds } from "../../plugins/defaults/memory/v2/activation-log-store.js";
 import { getMemoryV3SelectionForInspectorByMessageIds } from "../../plugins/defaults/memory/v3/selection-log-store.js";
 import { CLOUD_ROUTABLE_PROVIDERS } from "../../providers/cadet-model-routing.js";
-import { writableProfileProviderIssue } from "../../providers/connection-resolution.js";
 import { ROUTING_IDENTITY_PROVIDERS } from "../../providers/inference/auth.js";
 import { PROVIDERS_REQUIRING_BASE_URL_AND_MODELS } from "../../providers/inference/auth.js";
 import {
@@ -684,98 +681,6 @@ function handleGetConfigSchema({ queryParams = {} }: RouteHandlerArgs) {
   };
 }
 
-/**
- * Reject writes that would store a routing-identity provider with a missing
- * or unroutable model (see `routingIdentityModelIssue`). saveRawConfig
- * persists without schema validation, so the parse-time rejection alone
- * would let the pair reach disk and be stripped on the next read — a silent
- * no-op where the user expects a saved override.
- */
-function collectProviderEntries(
-  raw: Record<string, unknown>,
-): [string, { provider?: unknown; model?: unknown }][] {
-  const llm = raw.llm as
-    | {
-        default?: { provider?: unknown; model?: unknown } | null;
-        profiles?: Record<
-          string,
-          { provider?: unknown; model?: unknown } | null | undefined
-        >;
-        callSites?: Record<
-          string,
-          { provider?: unknown; model?: unknown } | null | undefined
-        >;
-      }
-    | undefined;
-  const entries: [string, { provider?: unknown; model?: unknown }][] = [];
-  // llm.default is a raw compatibility field outside the parsed schema;
-  // profile materialization uses the on-disk blob as its fill base, so it is
-  // checked like the schema-carried sections.
-  if (llm?.default) {
-    entries.push(["llm.default", llm.default]);
-  }
-  for (const section of ["profiles", "callSites"] as const) {
-    for (const [name, entry] of Object.entries(llm?.[section] ?? {})) {
-      if (entry) {
-        entries.push([`llm.${section}.${name}`, entry]);
-      }
-    }
-  }
-  return entries;
-}
-
-function assertRoutableIdentityEntries(
-  preWrite: Record<string, unknown>,
-  raw: Record<string, unknown>,
-): void {
-  const entries = collectProviderEntries(raw);
-  const priorProviders = new Map(
-    collectProviderEntries(preWrite).flatMap(([label, entry]) =>
-      typeof entry.provider === "string" ? [[label, entry.provider]] : [],
-    ),
-  );
-  for (const [label, entry] of entries) {
-    if (typeof entry.provider !== "string") {
-      continue;
-    }
-    // The provider schema is an open string (a stored value outside the
-    // known set parses instead of stripping its profile), so write-time
-    // membership is enforced here and at the profiles route. Scoped to
-    // providers this write introduces or changes: a stored value outside
-    // the known set is readable and dispatchable by design, and
-    // re-validating it on every write would make all later settings saves
-    // fail with no in-product repair path. Profiles accept entry names;
-    // call-site fragments and the legacy default blob stay vendor-only
-    // (overrides become model-only with the entries demolition).
-    if (entry.provider !== priorProviders.get(label)) {
-      const providerIssue = label.startsWith("llm.profiles.")
-        ? writableProfileProviderIssue(entry.provider)
-        : unknownLlmProviderIssue(entry.provider);
-      if (providerIssue) {
-        throw new BadRequestError(`${providerIssue} (${label})`);
-      }
-    }
-    // A model-less entry under a code-defined default name is the thin
-    // managed stub — its content is code-owned, so the routing-identity
-    // model check applies only to entries carrying their own body.
-    const profileName = label.startsWith("llm.profiles.")
-      ? label.slice("llm.profiles.".length)
-      : undefined;
-    const isManagedName =
-      profileName != null && MANAGED_PROFILE_NAMES.has(profileName);
-    if (entry.model == null && isManagedName) {
-      continue;
-    }
-    const issue = routingIdentityModelIssue(
-      entry.provider,
-      typeof entry.model === "string" ? entry.model : undefined,
-    );
-    if (issue) {
-      throw new BadRequestError(`${issue} (${label})`);
-    }
-  }
-}
-
 export async function commitConfigWrite(
   raw: Record<string, unknown>,
   opLabel: string,
@@ -792,7 +697,6 @@ export async function commitConfigWrite(
   if (!chatSettings.success) {
     throw new BadRequestError(chatSettings.error.message);
   }
-  assertRoutableIdentityEntries(preWrite, raw);
 
   // Suppress the file-watcher callback for the duration of the debounce
   // window. Without this, the ConfigWatcher detects the config.json write