@vellumai/assistant 0.8.9-dev.202606091853.fbaa2ae → 0.8.9-dev.202606091926.ebb2d62

package/openapi.yaml

@@ -15945,6 +15945,8 @@ paths:
                             - assistant
                         content:
                           type: string
+                          deprecated: true
+                          description: "Deprecated: superseded by contentBlocks. Flat plain-text body (joined text segments)."
                         timestamp:
                           type: string
                         attachments:
@@ -16304,14 +16306,22 @@ paths:
                           type: array
                           items:
                             type: string
+                          deprecated: true
+                          description: "Deprecated: superseded by contentBlocks. Text segments split by tool-call boundaries."
                         thinkingSegments:
                           type: array
                           items:
                             type: string
+                          deprecated: true
+                          description: "Deprecated: superseded by contentBlocks. Reasoning text extracted from thinking blocks."
                         contentOrder:
                           type: array
                           items:
                             type: string
+                          deprecated: true
+                          description:
+                            'Deprecated: superseded by contentBlocks. Positional "<type>:<index>" content ordering (e.g. "text:0",
+                            "thinking:1").'
                         contentBlocks:
                           type: array
                           items:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.9-dev.202606091853.fbaa2ae",
+  "version": "0.8.9-dev.202606091926.ebb2d62",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/sync-llm-catalog.ts

@@ -74,6 +74,8 @@ function projectModel(model: CatalogModel): Record<string, unknown> {
     projected.longContextMode = model.longContextMode;
   if (model.supportsThinking !== undefined)
     projected.supportsThinking = model.supportsThinking;
+  if (model.adaptiveThinkingOnly !== undefined)
+    projected.adaptiveThinkingOnly = model.adaptiveThinkingOnly;
   if (model.supportsCaching !== undefined)
     projected.supportsCaching = model.supportsCaching;
   if (model.supportsVision !== undefined)

package/src/__tests__/build-persisted-content.test.ts

@@ -54,7 +54,10 @@ mock.module("../memory/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
-import { buildPersistedAssistantContent } from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  buildPersistedAssistantContent,
+  stampThinkingTiming,
+} from "../daemon/conversation-agent-loop-handlers.js";
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import type { ContentBlock } from "../providers/types.js";
 
@@ -182,3 +185,74 @@ describe("buildPersistedAssistantContent — native activityMetadata", () => {
     expect(block._activityMetadata).toBeUndefined();
   });
 });
+
+describe("stampThinkingTiming", () => {
+  test("stamps internal timing onto thinking blocks by position", () => {
+    // GIVEN a turn that interleaves text and two thinking blocks AND the
+    // per-block timing captured while streaming (one entry per thinking block,
+    // in stream order)
+    const content = [
+      { type: "thinking", thinking: "first", signature: "s1" },
+      { type: "text", text: "answer" },
+      { type: "thinking", thinking: "second", signature: "s2" },
+    ] as unknown as ContentBlock[];
+    const timings = [
+      { startedAt: 100, completedAt: 250 },
+      { startedAt: 400, completedAt: 480 },
+    ];
+
+    // WHEN the content is stamped before persistence
+    const stamped = stampThinkingTiming(content, timings) as unknown as Array<
+      Record<string, unknown>
+    >;
+
+    // THEN each thinking block carries the `_`-prefixed timing for its position
+    expect(stamped[0]).toMatchObject({
+      type: "thinking",
+      _startedAt: 100,
+      _completedAt: 250,
+    });
+    expect(stamped[2]).toMatchObject({
+      type: "thinking",
+      _startedAt: 400,
+      _completedAt: 480,
+    });
+    // AND the interleaved text block is left untouched
+    expect(stamped[1]).toEqual({ type: "text", text: "answer" });
+  });
+
+  test("leaves thinking blocks unstamped when no timing was captured", () => {
+    // GIVEN thinking content but an empty timing list (thinking streaming was
+    // disabled, so no per-block timing was recorded this turn)
+    const content = [
+      { type: "thinking", thinking: "first", signature: "s1" },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is stamped with no timing
+    const stamped = stampThinkingTiming(content, []);
+
+    // THEN the original content is returned unchanged so the UI hides duration,
+    // exactly as a tool call with no timing
+    expect(stamped).toBe(content);
+    expect(stamped[0]).not.toHaveProperty("_startedAt");
+  });
+
+  test("stamps only the thinking blocks that have a matching timing entry", () => {
+    // GIVEN two thinking blocks but only one captured timing entry (e.g. the
+    // second block opened after the timing array was already finalized)
+    const content = [
+      { type: "thinking", thinking: "first", signature: "s1" },
+      { type: "thinking", thinking: "second", signature: "s2" },
+    ] as unknown as ContentBlock[];
+    const timings = [{ startedAt: 100, completedAt: 250 }];
+
+    // WHEN the content is stamped
+    const stamped = stampThinkingTiming(content, timings) as unknown as Array<
+      Record<string, unknown>
+    >;
+
+    // THEN the first block is stamped and the unmatched second block is left as-is
+    expect(stamped[0]).toMatchObject({ _startedAt: 100, _completedAt: 250 });
+    expect(stamped[1]).not.toHaveProperty("_startedAt");
+  });
+});

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

@@ -57,17 +57,8 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeLoggerStub(),
 }));
 
