@vellumai/assistant 0.11.2-dev.202608051838.a2809c6 → 0.11.2-dev.202608051933.deffc0f

package/ARCHITECTURE.md

@@ -67,8 +67,10 @@ All HTTP API requests use a single `Authorization: Bearer <jwt>` header for auth
 | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
 | `actor_client_v1`    | `chat.{read,write}`, `approval.{read,write}`, `settings.{read,write}`, `attachments.{read,write}`, `calls.{read,write}`, `feature_flags.{read,write}` | Desktop, CLI clients                         |
 | `gateway_ingress_v1` | `ingress.write`, `internal.write`                                                                                                                     | Gateway channel inbound + webhook forwarding |
-| `gateway_service_v1` | `settings.read`, `settings.write`, `internal.write`                                                                                                   | Gateway service-to-daemon calls              |
-| `internal_v1`        | `internal.all`                                                                                                                                        | Internal service connections                 |
+| `gateway_service_v1` | `chat.{read,write}`, `settings.{read,write}`, `attachments.{read,write}`, `internal.write`                                                            | Gateway service-to-daemon calls              |
+| `local_v1`           | `local.all`                                                                                                                                           | Local (loopback) conversation sessions       |
+| `speech_relay_v1`    | `speech.relay`                                                                                                                                        | Daemon dial of the gateway speech relay only |
+| `ui_page_v1`         | `settings.read`                                                                                                                                       | Served UI pages                              |
 
 **Identity lifecycle:**
 

package/openapi.yaml

@@ -9565,6 +9565,28 @@ paths:
                 required:
                   - ok
                 additionalProperties: false
+  /v1/conversations/unread-count:
+    get:
+      operationId: conversations_unreadcount_get
+      summary: Unread conversation count
+      description:
+        "Count of foreground conversations whose latest assistant message is unseen. Matches the sidebar's unread
+        indicators: archived rows and non-surfaced background/scheduled rows are excluded."
+      tags:
+        - conversations
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  count:
+                    type: number
+                required:
+                  - count
+                additionalProperties: false
   /v1/conversations/wake:
     post:
       operationId: conversations_wake_post

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2-dev.202608051838.a2809c6",
+  "version": "0.11.2-dev.202608051933.deffc0f",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -1,16 +1,17 @@
 /**
  * Verifies that the per-turn `overrideProfile` plumbed into `AgentLoop.run()`
  * surfaces on every `SendMessageOptions.config` the loop emits, and that
- * `SubagentManager.spawn()` propagates an inherited `overrideProfile` from
- * its `SubagentConfig` into the subagent's `runAgentLoop()` call.
+ * `SubagentManager.spawn()` propagates an `overrideProfile` set on its
+ * `SubagentConfig` into the subagent's `runAgentLoop()` call.
  *
- * Together these two assertions establish the PR 6 contract: a parent
- * conversation that pins an inference profile sees that profile applied to
- * every LLM call within its agent-loop turn, and any subagent spawned during
- * that turn inherits the same profile automatically.
+ * Together these establish where a pinned profile does and does not travel: it
+ * applies to every LLM call within the pinning conversation's own turn, and it
+ * stops at the spawn boundary. `executeSubagentSpawn` sets `overrideProfile`
+ * on the `SubagentConfig` only for a profile named explicitly on the spawn, so
+ * the propagation above carries a caller's choice rather than a parent's pin.
  *
- * Default behavior (no `overrideProfile` set) must remain unchanged — the
- * field is omitted from `providerConfig` rather than carrying `undefined`.
+ * With no `overrideProfile` set, the field is omitted from `providerConfig`
+ * rather than carrying `undefined`.
  */
 
 import { describe, expect, mock, test } from "bun:test";
@@ -183,7 +184,7 @@ describe("AgentLoop.run — overrideProfile plumbing", () => {
   });
 });
 
-// ── Subagent inheritance ─────────────────────────────────────────────────
+// ── Subagent profile forwarding ──────────────────────────────────────────
 
 // Capture the SubagentManager → Conversation handshake so we can verify the
 // `overrideProfile` from `SubagentConfig` is forwarded into the spawned
