@vellumai/assistant 0.8.2 → 0.8.4

package/src/providers/provider-catalog-visibility.ts

@@ -32,5 +32,7 @@ export function getVisibleProviderCatalog(
       if (visibleModels.length === entry.models.length) return entry;
       return { ...entry, models: visibleModels };
     })
-    .filter((entry) => entry.models.length > 0);
+    .filter(
+      (entry) => entry.models.length > 0 || entry.defaultModel === "",
+    );
 }

package/src/providers/provider-send-message.ts

@@ -7,8 +7,10 @@
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
+import { getDb } from "../memory/db-connection.js";
 import { getLogger } from "../util/logger.js";
 import { tryResolveProviderForConnectionName } from "./connection-resolution.js";
+import { listConnections } from "./inference/connections.js";
 import { initializeProviders, listProviders } from "./registry.js";
 import type {
   ContentBlock,
@@ -110,22 +112,35 @@ export async function resolveConfiguredProvider(
 
   const resolved = resolveCallSiteConfig(callSite, config.llm, opts);
   const inferenceProvider = resolved.provider;
-  const connectionName = resolved.provider_connection;
+  let connectionName = resolved.provider_connection;
 
   // Connection-aware path: every dispatch goes through `provider_connection`.
   // The boot-time backfill ensures every profile has one in production.
-  // When unset (test envs that skip backfill, freshly-installed configs
-  // not yet backfilled, or users who manually cleared the field), we
-  // return null so callsites with deterministic fallbacks (invite
-  // instructions, telegram username resolution, etc.) keep working.
-  // Hard config errors — connection lookup failure, provider mismatch —
-  // still throw via `tryResolveProviderForConnectionName` below.
+  // When unset (profile set provider with "Any active" connection, test envs
+  // that skip backfill, freshly-installed configs not yet backfilled, or
+  // users who manually cleared the field), try to auto-resolve from the
+  // provider before falling back to null.
   if (!connectionName) {
-    log.debug(
-      { callSite, inferenceProvider },
-      "resolveCallSiteConfig yielded no provider_connection — returning null so callsite can fall back",
-    );
-    return null;
+    if (inferenceProvider) {
+      try {
+        const candidates = listConnections(getDb(), {
+          provider: inferenceProvider,
+        });
+        const active = candidates.find((c) => c.status === "active");
+        if (active) {
+          connectionName = active.name;
+        }
+      } catch {
+        // DB not available — fall through to the existing null-return path.
+      }
+    }
+    if (!connectionName) {
+      log.debug(
+        { callSite, inferenceProvider },
+        "resolveCallSiteConfig yielded no provider_connection — returning null so callsite can fall back",
+      );
+      return null;
+    }
   }
 
   const connectionProvider = await tryResolveProviderForConnectionName(

package/src/providers/registry.ts

@@ -1,4 +1,6 @@
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import type { AssistantConfig } from "../config/schema.js";
 import { type LLMConfig } from "../config/schemas/llm.js";
 import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { ProviderNotConfiguredError } from "../util/errors.js";
@@ -26,6 +28,7 @@ const log = getLogger("provider-registry");
 
 const providers = new Map<string, Provider>();
 const routingSources = new Map<string, "user-key" | "managed-proxy">();
+const OPENAI_COMPATIBLE_ENDPOINTS_FLAG = "openai-compatible-endpoints";
 
 /** Per-connection provider cache, keyed by connection name. */
 const connectionProviders = new Map<string, Provider>();
@@ -69,6 +72,16 @@ export interface ProvidersConfig {
   timeouts?: { providerStreamTimeoutSec?: number };
 }
 
+function isProviderFeatureFlagEnabled(
+  key: string,
+  config: ProvidersConfig,
+): boolean {
+  return isAssistantFeatureFlagEnabled(
+    key,
+    config as unknown as AssistantConfig,
+  );
+}
+
 function resolveModel(config: ProvidersConfig, providerName: string): string {
   const resolved = resolveCallSiteConfig("mainAgent", config.llm);
   const inferenceProvider = resolved.provider;
@@ -130,6 +143,13 @@ export async function initializeProviders(
   ).provider;
 
   for (const entry of PROVIDER_CATALOG) {
+    if (
+      entry.featureFlag &&
+      !isProviderFeatureFlagEnabled(entry.featureFlag, config)
+    ) {
+      continue;
+    }
+
     const isKeyless = entry.setupMode === "keyless";
 
     // Credential resolution: user key first, managed proxy second. Keyless
@@ -202,10 +222,19 @@ export async function resolveProviderFromConnection(
   connection: ProviderConnection,
   config: ProvidersConfig,
 ): Promise<Provider | null> {
+  if (
+    connection.provider === "openai-compatible" &&
+    !isProviderFeatureFlagEnabled(OPENAI_COMPATIBLE_ENDPOINTS_FLAG, config)
+  ) {
+    return null;
+  }
+
   const cached = connectionProviders.get(connection.name);
   if (cached) return cached;
 
-  const authResult = await resolveAuth(connection.auth, connection.provider);
+  const authResult = await resolveAuth(connection.auth, connection.provider, {
+    baseUrl: connection.baseUrl,
+  });
   if (!authResult.ok) {
     const err = authResult.error;
     if (err.code === "not_implemented") {

package/src/providers/types.ts

@@ -27,6 +27,15 @@ export interface FileContent {
     filename: string;
   };
   extracted_text?: string;
+  /**
+   * Internal id linking this block to a row in the attachments table.
+   * Set when the file block originates from a persisted user-message
+   * attachment so downstream consumers (DB joins, inline-chip
+   * positioning) can correlate the block back to its attachment id.
+   * Stripped by `daemon/handlers/shared.ts` before sending to the
+   * model.
+   */
+  _attachmentId?: string;
 }
 
 export interface ToolUseContent {
@@ -137,6 +146,22 @@ export type ProviderEvent =
       toolUseId: string;
       isError: boolean;
       content?: unknown[];
+      /**
+       * Finalized input for the server tool call (e.g. the actual query).
+       * Anthropic streams `server_tool_use` block input via `input_json_delta`
+       * events, so consumers reading the input at `server_tool_start` see `{}`.
+       * The provider accumulates the JSON and surfaces it here once the block
+       * stops, so downstream handlers can build accurate activity metadata.
+       */
+      resolvedInput?: Record<string, unknown>;
+      /**
+       * Provider-specific error code when `isError` is true (e.g. Anthropic's
+       * `max_uses_exceeded`, `query_too_long`). Surfaced so user-facing
+       * messages can be specific instead of a generic "Search failed".
+       */
+      errorCode?: string;
+      /** Optional human-readable error message from the provider. */
+      errorMessage?: string;
     };
 
 export interface SendMessageConfig {

package/src/runtime/__tests__/agent-wake.test.ts

@@ -22,8 +22,29 @@ import type { DiskPressureStatus } from "../../daemon/disk-pressure-guard.js";
 // Stub the DB-backed override-profile read so unit tests don't need a
 // real SQLite database. The wake helper calls this on every invocation
 // to honor the conversation's pinned inference profile.
+// `getConversation` is consumed by `defaultResolveTarget` — most tests
+// pass explicit `deps.resolveTarget` and bypass it, but the
+// trust-context threading test below drives the default resolver and
+// needs the existence/archived check to pass.
 mock.module("../../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: () => undefined,
+  getConversation: () => ({ archivedAt: null }),
+}));
+
+const mockGetOrCreateConversationCalls: Array<{
+  conversationId: string;
+  options: unknown;
+}> = [];
+mock.module("../../daemon/conversation-store.js", () => ({
+  getOrCreateConversation: (conversationId: string, options?: unknown) => {
+    mockGetOrCreateConversationCalls.push({ conversationId, options });
+    return Promise.resolve({ __mockConversation: true });
+  },
+}));
+
+let mockResolverTarget: unknown = null;
+mock.module("../../daemon/wake-target-adapter.js", () => ({
+  conversationToWakeTarget: () => mockResolverTarget,
 }));
 
 mock.module("../../config/loader.js", () => ({
@@ -248,6 +269,8 @@ function makeTarget(options: {
 beforeEach(() => {
   __resetWakeChainForTests();
   recordRequestLogCalls.length = 0;
+  mockGetOrCreateConversationCalls.length = 0;
+  mockResolverTarget = null;
   mockDiskPressureStatus = {
     enabled: false,
     state: "disabled",
@@ -1587,4 +1610,195 @@ describe("wakeAgentForOpportunity", () => {
     // No log row was inserted because JSON.stringify threw.
     expect(recordRequestLogCalls).toHaveLength(0);
   });
+
+  // Regression guard for fork-based memory retrospectives: PR #31260
+  // forked a conversation and waked it with a guardian trustContext,
+  // but the wake's default resolver called
+  // `getOrCreateConversation(conversationId)` with no options, so the
+  // store hydrated with `trustContext === undefined`. `loadFromDb`
+  // fail-closes to `trustClass: "unknown"` and filters out every
+  // guardian-provenance message — so the LLM saw an empty history and
+  // every fork sent `messages: []`. Threading trustContext through
+  // ensures `setTrustContext` + `ensureActorScopedHistory` run during
+  // hydration.
+  const makeDefaultResolverTarget = (conversationId: string): WakeTarget => {
+    const history: Message[] = [];
+    let processing = false;
+    return {
+      conversationId,
+      agentLoop: { run: async (input) => input },
+      getMessages: () => history,
+      pushMessage: () => {},
+      emitAgentEvent: () => {},
+      isProcessing: () => processing,
+      markProcessing: (on) => {
+        processing = on;
+      },
+      persistTailMessage: async () => {},
+    };
+  };
+
+  test("default resolver threads WakeOptions.trustContext into getOrCreateConversation", async () => {
+    mockResolverTarget = makeDefaultResolverTarget("conv-thread-trust");
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    } as const;
+
+    await wakeAgentForOpportunity({
+      conversationId: "conv-thread-trust",
+      hint: "consolidate",
+      source: "memory_v2_consolidation",
+      trustContext,
+    });
+
+    expect(mockGetOrCreateConversationCalls).toEqual([
+      { conversationId: "conv-thread-trust", options: { trustContext } },
+    ]);
+  });
+
+  test("default resolver passes trustContext: undefined when WakeOptions.trustContext is omitted", async () => {
+    // Inbound user-turn wakes get trust via processMessage(); the wake
+    // must not synthesize a trust context out of thin air.
+    mockResolverTarget = makeDefaultResolverTarget("conv-no-trust-default");
+
+    await wakeAgentForOpportunity({
+      conversationId: "conv-no-trust-default",
+      hint: "x",
+      source: "unit-test",
+    });
+
+    expect(mockGetOrCreateConversationCalls).toEqual([
+      {
+        conversationId: "conv-no-trust-default",
+        options: { trustContext: undefined },
+      },
+    ]);
+  });
+
+  describe("suppressWakeSurface option", () => {
+    function makeCheckpointTarget(): {
+      target: WakeTarget;
+      persistedTailCalls: Message[];
+      wakeProducedOutputCalls: string[];
+    } {
+      const firstAssistant: Message = {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu-1", name: "some_tool", input: {} },
+        ],
+      };
+      const toolResult: Message = {
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: "tu-1", content: "ok" }],
+      };
+      const persistedTailCalls: Message[] = [];
+      const baseline: Message[] = [
+        { role: "user", content: [{ type: "text", text: "hi" }] },
+      ];
+      const history: Message[] = [...baseline];
+      let processing = false;
+      const wakeProducedOutputCalls: string[] = [];
+
+      const target: WakeTarget = {
+        conversationId: "conv-suppress-surface",
+        agentLoop: {
+          run: async (_input, _onEvent, _signal, _requestId, onCheckpoint) => {
+            const runHistory: Message[] = [..._input];
+            runHistory.push(firstAssistant);
+            runHistory.push(toolResult);
+            await onCheckpoint!({
+              turnIndex: 0,
+              toolCount: 1,
+              hasToolUse: true,
+              history: runHistory,
+            });
+            return runHistory;
+          },
+        },
+        getMessages: () => history,
+        pushMessage: (msg) => {
+          history.push(msg);
+        },
+        emitAgentEvent: () => {},
+        isProcessing: () => processing,
+        markProcessing: (on) => {
+          processing = on;
+        },
+        persistTailMessage: async (msg) => {
+          persistedTailCalls.push(msg);
+        },
+        onWakeProducedOutput: (_source, _hint, surfaceId) => {
+          wakeProducedOutputCalls.push(surfaceId);
+        },
+      };
+      return { target, persistedTailCalls, wakeProducedOutputCalls };
+    }
+
+    test(
+      "default (suppressWakeSurface omitted) still injects the ui_surface " +
+        "card and calls onWakeProducedOutput",
+      async () => {
+        const { target, persistedTailCalls, wakeProducedOutputCalls } =
+          makeCheckpointTarget();
+
+        await wakeAgentForOpportunity(
+          {
+            conversationId: "conv-suppress-surface",
+            hint: "do the thing",
+            source: "memory_v2_consolidation",
+          },
+          { resolveTarget: async () => target },
+        );
+
+        // Existing behavior: card injected, broadcast fired exactly once.
+        expect(wakeProducedOutputCalls).toHaveLength(1);
+        const persistedFirst = persistedTailCalls[0];
+        expect(persistedFirst).toBeDefined();
+        const blocks = Array.isArray(persistedFirst!.content)
+          ? persistedFirst!.content
+          : [];
+        const uiBlock = blocks.find(
+          (b: { type?: string }) => b.type === "ui_surface",
+        );
+        expect(uiBlock).toBeDefined();
+      },
+    );
+
+    test(
+      "suppressWakeSurface: true produces output but skips the ui_surface " +
+        "card injection and the onWakeProducedOutput broadcast",
+      async () => {
+        const { target, persistedTailCalls, wakeProducedOutputCalls } =
+          makeCheckpointTarget();
+
+        await wakeAgentForOpportunity(
+          {
+            conversationId: "conv-suppress-surface",
+            hint: "do the thing",
+            source: "memory_v2_consolidation",
+            suppressWakeSurface: true,
+          },
+          { resolveTarget: async () => target },
+        );
+
+        // Tail still persisted (wake produced real output).
+        const persistedFirst = persistedTailCalls[0];
+        expect(persistedFirst).toBeDefined();
+        // First assistant tail message should NOT have a ui_surface block
+        // prepended at the front.
+        const blocks = Array.isArray(persistedFirst!.content)
+          ? persistedFirst!.content
+          : [];
+        const firstBlock = blocks[0] as { type?: string } | undefined;
+        expect(firstBlock?.type).not.toBe("ui_surface");
+        const uiBlock = blocks.find(
+          (b: { type?: string }) => b.type === "ui_surface",
+        );
+        expect(uiBlock).toBeUndefined();
+        // Live broadcast was suppressed.
+        expect(wakeProducedOutputCalls).toHaveLength(0);
+      },
+    );
+  });
 });

package/src/runtime/__tests__/background-job-runner.test.ts

@@ -94,6 +94,8 @@ mock.module("../pre-first-message-gate.js", () => ({
 
 // Import after mocks are in place.
 const { runBackgroundJob } = await import("../background-job-runner.js");
+const { bufferIfDeferred, resetDeferredForTest } =
+  await import("../../notifications/deferred-emit.js");
 
 // ── Shared fixtures ──────────────────────────────────────────────────
 
@@ -121,6 +123,7 @@ beforeEach(() => {
   processMessageCalls.length = 0;
   emitCalls.length = 0;
   addMessageCalls.length = 0;
+  resetDeferredForTest();
   preFirstMessageGateOpen = true;
   processMessageImpl = async () => ({ messageId: "msg-1" });
   emitImpl = async () => ({
@@ -354,4 +357,129 @@ describe("runBackgroundJob", () => {
       expect(processMessageCalls).toHaveLength(1);
     });
   });
+
+  describe("deferNotifications", () => {
+    function buildSkillNotificationParams(message: string) {
+      return {
+        sourceEventName: "assistant.share",
+        sourceChannel: "assistant_tool" as const,
+        sourceContextId: "skill-ctx",
+        contextPayload: { requestedMessage: message },
+        attentionHints: {
+          requiresAction: false,
+          urgency: "low" as const,
+          isAsyncBackground: false,
+          visibleInSourceNow: false,
+        },
+      };
+    }
+
+    test("success path commits buffered in-band notifications", async () => {
+      processMessageImpl = async () => {
+        // Stand in for the IPC route's bufferIfDeferred call when the model
+        // invokes `notifications send` mid-turn.
+        const buffered = bufferIfDeferred(
+          STUB_CONVERSATION_ID,
+          buildSkillNotificationParams("all green"),
+        );
+        expect(buffered).not.toBeNull();
+        expect(buffered!.dispatched).toBe(false);
+        return { messageId: "msg-success" };
+      };
+
+      const result = await runBackgroundJob(
+        baseOpts({ deferNotifications: true }),
+      );
+
+      expect(result.ok).toBe(true);
+      // Commit flushed the buffered notification through emitNotificationSignal.
+      const successEmits = emitCalls.filter(
+        (e) => e.sourceEventName !== "activity.failed",
+      );
+      expect(successEmits).toHaveLength(1);
+      expect(successEmits[0].sourceEventName).toBe("assistant.share");
+    });
+
+    // Regression for the PR #31216 Codex P1 finding: a heartbeat that calls
+    // the notifications skill and then times out must not leave a "success"
+    // notification standing alongside the runner's `activity.failed` emit.
+    test("timeout drops buffered in-band notifications; only activity.failed emits", async () => {
+      processMessageImpl = () => {
+        bufferIfDeferred(
+          STUB_CONVERSATION_ID,
+          buildSkillNotificationParams("premature success"),
+        );
+        return new Promise(() => {});
+      };
+
+      const result = await runBackgroundJob(
+        baseOpts({ deferNotifications: true, timeoutMs: 30 }),
+      );
+
+      expect(result.ok).toBe(false);
+      expect(result.errorKind).toBe("timeout");
+      // Only the runner's failure signal makes it out — the buffered
+      // "success" notification is discarded.
+      expect(emitCalls).toHaveLength(1);
+      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
+    });
+
+    test("thrown exception also drops buffered notifications", async () => {
+      processMessageImpl = async () => {
+        bufferIfDeferred(
+          STUB_CONVERSATION_ID,
+          buildSkillNotificationParams("doomed"),
+        );
+        throw new Error("kaboom");
+      };
+
+      const result = await runBackgroundJob(
+        baseOpts({ deferNotifications: true }),
+      );
+
+      expect(result.ok).toBe(false);
+      expect(emitCalls).toHaveLength(1);
+      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
+    });
+
+    // Regression: after timeout, `processMessage` keeps running and may
+    // emit a late skill call. The tombstone must swallow it instead of
+    // letting it bypass the buffer and reach the dispatch pipeline.
+    test("late skill call after timeout is swallowed by the tombstone", async () => {
+      processMessageImpl = () => new Promise(() => {});
+
+      const result = await runBackgroundJob(
+        baseOpts({ deferNotifications: true, timeoutMs: 20 }),
+      );
+      expect(result.ok).toBe(false);
+
+      const late = bufferIfDeferred(
+        STUB_CONVERSATION_ID,
+        buildSkillNotificationParams("post-timeout"),
+      );
+      expect(late).not.toBeNull();
+      expect(late!.dispatched).toBe(false);
+      expect(late!.reason).toMatch(/did not complete/);
+
+      // Only the runner's failure signal made it out.
+      expect(emitCalls).toHaveLength(1);
+      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
+    });
+
+    test("without deferNotifications, bufferIfDeferred is a no-op", async () => {
+      processMessageImpl = async () => {
+        const buffered = bufferIfDeferred(
+          STUB_CONVERSATION_ID,
+          buildSkillNotificationParams("immediate"),
+        );
+        // Buffer was never armed, so the call returns null and the IPC
+        // handler would emit directly.
+        expect(buffered).toBeNull();
+        return { messageId: "msg-success" };
+      };
+
+      const result = await runBackgroundJob(baseOpts());
+      expect(result.ok).toBe(true);
+    });
+  });
 });