@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.9",
+  "version": "0.10.10-dev.202607162206.d08e98e",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/generate-openapi.ts

@@ -30,6 +30,14 @@ import type {
 } from "zod-openapi";
 import { createDocument } from "zod-openapi";
 
+import { jsonValueSchema } from "../src/telemetry/telemetry-wire.generated.js";
+
+// The recursive wire JSON-value schema (`claims`/`suggestions` item type) must
+// be hoisted into a named component so it can `$ref` itself; without a
+// registered id zod-openapi falls back to an anonymous `__schema0`. Name it
+// explicitly so the spec + generated SDK read as `TelemetryJsonValue`.
+z.globalRegistry.add(jsonValueSchema, { id: "TelemetryJsonValue" });
+
 const ROOT = resolve(import.meta.dir, "..");
 const ROUTES_DIR = join(ROOT, "src/runtime/routes");
 const PLUGIN_DEFAULTS_DIR = join(ROOT, "src/plugins/defaults");

package/src/__tests__/activation-early-marking.test.ts

@@ -25,9 +25,8 @@ const { isActivationSession } =
   await import("../plugins/defaults/memory/activation-session-store.js");
 const { ACTIVATION_RAIL_BOOTSTRAP_TEMPLATE } =
   await import("../telemetry/activation-funnel.js");
-const { getDb } = await import("../persistence/db-connection.js");
+const { getMemorySqlite } = await import("../persistence/db-connection.js");
 const { initializeDb } = await import("../persistence/db-init.js");
-const { activationSessions } = await import("../persistence/schema/index.js");
 
 await initializeDb();
 