@@ -329,7 +330,7 @@ seedLlmConfig();
 
 import { SubagentManager } from "../subagent/manager.js";
 
-describe("SubagentManager.spawn — overrideProfile inheritance", () => {
+describe("SubagentManager.spawn: forwards a configured overrideProfile", () => {
   test("forwards overrideProfile from SubagentConfig into runAgentLoop", async () => {
     capturedRunAgentLoopOptions.length = 0;
 
@@ -344,9 +345,9 @@ describe("SubagentManager.spawn — overrideProfile inheritance", () => {
       () => {},
     );
 
-    // The spawned subagent's runAgentLoop must receive both the
-    // `subagentSpawn` callSite (existing behavior) and the inherited
-    // `overrideProfile` (new behavior).
+    // The spawned subagent's runAgentLoop receives the `subagentSpawn`
+    // callSite and whatever `overrideProfile` the config carries, which
+    // `executeSubagentSpawn` sets only for an explicitly named profile.
     expect(capturedRunAgentLoopOptions).toHaveLength(1);
     const captured = capturedRunAgentLoopOptions[0];
     expect(captured.callSite).toBe("subagentSpawn");
@@ -399,21 +400,18 @@ describe("SubagentManager.spawn — overrideProfile inheritance", () => {
   });
 });
 
-// ── Nested subagent spawn — context.overrideProfile preferred ────────────
+// ── Nested subagent spawn: no profile crosses the boundary ───────────────
 
-// Verify the third-level inheritance contract: when a subagent's agent loop
-// is running with `currentTurnOverrideProfile`, the executor closure plumbs
-// that value into `ToolContext.overrideProfile`. `executeSubagentSpawn` must
-// then prefer `context.overrideProfile` over a row read against the in-flight
-// subagent's own conversationId — that row never has `inferenceProfile` set,
-// and `getConversationOverrideProfile` short-circuits for background
-// conversations regardless. Without preferring the in-memory context, the
-// inheritance chain breaks at the second nesting level.
+// When a subagent's agent loop is running under a turn profile, the executor
+// closure plumbs that value into `ToolContext.overrideProfile`. That value
+// describes the spawning turn, so `executeSubagentSpawn` leaves it behind: a
+// child resolves the `subagentSpawn` call site on its own, and a forwarded
+// override would both re-price the child and file its spend as a pin nobody
+// set. These tests cover the nesting levels where a profile could otherwise
+// compound down a chain of children.
 
 mock.module("../persistence/conversation-crud.js", () => ({
   setConversationProcessingStartedAt: () => {},
-  // Always return undefined for the row read so the test fails fast unless
-  // executeSubagentSpawn reads from context.overrideProfile first.
   getConversationOverrideProfile: () => undefined,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
@@ -421,8 +419,8 @@ mock.module("../persistence/conversation-crud.js", () => ({
 import { getSubagentManager } from "../subagent/index.js";
 import { executeSubagentSpawn } from "../tools/subagent/spawn.js";
 
-describe("executeSubagentSpawn — nested inheritance via context.overrideProfile", () => {
-  test("forwards context.overrideProfile to SubagentConfig (third-level inheritance)", async () => {
+describe("executeSubagentSpawn: the spawn boundary carries no profile", () => {
+  test("a subagent spawning a subagent does not pass its own turn profile down", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;
@@ -432,11 +430,11 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
     };
 
     try {
-      // Simulate the second-level spawn: tool invocation occurs inside the
-      // first subagent's tool context, where `overrideProfile` was populated
-      // by `runAgentLoopImpl` from its `currentTurnOverrideProfile` snapshot.
-      // The first subagent's own conversation row has no `inferenceProfile`,
-      // so the row-read fallback would otherwise return undefined.
+      // The second-level spawn: this tool call happens inside the first
+      // subagent's tool context, where `overrideProfile` was populated by
+      // `runAgentLoopImpl` from its own turn snapshot. That snapshot describes
+      // the parent's turn, so it stops here rather than compounding down a
+      // chain of nested children.
       const result = await executeSubagentSpawn(
         { label: "nested", objective: "do nested work" },
         {
@@ -450,16 +448,13 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
 
       expect(result.isError).toBe(false);
       expect(capturedConfig).toBeDefined();
-      // The forwarded SubagentConfig must carry the in-memory override so
-      // SubagentManager.spawn forwards it into the nested subagent's
-      // runAgentLoop options — preserving inheritance across the chain.
-      expect(capturedConfig!.overrideProfile).toBe("fast");
+      expect("overrideProfile" in capturedConfig!).toBe(false);
     } finally {
       manager.spawn = originalSpawn;
     }
   });
 
-  test("forwards the invoker's resolved default profile when neither context nor row carries an override", async () => {
+  test("no override anywhere leaves the child on the subagentSpawn default", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;
@@ -481,22 +476,17 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
       );
 
       expect(capturedConfig).toBeDefined();
-      // 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");
+      expect("overrideProfile" in capturedConfig!).toBe(false);
     } finally {
       manager.spawn = originalSpawn;
     }
   });
 
-  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 —
-    // a forwarded override would outrank the pin under single-winner
-    // resolution, overriding the user's explicit call-site choice.
+  test("a workspace active profile does not reach the child, pinned or not", async () => {
+    // The child resolves `llm.callSites.subagentSpawn` on its own, so the
+    // spawn must forward nothing either way: a forwarded override would
+    // outrank an explicit call-site pin under single-winner resolution and
+    // overturn the operator's choice.
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;
@@ -517,7 +507,7 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
         { label: "nested", objective: "do nested work" },
         baseContext,
       );
-      expect(capturedConfig!.overrideProfile).toBe("fast");
+      expect("overrideProfile" in capturedConfig!).toBe(false);
 
       seedLlmConfig({
         activeProfile: "fast",

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -80,16 +80,6 @@ describe("isAssistantFeatureFlagEnabled", () => {
   });
 });
 
-describe("subagent flags default to disabled", () => {
-  for (const flagKey of ["subagent-profile-isolation", "subagent-loop-guard"]) {
-    test(`${flagKey} resolves to false with no override`, () => {
-      const config = {} as any;
-
-      expect(isAssistantFeatureFlagEnabled(flagKey, config)).toBe(false);
-    });
-  }
-});
-
 describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   test("resolves skill flag via canonical path", () => {
     setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });

package/src/__tests__/llm-resolver-override-or-default.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import { CODE_DEFAULT_PROFILE_ENTRIES } from "../config/default-profile-catalog.js";
 import {
+  composeCallSiteTweak,
   type ResolutionFallbackReason,
   resolveCallSiteConfig,
   resolveDefaultProfileKey,
@@ -178,6 +179,146 @@ describe("fallback and completeness", () => {
   });
 });
 
+describe("composeCallSiteTweak", () => {
+  // `CallSiteDefaultConfig` supports a shipped `model` (and the provider it
+  // implies). No entry sets one today, so these pin the invariant the merge
+  // depends on rather than waiting for the first entry that would break it.
+  test("a workspace entry owns selection: a shipped model/provider is dropped", () => {
+    const tweak = composeCallSiteTweak(
+      { model: "shipped-model", provider: "openai", effort: "low" },
+      { profile: "mine" },
+    );
+    expect("model" in tweak).toBe(false);
+    expect("provider" in tweak).toBe(false);
+    // The shipped tuning still layers in.
+    expect(tweak.effort).toBe("low");
+  });
+
+  test("with no workspace entry the shipped fragment applies whole", () => {
+    const tweak = composeCallSiteTweak(
+      { model: "shipped-model", provider: "openai", effort: "low" },
+      undefined,
+    );
+    expect(tweak.model).toBe("shipped-model");
+    expect(tweak.provider).toBe("openai");
+  });
+
+  test("a workspace provider/model still applies", () => {
+    const tweak = composeCallSiteTweak(
+      { model: "shipped-model", effort: "low" },
+      { provider: "anthropic", model: "chosen-model" },
+    );
+    expect(tweak.model).toBe("chosen-model");
+    expect(tweak.provider).toBe("anthropic");
+    expect(tweak.effort).toBe("low");
+  });
+
+  test("profile and logitBias never reach the fragment", () => {
+    const tweak = composeCallSiteTweak(
+      { effort: "low" },
+      { profile: "mine", logitBias: "suppress-cjk", maxTokens: 10 },
+    );
+    expect("profile" in tweak).toBe(false);
+    expect("logitBias" in tweak).toBe(false);
+    expect(tweak.maxTokens).toBe(10);
+  });
+});
+
+describe("shipped call-site tuning", () => {
+  // A workspace entry that only repoints the profile must not cost the call
+  // site the tuning it ships with. `recall` carries a full set: a token
+  // budget, effort, sampling, thinking, and cache posture.
+  test("a profile-only entry keeps the shipped tuning and takes the new model", () => {
+    const shipped = resolveCallSiteConfig(
+      "recall",
+      LLMSchema.parse({ profiles: { mine: completeCustom }, ...anthropicDp }),
+    );
+    const repointed = resolveCallSiteConfig(
+      "recall",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: { recall: { profile: "mine" } },
+        ...anthropicDp,
+      }),
+    );
+
+    // The pin is what selects the model.
+    expect(repointed.model).toBe("gpt-5.5");
+    expect(repointed.model).not.toBe(shipped.model);
+
+    // Everything the call site ships with survives the repoint.
+    expect(repointed.maxTokens).toBe(4096);
+    expect(repointed.effort).toBe("low");
+    expect(repointed.temperature).toBe(0);
+    expect(repointed.disableCache).toBe(true);
+    expect(repointed.thinking.enabled).toBe(false);
+    expect(repointed.thinking.streamThinking).toBe(false);
+  });
+
+  test("a profile-only entry keeps a shipped nested budget", () => {
+    const resolved = resolveCallSiteConfig(
+      "memoryRouter",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: { memoryRouter: { profile: "mine" } },
+        ...anthropicDp,
+      }),
+    );
+    expect(resolved.contextWindow.maxInputTokens).toBe(1000000);
+  });
+
+  test("an explicit workspace field beats the shipped one, field by field", () => {
+    const resolved = resolveCallSiteConfig(
+      "recall",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: {
+          recall: { profile: "mine", maxTokens: 512, effort: "high" },
+        },
+        ...anthropicDp,
+      }),
+    );
+    // The two fields the entry names come from the entry.
+    expect(resolved.maxTokens).toBe(512);
+    expect(resolved.effort).toBe("high");
+    // The ones it does not name still come from the shipped tuning.
+    expect(resolved.temperature).toBe(0);
+    expect(resolved.disableCache).toBe(true);
+    expect(resolved.thinking.enabled).toBe(false);
+  });
+
+  test("a provider/model entry keeps the shipped tuning too", () => {
+    const resolved = resolveCallSiteConfig(
+      "recall",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: {
+          recall: { provider: "openai", model: "gpt-5.5" },
+        },
+        ...anthropicDp,
+      }),
+    );
+    expect(resolved.model).toBe("gpt-5.5");
+    expect(resolved.maxTokens).toBe(4096);
+    expect(resolved.effort).toBe("low");
+    expect(resolved.disableCache).toBe(true);
+  });
+
+  test("a call site with no shipped tuning is unaffected", () => {
+    const resolved = resolveCallSiteConfig(
+      "conversationSummarization",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: { conversationSummarization: { profile: "mine" } },
+        ...anthropicDp,
+      }),
+    );
+    expect(resolved.model).toBe("gpt-5.5");
+    expect(resolved.maxTokens).toBe(completeCustom.maxTokens);
+    expect(resolved.effort).toBe(completeCustom.effort);
+  });
+});
+
 describe("composition", () => {
   test("base + winner + site-tweak composition (nested tweaks combine leaf-wise)", () => {
     const llm = LLMSchema.parse({