-// ---------------------------------------------------------------------------
-// Feature flag mock — controls whether managed-gemini-embeddings-enabled is on
-// ---------------------------------------------------------------------------
-
-let featureFlagEnabled = false;
-
 mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) => {
-    if (key === "managed-gemini-embeddings-enabled") return featureFlagEnabled;
-    return true;
-  },
+  isAssistantFeatureFlagEnabled: () => true,
   clearFeatureFlagOverridesCache: () => {},
   initFeatureFlagOverrides: async () => {},
   getAssistantFeatureFlagDefaults: () => ({}),
@@ -119,8 +110,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
     setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
 
-    // Reset mock state
-    featureFlagEnabled = false;
     originalIsPlatform = process.env.IS_PLATFORM;
     delete process.env.IS_PLATFORM;
   });
@@ -137,10 +126,9 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
     }
   });
 
-  test("applies managed Gemini defaults when FF on + IS_PLATFORM + provider auto", () => {
+  test("applies managed Gemini defaults when IS_PLATFORM + provider auto", () => {
     writeConfig({});
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -162,22 +150,9 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
     expect(qdrantRaw.vectorSize).toBe(3072);
   });
 
-  test("does NOT apply when feature flag is OFF", () => {
-    writeConfig({});
-
-    featureFlagEnabled = false;
-    process.env.IS_PLATFORM = "true";
-
-    const config = loadConfig();
-
-    expect(config.memory.embeddings.provider).toBe("auto");
-    expect(config.memory.qdrant.vectorSize).toBe(384);
-  });
-
   test("does NOT apply when IS_PLATFORM is not set", () => {
     writeConfig({});
 
-    featureFlagEnabled = true;
     delete process.env.IS_PLATFORM;
 
     const config = loadConfig();
@@ -191,7 +166,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       memory: { embeddings: { provider: "local" } },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -204,7 +178,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       memory: { embeddings: { provider: "openai" } },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -219,7 +192,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -235,7 +207,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       memory: { embeddings: { provider: "ollama" } },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -245,7 +216,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
   test("is idempotent — second loadConfig is a no-op after migration", () => {
     writeConfig({});
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -274,7 +244,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -295,22 +264,9 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
     expect(qdrantRaw.onDisk).toBe(false);
   });
 
-  test("does NOT apply when both FF off and IS_PLATFORM not set", () => {
-    writeConfig({});
-
-    featureFlagEnabled = false;
-    delete process.env.IS_PLATFORM;
-
-    const config = loadConfig();
-
-    expect(config.memory.embeddings.provider).toBe("auto");
-    expect(config.memory.qdrant.vectorSize).toBe(384);
-  });
-
   test("applies when IS_PLATFORM is '1'", () => {
     writeConfig({});
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "1";
 
     const config = loadConfig();

package/src/__tests__/credential-execution-feature-gates.test.ts

@@ -165,10 +165,11 @@ describe("CES flags do not affect unrelated flags", () => {
     setOverridesForTesting(overrides);
     const config = makeConfig();
 
-    // account-deletion defaults to true in the registry and should stay true.
-    expect(isAssistantFeatureFlagEnabled("account-deletion", config)).toBe(
-      true,
-    );
+    // Flags with defaultEnabled: true in the registry should stay true
+    // regardless of CES overrides.
+    expect(
+      isAssistantFeatureFlagEnabled("platform-features-in-local-mode", config),
+    ).toBe(true);
   });
 
   test("enabling all CES flags does not change unrelated fail-closed flags", () => {

package/src/__tests__/embedding-managed-proxy-selection.test.ts

@@ -2,8 +2,7 @@
  * Tests for managed proxy Gemini embedding backend selection.
  *
  * Verifies that selectEmbeddingBackend correctly routes through the
- * managed proxy when the feature flag is enabled and managed proxy
- * prerequisites are satisfied.
+ * managed proxy when managed proxy prerequisites are satisfied.
  */
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -42,13 +41,9 @@ mock.module("../security/secure-keys.js", () => ({
   },
 }));
 
-// Feature flag mock
-const mockFeatureFlags: Record<string, boolean> = {};
-
+// Feature flag mock — always returns true (flag is GA'ed)
 mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string, _config: unknown) => {
-    return mockFeatureFlags[key] ?? false;
-  },
+  isAssistantFeatureFlagEnabled: () => true,
 }));
 
 import type { AssistantConfig } from "../config/types.js";
@@ -75,14 +70,6 @@ function disableManagedProxy() {
   mockAssistantApiKey = null;
 }
 
-function enableFlag() {
-  mockFeatureFlags["managed-gemini-embeddings-enabled"] = true;
-}
-
-function disableFlag() {
-  mockFeatureFlags["managed-gemini-embeddings-enabled"] = false;
-}
-
 function makeConfig(
   overrides: {
     provider?: string;
@@ -116,7 +103,6 @@ function makeConfig(
 
 beforeEach(() => {
   disableManagedProxy();
-  disableFlag();
   mockProviderKeys = {};
   clearEmbeddingBackendCache();
 });
@@ -126,9 +112,8 @@ afterEach(() => {
 });
 
 describe("managed proxy Gemini embedding selection", () => {
-  test("selects managed proxy Gemini when flag enabled and proxy context available", async () => {
+  test("selects managed proxy Gemini when proxy context available", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig();
 
     const { backend, reason } = await selectEmbeddingBackend(config);
@@ -141,7 +126,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("managed proxy backend uses default 3072 dimensions when geminiDimensions not set", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig();
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -155,7 +139,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("managed proxy backend uses explicit geminiDimensions when set", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig({ geminiDimensions: 768 });
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -168,7 +151,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("managed proxy backend uses managedBaseUrl (not direct Google API)", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig();
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -179,32 +161,19 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(managedBaseUrl).toBe(`${PLATFORM_BASE}/v1/runtime-proxy/gemini`);
   });
 
-  test("falls back to local when flag is disabled (no managed proxy)", async () => {
-    enableManagedProxy();
-    disableFlag();
-    const config = makeConfig();
-
-    const { backend } = await selectEmbeddingBackend(config);
-
-    // With auto and no provider keys, falls through to local
-    expect(backend).not.toBeNull();
-    expect(backend!.provider).toBe("local");
-  });
-
   test("falls back to local when managed proxy context unavailable", async () => {
     disableManagedProxy();
-    enableFlag();
     const config = makeConfig();
 
     const { backend } = await selectEmbeddingBackend(config);
 
+    // With auto and no provider keys or proxy, falls through to local
     expect(backend).not.toBeNull();
     expect(backend!.provider).toBe("local");
   });
 
   test("selects managed proxy when provider is explicitly gemini", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig({ provider: "gemini" });
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -217,7 +186,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("does not use managed proxy when provider is explicitly local", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig({ provider: "local" });
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -228,7 +196,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("does not use managed proxy when provider is explicitly openai", async () => {
     enableManagedProxy();
-    enableFlag();
     mockProviderKeys[credentialKey("openai", "api_key")] = "user-openai-key";
     const config = makeConfig({ provider: "openai" });
 
@@ -238,9 +205,8 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(backend!.provider).toBe("openai");
   });
 
-  test("direct Gemini key still works when flag is off", async () => {
+  test("direct Gemini key still works without managed proxy", async () => {
     disableManagedProxy();
-    disableFlag();
     mockProviderKeys[credentialKey("gemini", "api_key")] = "user-gemini-key";
     const config = makeConfig({ provider: "gemini" });
 

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

@@ -53,6 +53,7 @@ interface ClientCatalogModel {
   longContextPricingThresholdTokens?: number;
   longContextMode?: "native-model" | "provider-request-option" | "unsupported";
   supportsThinking?: boolean;
+  adaptiveThinkingOnly?: boolean;
   supportsCaching?: boolean;
   supportsVision?: boolean;
   supportsToolUse?: boolean;
@@ -194,6 +195,9 @@ describe("LLM catalog parity: daemon vs client", () => {
         );
         expect(clientModel.longContextMode).toBe(daemonModel.longContextMode);
         expect(clientModel.supportsThinking).toBe(daemonModel.supportsThinking);
+        expect(clientModel.adaptiveThinkingOnly).toBe(
+          daemonModel.adaptiveThinkingOnly,
+        );
         expect(clientModel.supportsCaching).toBe(daemonModel.supportsCaching);
         expect(clientModel.supportsVision).toBe(daemonModel.supportsVision);
         expect(clientModel.supportsToolUse).toBe(daemonModel.supportsToolUse);

package/src/__tests__/persistence-secret-redaction.test.ts

@@ -370,3 +370,81 @@ describe("persistence-layer secret redaction", () => {
     expect(textBlock?.text).toBe(text);
   });
 });
+
+describe("thinking timing persistence", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+    state = createEventHandlerState();
+    state.turnStartedAt = 1_700_000_000_000;
+  });
+
+  afterEach(() => {
+    addMessageCalls.length = 0;
+  });
+
+  function makeThinkingCompleteEvent(): Extract<
+    AgentEvent,
+    { type: "message_complete" }
+  > {
+    return {
+      type: "message_complete",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "let me reason", signature: "sig" },
+          { type: "text", text: "the answer" },
+        ],
+      },
+    };
+  }
+
+  test("stamps per-block thinking timing onto the persisted thinking block", async () => {
+    // GIVEN a turn whose row was reserved at llm_call_started
+    await handleLlmCallStarted(state, makeDeps());
+
+    // AND streaming then captured timing for one thinking block (startedAt when
+    // it opened, completedAt at its last reasoning delta). The reserve resets
+    // the accumulator, so deltas — and thus the timing — land after it.
+    state.currentThinkingTimestamps = [{ startedAt: 1000, completedAt: 1750 }];
+
+    // WHEN the message completes and content is persisted
+    await handleMessageComplete(state, makeDeps(), makeThinkingCompleteEvent());
+
+    // THEN the persisted thinking block carries the internal `_`-prefixed
+    // timing so a history reload can surface the duration + "Started at" hover
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      _startedAt?: number;
+      _completedAt?: number;
+    }>;
+    const thinkingBlock = blocks.find((b) => b.type === "thinking");
+    expect(thinkingBlock?._startedAt).toBe(1000);
+    expect(thinkingBlock?._completedAt).toBe(1750);
+  });
+
+  test("persists no thinking timing when none was captured this turn", async () => {
+    // GIVEN a turn that produced a thinking block but captured no timing
+    // (thinking streaming disabled, so the timing list stays empty)
+    expect(state.currentThinkingTimestamps).toEqual([]);
+
+    // WHEN the message completes and content is persisted
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(state, makeDeps(), makeThinkingCompleteEvent());
+
+    // THEN the thinking block is persisted without timing, so the client hides
+    // the duration exactly as a tool call with no timing
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      _startedAt?: number;
+      _completedAt?: number;
+    }>;
+    const thinkingBlock = blocks.find((b) => b.type === "thinking");
+    expect(thinkingBlock).toBeDefined();
+    expect(thinkingBlock?._startedAt).toBeUndefined();
+    expect(thinkingBlock?._completedAt).toBeUndefined();
+  });
+});