@vellumai/assistant 0.8.5 → 0.8.6

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

@@ -1,9 +1,11 @@
 /**
  * When IS_PLATFORM=true and no config.json exists yet, loadConfig() must
- * write all eight managed-capable service modes as "managed" instead of the
- * schema default "your-own". When IS_PLATFORM is absent/false, or when
- * config.json already exists, the schema defaults and existing values are
- * preserved unchanged.
+ * write all managed-capable service modes as "managed" instead of the
+ * per-service schema default. When IS_PLATFORM is absent/false, or when
+ * config.json already exists, the Zod schema defaults and existing values
+ * are preserved unchanged — note that `google-oauth` and `notion-oauth`
+ * default to "managed" at the schema level (per JARVIS-966), while every
+ * other managed-capable service defaults to "your-own".
  */
 
 import {
@@ -59,7 +61,7 @@ afterAll(() => {
 
 import { invalidateConfigCache, loadConfig } from "../config/loader.js";
 import { applyContextDefaultsToRawConfig } from "../runtime/routes/conversation-query-routes.js";
-import { _setStorePath } from "../security/encrypted-store.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -91,6 +93,9 @@ function readConfig(): Record<string, unknown> {
   return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
 }
 
+// When IS_PLATFORM=true, every managed-capable service defaults to "managed".
+// Without IS_PLATFORM, services split by Zod schema default: google/notion-oauth
+// resolve to "managed" (per JARVIS-966), the rest resolve to "your-own".
 const MANAGED_SERVICES = [
   "image-generation",
   "web-search",
@@ -101,6 +106,28 @@ const MANAGED_SERVICES = [
   "notion-oauth",
 ] as const;
 
+/**
+ * Services whose Zod schema default is `"managed"` rather than `"your-own"`.
+ * For these, the fresh-write and in-memory paths produce `"managed"` even
+ * when IS_PLATFORM is false/unset — the schema default applies regardless of
+ * deployment context. See `assistant/src/config/schemas/services.ts` and
+ * JARVIS-966: managed mode is the optimization target for new users on
+ * managed-capable infra, since the BYO flow requires a Google Cloud /
+ * Notion integration setup that most users never complete.
+ */
+const SCHEMA_MANAGED_DEFAULT_SERVICES = [
+  "google-oauth",
+  "notion-oauth",
+] as const;
+
+const SCHEMA_YOUR_OWN_DEFAULT_SERVICES = [
+  "image-generation",
+  "web-search",
+  "outlook-oauth",
+  "linear-oauth",
+  "github-oauth",
+] as const;
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -110,12 +137,12 @@ describe("platform-managed config defaults", () => {
 
   beforeEach(() => {
     resetWorkspace();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     invalidateConfigCache();
     // Restore env to its original value
     if (originalIsPlatform === undefined) {
@@ -137,9 +164,12 @@ describe("platform-managed config defaults", () => {
     for (const svc of MANAGED_SERVICES) {
       expect((services[svc] as { mode?: string })?.mode).toBe("managed");
     }
+    expect((services["web-search"] as { provider?: string })?.provider).toBe(
+      "inference-provider-native",
+    );
   });
 
-  test("IS_PLATFORM=false, no config file → managed service modes default to 'your-own'", () => {
+  test("IS_PLATFORM=false, no config file → service modes follow schema defaults (your-own except google/notion-oauth which are managed)", () => {
     process.env.IS_PLATFORM = "false";
 
     loadConfig();
@@ -148,12 +178,15 @@ describe("platform-managed config defaults", () => {
     const written = readConfig() as { services?: Record<string, unknown> };
     expect(written.services).toBeDefined();
     const services = written.services!;
-    for (const svc of MANAGED_SERVICES) {
+    for (const svc of SCHEMA_YOUR_OWN_DEFAULT_SERVICES) {
       expect((services[svc] as { mode?: string })?.mode).toBe("your-own");
     }
+    for (const svc of SCHEMA_MANAGED_DEFAULT_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("managed");
+    }
   });
 
-  test("IS_PLATFORM unset, no config file → managed service modes default to 'your-own'", () => {
+  test("IS_PLATFORM unset, no config file → service modes follow schema defaults (your-own except google/notion-oauth which are managed)", () => {
     delete process.env.IS_PLATFORM;
 
     loadConfig();
@@ -162,9 +195,12 @@ describe("platform-managed config defaults", () => {
     const written = readConfig() as { services?: Record<string, unknown> };
     expect(written.services).toBeDefined();
     const services = written.services!;
-    for (const svc of MANAGED_SERVICES) {
+    for (const svc of SCHEMA_YOUR_OWN_DEFAULT_SERVICES) {
       expect((services[svc] as { mode?: string })?.mode).toBe("your-own");
     }
+    for (const svc of SCHEMA_MANAGED_DEFAULT_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("managed");
+    }
   });
 
   test("IS_PLATFORM=true, config file already exists → existing service mode values are preserved", () => {
@@ -197,6 +233,37 @@ describe("platform-managed config defaults", () => {
     expect(config.services["image-generation"].mode).toBe("your-own");
   });
 
+  test("IS_PLATFORM=true, config file with explicit notion-oauth mode='your-own' → preserved (schema default is 'managed')", () => {
+    process.env.IS_PLATFORM = "true";
+
+    // notion-oauth's schema default is "managed" (per JARVIS-966), but an
+    // explicit user choice of "your-own" must win — the fill-defaults pass
+    // must never override an explicit value, even one that contradicts the
+    // schema default. Mirror of the image-generation "your-own preserved"
+    // test above, but for a service whose schema default is "managed".
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          services: {
+            "notion-oauth": { mode: "your-own" },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const config = loadConfig();
+
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    expect((written.services!["notion-oauth"] as { mode?: string })?.mode).toBe(
+      "your-own",
+    );
+    expect(config.services["notion-oauth"].mode).toBe("your-own");
+  });
+
   test("IS_PLATFORM=true, config file exists without a services key → in-memory config has all managed modes", () => {
     // Regression guard for the platform-managed boot order: by the time
     // `loadConfig()` runs, lifecycle steps such as `seedInferenceProfiles`
@@ -228,12 +295,8 @@ describe("platform-managed config defaults", () => {
     // missing service-mode fields.
     for (const svc of MANAGED_SERVICES) {
       expect(
-        (
-          config.services as unknown as Record<
-            string,
-            { mode: string }
-          >
-        )[svc]!.mode,
+        (config.services as unknown as Record<string, { mode: string }>)[svc]!
+          .mode,
       ).toBe("managed");
     }
 
@@ -277,9 +340,11 @@ describe("platform-managed config defaults", () => {
     expect(imageGen.provider).toBe("openai");
   });
 
-  test("IS_PLATFORM=false, config file exists without services key → in-memory config keeps schema your-own defaults", () => {
+  test("IS_PLATFORM=false, config file exists without services key → in-memory config keeps schema defaults (your-own except google/notion-oauth which are managed)", () => {
     // Sanity guard: deployment-context defaults are a no-op when IS_PLATFORM
-    // is not enabled, regardless of whether config.json existed.
+    // is not enabled, regardless of whether config.json existed. The Zod
+    // schema defaults still apply, so google-oauth and notion-oauth resolve
+    // to "managed" while the remaining services resolve to "your-own".
     process.env.IS_PLATFORM = "false";
 
     writeFileSync(
@@ -300,16 +365,18 @@ describe("platform-managed config defaults", () => {
 
     const config = loadConfig();
 
-    for (const svc of MANAGED_SERVICES) {
+    for (const svc of SCHEMA_YOUR_OWN_DEFAULT_SERVICES) {
       expect(
-        (
-          config.services as unknown as Record<
-            string,
-            { mode: string }
-          >
-        )[svc]!.mode,
+        (config.services as unknown as Record<string, { mode: string }>)[svc]!
+          .mode,
       ).toBe("your-own");
     }
+    for (const svc of SCHEMA_MANAGED_DEFAULT_SERVICES) {
+      expect(
+        (config.services as unknown as Record<string, { mode: string }>)[svc]!
+          .mode,
+      ).toBe("managed");
+    }
   });
 });
 

package/src/__tests__/config-loader-quarantine-bulletin.test.ts

@@ -28,7 +28,7 @@ import {
   invalidateConfigCache,
   loadConfig,
 } from "../config/loader.js";
-import { _setStorePath } from "../security/encrypted-store.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -71,12 +71,12 @@ function listQuarantinedFiles(): string[] {
 describe("config-quarantine UPDATES.md bulletin", () => {
   beforeEach(() => {
     resetWorkspace();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     invalidateConfigCache();
   });
 

package/src/__tests__/config-managed-gemini-defaults.test.ts

@@ -68,7 +68,6 @@ mock.module("../config/assistant-feature-flags.js", () => ({
     if (key === "managed-gemini-embeddings-enabled") return featureFlagEnabled;
     return true;
   },
-  _setOverridesForTesting: () => {},
   clearFeatureFlagOverridesCache: () => {},
   initFeatureFlagOverrides: async () => {},
   getAssistantFeatureFlagDefaults: () => ({}),
@@ -81,7 +80,7 @@ afterAll(() => {
 });
 
 import { invalidateConfigCache, loadConfig } from "../config/loader.js";
-import { _setStorePath } from "../security/encrypted-store.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -117,7 +116,7 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       }
     }
     ensureTestDir();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
 
     // Reset mock state
@@ -127,7 +126,7 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     invalidateConfigCache();
 
     // Restore IS_PLATFORM

package/src/__tests__/config-schema.test.ts

@@ -64,9 +64,9 @@ import {
   VALID_TTS_PROVIDERS as VALID_TTS_SERVICE_PROVIDERS,
 } from "../config/schemas/tts.js";
 import type { AssistantConfig } from "../config/types.js";
-import { _setStorePath } from "../security/encrypted-store.js";
 import { listCatalogProviderIds } from "../tts/provider-catalog.js";
 import { resolveTtsConfig } from "../tts/tts-config-resolver.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -87,7 +87,7 @@ describe("AssistantConfigSchema", () => {
     // llm.default.{provider,model}, auth routing via provider_connections.
     expect(result.services.inference).toEqual({});
     expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-opus-4-7");
+    expect(result.llm.default.model).toBe("claude-opus-4-8");
     expect(result.services["image-generation"].provider).toBe("gemini");
     expect(result.services["image-generation"].model).toBe(
       "gemini-3.1-flash-image-preview",
@@ -179,7 +179,7 @@ describe("AssistantConfigSchema", () => {
     expect(result.llm).toBeDefined();
     expect(result.llm.default).toEqual({
       provider: "anthropic",
-      model: "claude-opus-4-7",
+      model: "claude-opus-4-8",
       maxTokens: 64000,
       effort: "max",
       speed: "standard",
@@ -318,7 +318,7 @@ describe("AssistantConfigSchema", () => {
       (result.services.inference as Record<string, unknown>).model,
     ).toBeUndefined();
     expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-opus-4-7");
+    expect(result.llm.default.model).toBe("claude-opus-4-8");
   });
 
   test("partial llm config (empty `llm: {}`) doesn't trigger full config reset", () => {
@@ -333,7 +333,7 @@ describe("AssistantConfigSchema", () => {
     });
     expect(result.llm.default.maxTokens).toBe(32000);
     expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-opus-4-7");
+    expect(result.llm.default.model).toBe("claude-opus-4-8");
   });
 
   test("llm.default with one missing field still parses (defaults applied)", () => {
@@ -2068,12 +2068,12 @@ describe("loadConfig with schema validation", () => {
       }
     }
     ensureTestDir();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     invalidateConfigCache();
   });
 
@@ -2096,7 +2096,7 @@ describe("loadConfig with schema validation", () => {
     writeConfig({});
     const config = loadConfig();
     expect(config.llm.default.provider).toBe("anthropic");
-    expect(config.llm.default.model).toBe("claude-opus-4-7");
+    expect(config.llm.default.model).toBe("claude-opus-4-8");
     expect(config.llm.default.maxTokens).toBe(64000);
     expect(config.llm.default.thinking).toEqual({
       enabled: true,
@@ -2350,12 +2350,12 @@ describe("Call entrypoint gating", () => {
       }
     }
     ensureTestDir();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     invalidateConfigCache();
   });
 

package/src/__tests__/connection-model-compat.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  describeSubscriptionModelIncompatibility,
+  isConnectionCompatibleWithModel,
+} from "../providers/connection-model-compat.js";
+
+describe("isConnectionCompatibleWithModel", () => {
+  test("non-oauth_subscription connections are always compatible", () => {
+    expect(
+      isConnectionCompatibleWithModel(
+        { auth: { type: "api_key" } as never },
+        "o3",
+      ),
+    ).toBe(true);
+  });
+
+  test("oauth_subscription is compatible with Codex models", () => {
+    expect(
+      isConnectionCompatibleWithModel(
+        { auth: { type: "oauth_subscription" } as never },
+        "gpt-5.4",
+      ),
+    ).toBe(true);
+  });
+
+  test("oauth_subscription is incompatible with non-Codex models", () => {
+    expect(
+      isConnectionCompatibleWithModel(
+        { auth: { type: "oauth_subscription" } as never },
+        "o3",
+      ),
+    ).toBe(false);
+  });
+
+  test("undefined model is always compatible", () => {
+    expect(
+      isConnectionCompatibleWithModel(
+        { auth: { type: "oauth_subscription" } as never },
+        undefined,
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("describeSubscriptionModelIncompatibility", () => {
+  const subscriptionConn = { auth: { type: "oauth_subscription" as const } as never };
+  const apiKeyConn = { auth: { type: "api_key" as const } as never };
+
+  test("returns message when all candidates are oauth_subscription and model is incompatible", () => {
+    const msg = describeSubscriptionModelIncompatibility(
+      [subscriptionConn],
+      "o3",
+    );
+    expect(msg).toContain("o3");
+    expect(msg).toContain("ChatGPT subscription");
+  });
+
+  test("returns null when no candidates", () => {
+    expect(describeSubscriptionModelIncompatibility([], "o3")).toBeNull();
+  });
+
+  test("returns null when model is undefined", () => {
+    expect(
+      describeSubscriptionModelIncompatibility([subscriptionConn], undefined),
+    ).toBeNull();
+  });
+
+  test("returns null when some candidates are compatible", () => {
+    expect(
+      describeSubscriptionModelIncompatibility(
+        [subscriptionConn, apiKeyConn],
+        "o3",
+      ),
+    ).toBeNull();
+  });
+
+  test("returns null when model is Codex-compatible", () => {
+    expect(
+      describeSubscriptionModelIncompatibility([subscriptionConn], "gpt-5.4"),
+    ).toBeNull();
+  });
+});

package/src/__tests__/contacts-tools.test.ts

@@ -65,11 +65,12 @@ import { executeContactMerge } from "../config/bundled-skills/contacts/tools/con
 import { executeContactSearch } from "../config/bundled-skills/contacts/tools/contact-search.js";
 import { upsertContact } from "../contacts/contact-store.js";
 import type { ContactWithChannels } from "../contacts/types.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { ROUTES } from "../runtime/routes/contact-routes.js";
 import { RouteError } from "../runtime/routes/errors.js";
 import type { ToolContext } from "../tools/types.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -127,7 +128,7 @@ beforeAll(() => {
 
 afterAll(() => {
   testServer?.stop(true);
-  resetDb();
+  resetDbForTesting();
 });
 
 function getRawDb(): Database {

package/src/__tests__/context-token-estimator.test.ts

@@ -367,6 +367,28 @@ describe("token estimator", () => {
     expect(tokens).toBeLessThan(4_200);
   });
 
+  test("Gemini preserves aspect ratio when resizing to the 3072px cap", () => {
+    // Gemini rescales BOTH dimensions by a single factor so the longest side
+    // becomes 3072px. A 10000x1000 image → 3072x307, i.e. ceil(3072/768)=4
+    // tiles wide * ceil(307/768)=1 tile high = 4 tiles (~1,032 tokens).
+    // Clamping each side independently would yield 4*2=8 tiles, over-counting
+    // by 2x and risking spurious compaction.
+    const tokens = estimateContentBlockTokens(
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/png",
+          data: makePngBase64(10000, 1000),
+        },
+      },
+      { providerName: "gemini" },
+    );
+    // 4 tiles * 258 = 1,032 image tokens + 16 block overhead + 3 media type.
+    expect(tokens).toBeGreaterThanOrEqual(1_032);
+    expect(tokens).toBeLessThan(1_100);
+  });
+
   test("Gemini images ≤384px on both sides count as a single 258-token tile", () => {
     const tokens = estimateContentBlockTokens(
       {

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -138,6 +138,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -192,6 +194,9 @@ mock.module("../agent/loop.js", () => ({
       onEvent: (event: AgentEvent) => void,
       _signal?: AbortSignal,
     ): Promise<Message[]> {
+      // Prime the assistant row anchor — production code emits this from
+      // `AgentLoop.run` just before `provider.sendMessage`.
+      await onEvent({ type: "llm_call_started" });
       const history = [...messages];
 
       // Simulate provider response with 2 tool_use blocks

package/src/__tests__/conversation-agent-loop-disk-pressure.test.ts

@@ -100,6 +100,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   setConversationHistoryStrippedAt: () => {},
   updateConversationContextWindow: () => {},
   updateConversationSlackContextWatermark: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";

package/src/__tests__/conversation-agent-loop-handlers-max-tokens.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test";
+
+import type { AgentEvent } from "../agent/loop.js";
+import {
+  createEventHandlerState,
+  type EventHandlerDeps,
+  handleMaxTokensReached,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+describe("max tokens reached handler", () => {
+  test("emits and stores an inline continuation card", () => {
+    const sent: ServerMessage[] = [];
+    const ctx = {
+      conversationId: "conv-1",
+      surfaceState: new Map(),
+      currentTurnSurfaces: [],
+    };
+    const deps = {
+      ctx,
+      onEvent: (msg: ServerMessage) => sent.push(msg),
+      reqId: "req-1",
+      isFirstMessage: false,
+      shouldGenerateTitle: false,
+      rlog: { warn: () => {} },
+      turnChannelContext: {
+        userMessageChannel: "vellum",
+        assistantMessageChannel: "vellum",
+      },
+      turnInterfaceContext: {
+        userMessageInterface: "web",
+        assistantMessageInterface: "web",
+      },
+    } as unknown as EventHandlerDeps;
+
+    handleMaxTokensReached(createEventHandlerState(), deps, {
+      type: "max_tokens_reached",
+      stopReason: "max_tokens",
+    } as Extract<AgentEvent, { type: "max_tokens_reached" }>);
+
+    const show = sent.find((msg) => msg.type === "ui_surface_show");
+    expect(show).toBeDefined();
+    if (!show || show.type !== "ui_surface_show") return;
+
+    expect(show.surfaceType).toBe("card");
+    expect((show.data as { title?: unknown }).title).toBe(
+      "Response limit reached",
+    );
+    expect(show.actions?.[0]?.id).toBe("relay_prompt");
+    expect(show.actions?.[0]?.data?.prompt).toContain("Continue");
+    expect(show.actions?.[0]?.data?._completeSurface).toBe(true);
+    expect(ctx.currentTurnSurfaces).toHaveLength(1);
+    expect(ctx.surfaceState.has(show.surfaceId)).toBe(true);
+  });
+});

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -170,6 +170,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
   setLastNotifiedInferenceProfile: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({