@@ -44,7 +43,7 @@ function seedGenericBootstrap(): void {
 
 describe("applyBootstrapTemplate — early activation marking", () => {
   beforeEach(() => {
-    getDb().delete(activationSessions).run();
+    getMemorySqlite()!.exec("DELETE FROM activation_sessions");
   });
 
   test("marks the conversation when the activation-rail template is applied", () => {
@@ -71,8 +70,10 @@ describe("applyBootstrapTemplate — early activation marking", () => {
     applyBootstrapTemplate(ACTIVATION_RAIL_BOOTSTRAP_TEMPLATE);
 
     // Nothing to assert by id; confirm the table stayed empty.
-    const rows = getDb().select().from(activationSessions).all();
-    expect(rows.length).toBe(0);
+    const { n } = getMemorySqlite()!
+      .query("SELECT COUNT(*) AS n FROM activation_sessions")
+      .get() as { n: number };
+    expect(n).toBe(0);
   });
 
   test("does not mark when BOOTSTRAP.md is customized to something else", () => {

package/src/__tests__/agent-loop-override-profile.test.ts

@@ -13,20 +13,13 @@
  * field is omitted from `providerConfig` rather than carrying `undefined`.
  */
 
-import { beforeAll, describe, expect, mock, test } from "bun:test";
-
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
-import { setConfig } from "./helpers/set-config.js";
+import { describe, expect, mock, test } from "bun:test";
 
 // These suites exercise override-profile PLUMBING through legacy-shaped
 // fixtures (llm.default-centric, no defaultProvider). Pinned to the
 // flag-off cascade; override-or-default resolution semantics are pinned by
 // llm-resolver-override-or-default.test.ts and the inference-profile loop
 // suite.
-beforeAll(() => {
-  setOverridesForTesting({ "override-or-default-resolution": false });
-});
-
 import { AgentLoop } from "../agent/loop.js";
 import type {
   Message,
@@ -35,6 +28,7 @@ import type {
   SendMessageOptions,
   ToolDefinition,
 } from "../providers/types.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const userMessage: Message = {
   role: "user",
@@ -277,14 +271,20 @@ mock.module("../providers/registry.js", () => ({
   resolveProviderFromConnection: async () => anthropicStub,
 }));
 
+import { VELLUM_MANAGED_CONNECTION_NAME } from "../providers/vellum-model-routing.js";
+
 // Connection-aware resolver path: satisfy
 // `tryResolveProviderForConnectionName` lookups so resolveDefaultProvider
-// returns a usable provider for the inline `anthropic-conn` fixture.
+// returns a usable provider for any connection name the winning profile
+// references. The managed connection must carry the provider the catalog
+// `balanced` default declares (fireworks) or resolution rejects the row as a
+// provider mismatch; other names behave as personal anthropic connections.
 mock.module("../providers/inference/connections.js", () => ({
   getConnection: (_db: unknown, name: string) => ({
     id: 1,
     name,
-    provider: "anthropic",
+    provider:
+      name === VELLUM_MANAGED_CONNECTION_NAME ? "fireworks" : "anthropic",
     auth_strategy: "user_managed_credential",
     credential_alias: null,
     metadata_json: null,
@@ -295,21 +295,16 @@ mock.module("../providers/inference/connections.js", () => ({
 
 /**
  * Seed the workspace `llm` config block for real. `activeProfile` and
- * `callSites` vary per test; the rest is the shared legacy-shaped fixture.
+ * `callSites` vary per test.
  */
 function seedLlmConfig(options?: {
   activeProfile?: string;
   callSites?: Record<string, unknown>;
 }): void {
   setConfig("llm", {
-    default: {
-      provider: "anthropic",
-      model: "claude-opus-4-7",
-      provider_connection: "anthropic-conn",
-    },
     profiles: {
-      // Disable the catalog default so resolution lands on llm.default.
-      balanced: { source: "managed", status: "disabled" },
+      // Complete (provider + model) so the profile is a usable winner at
+      // every rung of the single-winner selection chain.
       fast: {
         source: "user",
         provider: "anthropic",
@@ -457,7 +452,7 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
     }
   });
 
-  test("omits overrideProfile when neither context nor row carries it", async () => {
+  test("forwards the invoker's resolved default profile when neither context nor row carries an override", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;
@@ -479,10 +474,11 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
       );
 
       expect(capturedConfig).toBeDefined();
-      // Field must be absent rather than carrying `undefined` so the
-      // SubagentConfig respects the same "field omitted when unset"
-      // contract the agent loop uses.
-      expect("overrideProfile" in capturedConfig!).toBe(false);
+      // With no explicit override anywhere, the invoker-default tier forwards
+      // the invoking call site's resolved default profile — here `mainAgent`
+      // with no active profile or pin, which resolves the catalog `balanced`
+      // default — so the subagent matches its invoker's model selection.
+      expect(capturedConfig!.overrideProfile).toBe("balanced");
     } finally {
       manager.spawn = originalSpawn;
     }
@@ -491,8 +487,9 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
   test("an explicit subagentSpawn call-site pin suppresses the invoker-default inheritance", async () => {
     // With an active profile the invoker-default tier resolves ("fast"), so
     // absent a pin it is forwarded as the inherited override; with an
-    // explicit llm.callSites.subagentSpawn profile the heuristic must yield
-    // so the pin can win under override-or-default resolution.
+    // explicit llm.callSites.subagentSpawn profile the heuristic must yield —
+    // a forwarded override would outrank the pin under single-winner
+    // resolution, overriding the user's explicit call-site choice.
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;

package/src/__tests__/agent-wake-override-profile.test.ts

@@ -26,26 +26,7 @@
  *      pinned-profile values.
  */
 
-import {
-  afterEach,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
-
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
-
-// These suites exercise override-profile PLUMBING through legacy-shaped
-// fixtures (llm.default-centric, no defaultProvider). Pinned to the
-// flag-off cascade; override-or-default resolution semantics are pinned by
-// llm-resolver-override-or-default.test.ts and the inference-profile loop
-// suite.
-beforeAll(() => {
-  setOverridesForTesting({ "override-or-default-resolution": false });
-});
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 let mockOverrideProfile: string | undefined = undefined;
 
@@ -140,14 +121,12 @@ describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
   test("forwards the conversation's pinned overrideProfile + mainAgent callSite to agentLoop.run", async () => {
     mockOverrideProfile = "frontier";
     setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-sonnet-4-6",
-        maxTokens: 64000,
-        contextWindow: { maxInputTokens: 200000 },
-      },
       profiles: {
+        // Complete (provider + model) so the pinned profile is a usable
+        // winner; its context window is what the wake must resolve.
         frontier: {
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
           contextWindow: { maxInputTokens: 150000 },
         },
       },
@@ -184,23 +163,24 @@ describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
   test("forceOverrideProfile replaces the pinned-profile lookup and forwards the force flag to agentLoop.run", async () => {
     // The conversation's own pinned profile must be ignored — the caller's
     // forced profile (e.g. a fork-based retrospective matching the source
-    // conversation) takes its place AND floats above the call-site layers
-    // via the resolver's `forceOverrideProfile` escape hatch.
+    // conversation) takes its place and, as the override rung of the
+    // single-winner chain, beats the call site's own pinned profile.
     mockOverrideProfile = "pinned-ignored";
     setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-sonnet-4-6",
-        maxTokens: 64000,
-        contextWindow: { maxInputTokens: 200000 },
-      },
       profiles: {
         forced: {
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
           contextWindow: { maxInputTokens: 120000 },
         },
+        "retrospective-pinned": {
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
+          contextWindow: { maxInputTokens: 180000 },
+        },
       },
       callSites: {
-        memoryRetrospective: { contextWindow: { maxInputTokens: 180000 } },
+        memoryRetrospective: { profile: "retrospective-pinned" },
       },
     });
     const { target, runArgs } = makeTarget();
@@ -221,8 +201,9 @@ describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
     expect(runArgs[0]!.options?.overrideProfile).toBe("forced");
     expect(runArgs[0]!.options?.forceOverrideProfile).toBe(true);
     expect(runArgs[0]!.options?.callSite).toBe("memoryRetrospective");
-    // The effective context window resolves under the FORCED profile, above
-    // the explicit call-site override (120k beats the call site's 180k).
+    // The effective context window resolves under the FORCED profile, which
+    // wins selection over the call site's own pinned profile (the forced
+    // profile's 120k beats the call-site profile's 180k).
     expect(runArgs[0]!.options?.resolveContextWindow?.().maxInputTokens).toBe(
       120000,
     );
@@ -231,13 +212,9 @@ describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
   test("without forceOverrideProfile the wake never sets the force flag", async () => {
     mockOverrideProfile = "frontier";
     setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-sonnet-4-6",
-        maxTokens: 64000,
-        contextWindow: { maxInputTokens: 200000 },
+      profiles: {
+        frontier: { provider: "anthropic", model: "claude-sonnet-4-6" },
       },
-      profiles: { frontier: {} },
       callSites: { mainAgent: {} },
     });
     const { target, runArgs } = makeTarget();
@@ -317,13 +294,9 @@ describe("wakeAgentForOpportunity — resolver actually engages", () => {
     // undefined (the original bug), the retry layer would skip the resolver
     // entirely and the downstream provider would see only the wire defaults.
     setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-sonnet-4-6",
-        maxTokens: 64000,
-      },
       profiles: {
         frontier: {
+          provider: "anthropic",
           model: "claude-opus-4-7",
           maxTokens: 32000,
         },

package/src/__tests__/app-builder-tool-scripts.test.ts

@@ -61,7 +61,6 @@ mock.module("../apps/app-store.js", () => ({
     dirName: id,
     appDir: `/tmp/test-apps/${id}`,
   }),
-  isMultifileApp: (app: AppDefinition) => app.formatVersion === 2,
 }));
 
 // Mock compileApp for multifile scaffold path

package/src/__tests__/app-bundler.test.ts

@@ -21,7 +21,6 @@ mock.module("../apps/app-store.js", () => ({
   getApp: (id: string) => mockApps.get(id) ?? null,
   getAppsDir: () => testAppsDir,
   getAppDirPath: (id: string) => join(testAppsDir, id),
-  isMultifileApp: (app: Record<string, unknown>) => app.formatVersion === 2,
 }));
 
 // Mock content-id to avoid pulling in crypto internals
@@ -323,19 +322,12 @@ render(<App />, document.getElementById('app')!);
     expect(zip.file("main.css")).toBeNull();
   });
 
-  test("keeps legacy single-file apps packageable", async () => {
+  test("rejects legacy single-file apps with a missing-src error", async () => {
     const appId = "legacy-single-file";
     setupLegacyApp(appId);
 
-    const result = await packageApp(appId);
-    const zipData = await readFile(result.bundlePath);
-    const zip = await JSZip.loadAsync(zipData);
-
-    const indexContent = await zip.file("index.html")!.async("string");
-    const manifestJson = await zip.file("manifest.json")!.async("string");
-    const manifest: AppManifest = JSON.parse(manifestJson);
-
-    expect(indexContent).toContain("<h1>Legacy</h1>");
-    expect(manifest.format_version).toBe(1);
+    await expect(packageApp(appId)).rejects.toThrow(
+      /missing src\/index\.html and src\/main\.tsx/,
+    );
   });
 });

package/src/__tests__/app-executors.test.ts

@@ -39,18 +39,6 @@ import {
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeLegacyApp(overrides?: Partial<AppDefinition>): AppDefinition {
-  return {
-    id: "legacy-app",
-    name: "Legacy App",
-    schemaJson: "{}",
-    htmlDefinition: "<html></html>",
-    createdAt: Date.now(),
-    updatedAt: Date.now(),
-    ...overrides,
-  };
-}
-
 function makeMultifileApp(overrides?: Partial<AppDefinition>): AppDefinition {
   return {
     id: "multi-app",
@@ -150,9 +138,7 @@ describe("executeAppCreate", () => {
     );
 
     expect(result.isError).toBe(false);
-    // formatVersion 2 passed to createApp
-    expect(createdParams?.formatVersion).toBe(2);
-    // htmlDefinition should be empty for multifile apps
+    // htmlDefinition should be empty — the real source lives under src/
     expect(createdParams?.htmlDefinition).toBe("");
     // Scaffold files should be written
     expect(files["src/index.html"]).toBeDefined();
@@ -455,20 +441,6 @@ describe("executeAppCreate", () => {
 // ---------------------------------------------------------------------------
 
 describe("executeAppRefresh", () => {
-  test("legacy app: bumps updatedAt without compiling", async () => {
-    const app = makeLegacyApp();
-    const store = mockStore(app);
-    const result = await executeAppRefresh({ app_id: app.id }, store);
-
-    expect(result.isError).toBe(false);
-    const parsed = JSON.parse(result.content);
-    expect(parsed.refreshed).toBe(true);
-    expect(parsed.appId).toBe(app.id);
-    // Legacy apps should not have compile-related fields
-    expect(parsed.compiled).toBeUndefined();
-    expect(parsed.compile_errors).toBeUndefined();
-  });
-
   test("multifile app: compiles src/ and returns result", async () => {
     const app = makeMultifileApp();
     const store = mockStore(app);
@@ -483,7 +455,7 @@ describe("executeAppRefresh", () => {
   });
 
   test("returns error for unknown app", async () => {
-    const app = makeLegacyApp();
+    const app = makeMultifileApp();
     const store = mockStore(app);
     const result = await executeAppRefresh({ app_id: "nonexistent" }, store);
 
@@ -541,25 +513,6 @@ describe("executeAppUpdate", () => {
     expect(JSON.parse(result.content).compiled).toBe(true);
   });
 
-  test("legacy app: updates without compiling", async () => {
-    const app = makeLegacyApp({ name: "Legacy" });
-    const store: AppStore = {
-      ...mockStore(app),
-      updateApp: (_id, updates) => ({ ...app, ...updates }),
-    };
-
-    const result = await executeAppUpdate(
-      { app_id: app.id, name: "Renamed" },
-      store,
-    );
-
-    expect(result.isError).toBe(false);
-    const parsed = JSON.parse(result.content);
-    expect(parsed.updated).toBe(true);
-    expect(parsed.name).toBe("Renamed");
-    expect(parsed.compiled).toBeUndefined();
-  });
-
   test("returns error for unknown app", async () => {
     const store = mockStore(makeMultifileApp());
     const result = await executeAppUpdate({ app_id: "nope" }, store);