@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/injector-pkb-v2-silenced.test.ts

@@ -0,0 +1,124 @@
+/**
+ * v2 read-side cutover behavior for the PKB-derived default injectors.
+ *
+ * When `isMemoryV2ReadActive(getConfig())` is true:
+ *   - `pkb-context` silences itself (concept pages own retrieval).
+ *   - `pkb-reminder` still fires (its body is generic recall/remember
+ *     guidance) but skips the PKB-search hints — those name PKB paths.
+ *   - `now-md` fires unchanged (workspace state, independent of PKB).
+ *
+ * Mocks `isMemoryV2ReadActive` at the module level so each test can flip the
+ * effective gate state without standing up a full feature-flag + config
+ * stack. Mocks the PKB hybrid search so the reminder-with-hints branch can
+ * resolve deterministically when called.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let v2Active = false;
+
+mock.module("../memory/context-search/sources/memory-v2.js", () => ({
+  isMemoryV2ReadActive: () => v2Active,
+}));
+
+mock.module("../memory/pkb/pkb-search.js", () => ({
+  searchPkbFiles: async () => [],
+}));
+
+const { applyRuntimeInjections } =
+  await import("../daemon/conversation-runtime-assembly.js");
+const { defaultInjectorsPlugin } =
+  await import("../plugins/defaults/injectors.js");
+const { registerPlugin, resetPluginRegistryForTests } =
+  await import("../plugins/registry.js");
+import type { TurnContext } from "../plugins/types.js";
+import type { Message } from "../providers/types.js";
+
+function makeTurnContext(): TurnContext {
+  return {
+    requestId: "req-test-1",
+    conversationId: "conv-test-1",
+    turnIndex: 0,
+    trust: {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    },
+  };
+}
+
+function tailTexts(messages: Message[]): string[] {
+  const tail = messages[messages.length - 1];
+  return tail.content
+    .filter((b): b is { type: "text"; text: string } => b.type === "text")
+    .map((b) => b.text);
+}
+
+const PKB_CONTEXT = "essentials of the project";
+const NOW_CONTENT = "Current focus: shipping G2.1";
+const RUN_MESSAGES: Message[] = [
+  { role: "user", content: [{ type: "text", text: "What next?" }] },
+];
+
+describe("PKB injector v2 cutover behavior", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultInjectorsPlugin);
+    v2Active = false;
+  });
+
+  test("v2 inactive → pkb-context, pkb-reminder, and now-md all produce blocks", async () => {
+    const result = await applyRuntimeInjections(RUN_MESSAGES, {
+      turnContext: makeTurnContext(),
+      pkbContext: PKB_CONTEXT,
+      pkbActive: true,
+      pkbScopeId: "scope-default",
+      pkbRoot: "/tmp/pkb",
+      pkbConversation: { messages: [] },
+      nowScratchpad: NOW_CONTENT,
+    });
+
+    const texts = tailTexts(result.messages);
+    expect(texts.some((t) => t.includes("<knowledge_base>"))).toBe(true);
+    expect(texts.some((t) => t.includes("<system_reminder>"))).toBe(true);
+    expect(texts.some((t) => t.includes("<NOW.md"))).toBe(true);
+  });
+
+  test("v2 active → pkb-context silenced; pkb-reminder + now-md still fire", async () => {
+    v2Active = true;
+    const result = await applyRuntimeInjections(RUN_MESSAGES, {
+      turnContext: makeTurnContext(),
+      pkbContext: PKB_CONTEXT,
+      pkbActive: true,
+      pkbScopeId: "scope-default",
+      pkbRoot: "/tmp/pkb",
+      pkbConversation: { messages: [] },
+      nowScratchpad: NOW_CONTENT,
+    });
+
+    const texts = tailTexts(result.messages);
+    expect(texts.some((t) => t.includes("<knowledge_base>"))).toBe(false);
+    expect(texts.some((t) => t.includes("<system_reminder>"))).toBe(true);
+    expect(texts.some((t) => t.includes("<NOW.md"))).toBe(true);
+    expect(texts).toContain("What next?");
+  });
+
+  test("v2 active → pkb-reminder body fires without the hybrid-search hints", async () => {
+    v2Active = true;
+    const result = await applyRuntimeInjections(RUN_MESSAGES, {
+      turnContext: makeTurnContext(),
+      pkbActive: true,
+      pkbScopeId: "scope-default",
+      pkbRoot: "/tmp/pkb",
+      pkbConversation: { messages: [] },
+      // Provide a query vector so the v1 path WOULD have called searchPkbFiles
+      // and rendered hints. Under v2, the call is skipped and the reminder
+      // is rendered with empty hints — i.e. no "files look especially
+      // relevant" line.
+      pkbQueryVector: [0.1, 0.2, 0.3],
+    });
+
+    const texts = tailTexts(result.messages);
+    const reminder = texts.find((t) => t.includes("<system_reminder>"));
+    expect(reminder).toBeDefined();
+    expect(reminder).not.toContain("files look especially relevant");
+  });
+});

package/src/__tests__/inline-command-runner.test.ts

@@ -19,8 +19,6 @@ const mockConfig = {
   rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: true,
-    action: "warn" as const,
-    entropyThreshold: 4.0,
   },
   auditLog: { retentionDays: 0 },
 };
@@ -43,30 +41,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-// Track wrapCommand calls to verify sandbox-only execution
-let lastWrapCall: {
-  command: string;
-  workingDir: string;
-  config: { enabled: boolean };
-  options?: { networkMode?: string };
-} | null = null;
-
-mock.module("../tools/terminal/sandbox.js", () => ({
-  wrapCommand: (
-    command: string,
-    workingDir: string,
-    config: { enabled: boolean },
-    options?: { networkMode?: string },
-  ) => {
-    lastWrapCall = { command, workingDir, config, options };
-    return {
-      command: "bash",
-      args: ["-c", "--", command],
-      sandboxed: false,
-    };
-  },
-}));
-
 mock.module("../tools/terminal/safe-env.js", () => ({
   buildSanitizedEnv: () => ({
     PATH: process.env.PATH ?? "/usr/bin:/bin",
@@ -100,46 +74,6 @@ function expectFailure(
 // ---------------------------------------------------------------------------
 
 describe("runInlineCommand", () => {
-  // ── Sandbox enforcement ──────────────────────────────────────────────────
-
-  describe("sandbox enforcement", () => {
-    test("always passes sandbox config with enabled=false", async () => {
-      lastWrapCall = null;
-      await runInlineCommand("echo sandbox-check", CWD);
-
-      expect(lastWrapCall).not.toBeNull();
-      expect(lastWrapCall!.config.enabled).toBe(false);
-    });
-
-    test("does not pass networkMode when sandbox is disabled", async () => {
-      lastWrapCall = null;
-      await runInlineCommand("echo network-check", CWD);
-
-      expect(lastWrapCall).not.toBeNull();
-      // networkMode is a no-op when sandbox is disabled (wrapCommand returns
-      // a plain bash invocation), so it is not passed. Network isolation is
-      // provided by the Docker/platform-managed container.
-      expect(lastWrapCall!.options).toBeUndefined();
-    });
-
-    test("uses the provided workingDir as cwd", async () => {
-      lastWrapCall = null;
-      const customDir = "/tmp/my-project";
-      await runInlineCommand("echo cwd-check", customDir);
-
-      expect(lastWrapCall).not.toBeNull();
-      expect(lastWrapCall!.workingDir).toBe(customDir);
-    });
-
-    test("passes the literal command string to the sandbox", async () => {
-      lastWrapCall = null;
-      await runInlineCommand("git log --oneline -n 5", CWD);
-
-      expect(lastWrapCall).not.toBeNull();
-      expect(lastWrapCall!.command).toBe("git log --oneline -n 5");
-    });
-  });
-
   // ── Successful execution ─────────────────────────────────────────────────
 
   describe("successful execution", () => {

package/src/__tests__/inline-skill-load-permissions.test.ts

@@ -188,7 +188,6 @@ describe("inline-command skill_load permissions", () => {
       );
       expect(result.decision).toBe("allow");
     });
-
   });
 
   // ── Feature flag disabled ────────────────────────────────────────────
@@ -253,5 +252,4 @@ describe("inline-command skill_load permissions", () => {
       }
     });
   });
-
 });

package/src/__tests__/install-skill-routing.test.ts

@@ -141,12 +141,6 @@ import { installSkill } from "../daemon/handlers/skills.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-const dummyCtx = {
-  debounceTimers: { schedule: () => {} },
-  setSuppressConfigReload: () => {},
-  updateConfigFingerprint: () => {},
-  broadcast: () => {},
-} as unknown as Parameters<typeof installSkill>[1];
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -178,7 +172,6 @@ describe("installSkill routing", () => {
         slug: "vercel-labs/agent-skills/react-best-practices",
         origin: "skillssh",
       },
-      dummyCtx,
     );
 
     expect(result.success).toBe(true);
@@ -196,7 +189,7 @@ describe("installSkill routing", () => {
   });
 
   test("install without origin falls through to clawhub for simple slugs", async () => {
-    const result = await installSkill({ slug: "some-clawhub-skill" }, dummyCtx);
+    const result = await installSkill({ slug: "some-clawhub-skill" });
 
     expect(result.success).toBe(true);
     expect(mockClawhubInstall).toHaveBeenCalledTimes(1);
@@ -210,7 +203,6 @@ describe("installSkill routing", () => {
   test("install with origin: 'clawhub' routes directly to clawhub without trying skills.sh", async () => {
     const result = await installSkill(
       { slug: "my-skill", origin: "clawhub" },
-      dummyCtx,
     );
 
     expect(result.success).toBe(true);
@@ -221,7 +213,6 @@ describe("installSkill routing", () => {
   test("multi-segment slug without explicit origin auto-routes to skills.sh", async () => {
     const result = await installSkill(
       { slug: "owner/repo/my-skill" },
-      dummyCtx,
     );
 
     expect(result.success).toBe(true);
@@ -242,7 +233,6 @@ describe("installSkill routing", () => {
     // should override the auto-detection and go to clawhub
     const result = await installSkill(
       { slug: "owner/repo/my-skill", origin: "clawhub" },
-      dummyCtx,
     );
 
     expect(result.success).toBe(true);
@@ -263,7 +253,6 @@ describe("installSkill routing", () => {
 
     const result = await installSkill(
       { slug: "bundled-skill", origin: "skillssh" },
-      dummyCtx,
     );
 
     expect(result.success).toBe(true);
@@ -282,7 +271,6 @@ describe("installSkill routing", () => {
         slug: "owner/repo/nonexistent-skill",
         origin: "skillssh",
       },
-      dummyCtx,
     );
 
     expect(result.success).toBe(false);

package/src/__tests__/llm-callsite-catalog.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+
+import { getLLMCallSiteLabel } from "../config/llm-callsite-catalog.js";
+import { CALL_SITE_CATALOG } from "../config/schemas/call-site-catalog.js";
+import { LLMCallSiteEnum } from "../config/schemas/llm.js";
+
+describe("LLM call-site catalog", () => {
+  test("resolves every backend call-site enum value from the catalog", () => {
+    const catalogIds = new Set(CALL_SITE_CATALOG.map(({ id }) => id));
+
+    expect(LLMCallSiteEnum.options.filter((id) => !catalogIds.has(id))).toEqual(
+      [],
+    );
+  });
+
+  test("returns catalog display names", () => {
+    for (const { id, displayName } of CALL_SITE_CATALOG) {
+      expect(getLLMCallSiteLabel(id)).toBe(displayName);
+    }
+  });
+
+  test("returns canonical user-facing labels", () => {
+    expect(getLLMCallSiteLabel("mainAgent")).toBe("Main Agent");
+    expect(getLLMCallSiteLabel("memoryExtraction")).toBe("Memory Extraction");
+    expect(getLLMCallSiteLabel("conversationTitle")).toBe("Conversation Title");
+    expect(getLLMCallSiteLabel("trustRuleSuggestion")).toBe(
+      "Trust Rule Suggestion",
+    );
+  });
+
+  test("returns the raw ID for unknown call sites", () => {
+    expect(getLLMCallSiteLabel("unknownCallSite")).toBe("unknownCallSite");
+  });
+});

package/src/__tests__/llm-catalog-parity.test.ts

@@ -38,6 +38,9 @@ interface ClientCatalogModel {
   displayName: string;
   contextWindowTokens?: number;
   maxOutputTokens?: number;
+  defaultContextWindowTokens?: number;
+  longContextPricingThresholdTokens?: number;
+  longContextMode?: "native-model" | "provider-request-option" | "unsupported";
   supportsThinking?: boolean;
   supportsCaching?: boolean;
   supportsVision?: boolean;
@@ -149,6 +152,13 @@ describe("LLM catalog parity: daemon vs client", () => {
           daemonModel.contextWindowTokens,
         );
         expect(clientModel.maxOutputTokens).toBe(daemonModel.maxOutputTokens);
+        expect(clientModel.defaultContextWindowTokens).toBe(
+          daemonModel.defaultContextWindowTokens,
+        );
+        expect(clientModel.longContextPricingThresholdTokens).toBe(
+          daemonModel.longContextPricingThresholdTokens,
+        );
+        expect(clientModel.longContextMode).toBe(daemonModel.longContextMode);
         expect(clientModel.supportsThinking).toBe(daemonModel.supportsThinking);
         expect(clientModel.supportsCaching).toBe(daemonModel.supportsCaching);
         expect(clientModel.supportsVision).toBe(daemonModel.supportsVision);
@@ -171,4 +181,84 @@ describe("LLM catalog parity: daemon vs client", () => {
       ).toBe(true);
     }
   });
+
+  test("every model default context is capped by its context window", () => {
+    const json = loadClientCatalog();
+
+    for (const entry of PROVIDER_CATALOG) {
+      for (const model of entry.models) {
+        expect(model.defaultContextWindowTokens).toBeGreaterThan(0);
+        if (model.contextWindowTokens === undefined) continue;
+        expect(
+          model.defaultContextWindowTokens,
+          `${entry.id}/${model.id} default context exceeds context window`,
+        ).toBeLessThanOrEqual(model.contextWindowTokens);
+      }
+    }
+
+    for (const entry of json.providers) {
+      for (const model of entry.models) {
+        expect(model.defaultContextWindowTokens).toBeGreaterThan(0);
+        if (model.contextWindowTokens === undefined) continue;
+        expect(
+          model.defaultContextWindowTokens,
+          `${entry.id}/${model.id} JSON default context exceeds context window`,
+        ).toBeLessThanOrEqual(model.contextWindowTokens);
+      }
+    }
+  });
+
+  test("sub-200k model defaults are clamped to model context caps", () => {
+    const ollama = PROVIDER_CATALOG.find((entry) => entry.id === "ollama");
+    expect(
+      ollama?.models.find((model) => model.id === "llama3.2"),
+    ).toMatchObject({
+      contextWindowTokens: 128000,
+      defaultContextWindowTokens: 128000,
+    });
+    expect(
+      ollama?.models.find((model) => model.id === "mistral"),
+    ).toMatchObject({
+      contextWindowTokens: 32768,
+      defaultContextWindowTokens: 32768,
+    });
+  });
+
+  test("OpenAI catalog includes long-context pricing metadata", () => {
+    const openai = PROVIDER_CATALOG.find((entry) => entry.id === "openai");
+    expect(
+      openai?.models.find((model) => model.id === "gpt-5.5-pro"),
+    ).toMatchObject({
+      displayName: "GPT-5.5 Pro",
+      contextWindowTokens: 1050000,
+      defaultContextWindowTokens: 200000,
+      maxOutputTokens: 128000,
+      longContextPricingThresholdTokens: 272000,
+      longContextMode: "native-model",
+    });
+    expect(
+      openai?.models.find((model) => model.id === "gpt-5.4"),
+    ).toMatchObject({
+      displayName: "GPT-5.4",
+      contextWindowTokens: 1050000,
+      defaultContextWindowTokens: 200000,
+      maxOutputTokens: 128000,
+      longContextPricingThresholdTokens: 272000,
+      longContextMode: "native-model",
+    });
+  });
+
+  test("Gemini 2.5 Pro catalog context matches provider limits", () => {
+    const gemini = PROVIDER_CATALOG.find((entry) => entry.id === "gemini");
+    expect(
+      gemini?.models.find((model) => model.id === "gemini-2.5-pro"),
+    ).toMatchObject({
+      displayName: "Gemini 2.5 Pro",
+      contextWindowTokens: 1048576,
+      defaultContextWindowTokens: 200000,
+      maxOutputTokens: 65536,
+      longContextPricingThresholdTokens: 200000,
+      longContextMode: "native-model",
+    });
+  });
 });

package/src/__tests__/llm-context-resolution.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, test } from "bun:test";
+
+import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+
+describe("resolveEffectiveContextWindow", () => {
+  test("existing config without context override resolves to 200k", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        provider: "openai",
+        model: "gpt-5.5",
+      },
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.maxInputTokens).toBe(200000);
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+    expect(resolved.defaultInputTokens).toBe(200000);
+    expect(resolved.isLongContextEnabled).toBe(false);
+  });
+
+  test("active profile context override beats llm.default", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        provider: "openai",
+        model: "gpt-5.5",
+        contextWindow: { maxInputTokens: 100000 },
+      },
+      profiles: {
+        long: {
+          contextWindow: { maxInputTokens: 150000 },
+        },
+      },
+      activeProfile: "long",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.provider).toBe("openai");
+    expect(resolved.model).toBe("gpt-5.5");
+    expect(resolved.maxInputTokens).toBe(150000);
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+    expect(resolved.defaultInputTokens).toBe(200000);
+    expect(resolved.isLongContextEnabled).toBe(false);
+  });
+
+  test("main agent active profile context override beats call-site profile defaults", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        provider: "openai",
+        model: "gpt-5.5",
+      },
+      profiles: {
+        active: {
+          contextWindow: { maxInputTokens: 150000 },
+        },
+        site: {
+          label: "Site profile",
+          description: "Used by one call site.",
+          source: "user",
+          contextWindow: { maxInputTokens: 175000 },
+        },
+      },
+      activeProfile: "active",
+      callSites: {
+        mainAgent: { profile: "site" },
+      },
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.maxInputTokens).toBe(150000);
+    expect(resolved.compactThreshold).toBe(0.8);
+    expect(resolved.summaryBudgetRatio).toBe(0.05);
+    expect(resolved.targetBudgetRatio).toBe(0.3);
+    expect(resolved.overflowRecovery.maxAttempts).toBe(3);
+  });
+
+  test("non-main call-site profile context override beats active profile", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        provider: "openai",
+        model: "gpt-5.5",
+      },
+      profiles: {
+        active: {
+          contextWindow: { maxInputTokens: 150000 },
+        },
+        site: {
+          contextWindow: { maxInputTokens: 175000 },
+        },
+      },
+      activeProfile: "active",
+      callSites: {
+        memoryExtraction: { profile: "site" },
+      },
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "memoryExtraction",
+    });
+
+    expect(resolved.maxInputTokens).toBe(175000);
+  });
+
+  test("unknown catalog model falls back safely to the default 200k cap", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        provider: "openai",
+        model: "custom-model",
+        contextWindow: { maxInputTokens: 300000 },
+      },
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.maxInputTokens).toBe(200000);
+    expect(resolved.modelMaxInputTokens).toBe(200000);
+    expect(resolved.defaultInputTokens).toBe(200000);
+    expect(resolved.maxOutputTokens).toBeUndefined();
+    expect(resolved.isLongContextEnabled).toBe(false);
+  });
+
+  test("configured context above the model maximum is clamped", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        provider: "openai",
+        model: "gpt-5.5",
+        contextWindow: { maxInputTokens: 2000000 },
+      },
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.maxInputTokens).toBe(1050000);
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+    expect(resolved.isLongContextEnabled).toBe(true);
+  });
+
+  test("max output metadata is independent from context budget", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        provider: "openai",
+        model: "gpt-5.5",
+      },
+      profiles: {
+        capped: {
+          contextWindow: { maxInputTokens: 150000 },
+        },
+      },
+      activeProfile: "capped",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.maxInputTokens).toBe(150000);
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+    expect(resolved.maxOutputTokens).toBe(128000);
+  });
+});