@vellumai/assistant 0.8.0 → 0.8.2

package/src/providers/retry.ts

@@ -72,6 +72,40 @@ const RETRYABLE_STREAM_PATTERNS = [
  */
 const RETRYABLE_PROVIDER_MESSAGE_PATTERNS = [/overloaded/i];
 
+/**
+ * Patterns that indicate the Anthropic provider SDK reported a transport-level
+ * abort (TCP close mid-stream, edge LB idle cutoff, Bun fetch deadline) rather
+ * than a caller-initiated cancellation or inner-timeout deadline. The SDK
+ * surfaces all three cases as ``Request was aborted`` with ``error.status ===
+ * undefined``; the catch-site in ``providers/anthropic/client.ts`` separates
+ * them by:
+ *   - tagging caller cancellations with ``abortReason`` (short-circuits in
+ *     {@link isRetryableError} before reaching this predicate)
+ *   - rewriting the inner-timeout message to ``"Anthropic stream timed out
+ *     after Xs (inner streamTimeoutMs)"`` (doesn't start with ``Anthropic API
+ *     error:`` so it falls through to network-error classification)
+ *   - leaving the transport-abort message verbatim as
+ *     ``"Anthropic API error: Request was aborted."``
+ *
+ * Pattern is intentionally anchored to the Anthropic-specific message prefix.
+ * The OpenAI / Gemini / OpenRouter catch-sites format their errors as
+ * ``"<Provider> API error (undefined): Request was aborted."`` (note the
+ * ``(undefined)`` parenthetical) and — crucially — do **not** rewrite
+ * inner-timeout failures, so a provider-agnostic ``/request was aborted/i``
+ * predicate would erroneously retry their 30-minute deadline failures three
+ * additional times. Once those catch-sites grow the same
+ * ``innerTimeoutFired`` distinction the Anthropic one has, the pattern set
+ * here can be expanded to cover them too.
+ *
+ * This is the daemon-side counterpart to the vembda graceful-close behavior
+ * for upstream disconnects (LUM-1536) — together they collapse the 45 s
+ * silent-stall window the web client used to observe whenever Anthropic's
+ * stream was cut mid-token.
+ */
+const RETRYABLE_TRANSPORT_ABORT_PATTERNS = [
+  /^anthropic api error:\s*request was aborted/i,
+];
+
 function isRetryableStreamError(error: unknown): boolean {
   if (!(error instanceof ProviderError)) return false;
   if (error.statusCode !== undefined) return false; // has a real HTTP status — not a stream error
@@ -84,6 +118,15 @@ function isRetryableProviderMessage(error: unknown): boolean {
   return RETRYABLE_PROVIDER_MESSAGE_PATTERNS.some((p) => p.test(error.message));
 }
 
+function isRetryableTransportAbort(error: unknown): boolean {
+  if (!(error instanceof ProviderError)) return false;
+  // Transport aborts surface with ``status === undefined`` (the SDK never
+  // saw an HTTP response). A real HTTP status here means a server error,
+  // which is handled by the status check.
+  if (error.statusCode !== undefined) return false;
+  return RETRYABLE_TRANSPORT_ABORT_PATTERNS.some((p) => p.test(error.message));
+}
+
 function isRetryableError(error: unknown): boolean {
   // Context overflow is deterministic — retrying the same oversized prompt
   // will never succeed. Short-circuit before the generic 429/5xx check so
@@ -103,6 +146,7 @@ function isRetryableError(error: unknown): boolean {
   }
   if (isRetryableProviderMessage(error)) return true;
   if (isRetryableStreamError(error)) return true;
+  if (isRetryableTransportAbort(error)) return true;
   return isRetryableNetworkError(error);
 }
 
@@ -205,16 +249,8 @@ function normalizeSendMessageOptions(
     ) {
       nextConfig.temperature = resolved.temperature;
     }
-    if (nextConfig.thinking === undefined) {
-      // Convert the schema-shape `{ enabled, streamThinking }` into Anthropic's
-      // discriminated wire-format (`{ type: "adaptive" | "disabled" }`).
-      // Without this conversion, `thinking` arrives at `AnthropicProvider`
-      // with a shape the SDK doesn't accept (`ThinkingConfigParam` requires
-      // a `type` discriminator).
-      const thinking = normalizeThinkingConfigForWire(resolved.thinking);
-      if (thinking !== undefined) {
-        nextConfig.thinking = thinking;
-      }
+    if (nextConfig.thinking === undefined && resolved.thinking !== undefined) {
+      nextConfig.thinking = resolved.thinking;
     }
     // Forward OpenRouter-only routing preferences so `OpenRouterProvider` can
     // translate `openrouter.only` into the wire-format `provider: { only: [...] }`
@@ -236,6 +272,22 @@ function normalizeSendMessageOptions(
     // "Extra inputs are not permitted".
   }
 
+  // Convert schema-shape `{ enabled, streamThinking }` into Anthropic's
+  // discriminated wire-format (`{ type: "adaptive" | "disabled" }`).
+  // `AnthropicProvider`'s SDK requires a `type` discriminator, and downstream
+  // forced-tool/temperature conflict checks compare against the wire shape.
+  // Applies to both the resolver path above and pass-through callers (e.g.
+  // `host.providers.llm.complete`) that supply `thinking` directly without a
+  // `callSite`.
+  if (nextConfig.thinking !== undefined) {
+    const normalized = normalizeThinkingConfigForWire(nextConfig.thinking);
+    if (normalized === undefined) {
+      delete nextConfig.thinking;
+    } else {
+      nextConfig.thinking = normalized;
+    }
+  }
+
   // thinking is Anthropic-specific on the wire; OpenRouter reads it as a
   // signal for its unified reasoning parameter. Strip it for other providers.
   if (
@@ -474,7 +526,9 @@ export class RetryProvider implements Provider {
                   ? "provider_overloaded"
                   : isRetryableStreamError(error)
                     ? "stream_corruption"
-                    : "network_error";
+                    : isRetryableTransportAbort(error)
+                      ? "transport_abort"
+                      : "network_error";
           log.warn(
             {
               attempt: attempt + 1,

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

@@ -0,0 +1,121 @@
+/**
+ * Canonical catalog of built-in web-search providers.
+ *
+ * This is the single source of truth that drives:
+ *
+ *   1. The config-schema enum (`VALID_WEB_SEARCH_PROVIDERS` in
+ *      `assistant/src/config/schemas/services.ts`).
+ *   2. The search-provider env-var map (`SEARCH_PROVIDER_ENV_VAR_NAMES`
+ *      in `provider-env-vars.ts`).
+ *   3. The API-key provider set (`SEARCH_API_KEY_PROVIDERS` in
+ *      `provider-secret-catalog.ts`).
+ *   4. (Indirect, via `meta/web-search-provider-catalog.json` generated by
+ *      `assistant/scripts/sync-web-search-catalog.ts`) the CLI mirror in
+ *      `cli/src/shared/provider-env-vars.ts` and the web vendored catalog
+ *      in `vellum-assistant-platform`.
+ *
+ * Mirrors the pattern from `model-catalog.ts` (Provider Expansion Phase 3
+ * for LLM providers). When introducing a new built-in web-search provider,
+ * the daemon-side changes collapse to:
+ *
+ *   1. Add a new executor in `tools/network/web-search.ts`.
+ *   2. Register an adapter in the `WEB_SEARCH_ADAPTERS` table.
+ *   3. Add an entry to this catalog.
+ *   4. Run `bun run sync:web-search-catalog` to regenerate
+ *      `meta/web-search-provider-catalog.json`.
+ *
+ * The split between adapter (which carries the executor) and catalog (which
+ * carries metadata) keeps the catalog purely declarative — adding an entry
+ * never forces a code rebuild downstream and the JSON projection stays
+ * trivial.
+ */
+
+export type SearchProviderKind = "managed" | "byok";
+
+export interface SearchProviderCatalogEntry {
+  /** Stable provider identifier. Matches config + secret-catalog values. */
+  readonly id: string;
+  /** Short display name used by picker UIs. */
+  readonly displayName: string;
+  /**
+   * Optional long display name for prose contexts (marketing docs,
+   * privacy notices). Defaults to {@link displayName} when omitted.
+   */
+  readonly displayNameLong?: string;
+  /** Authentication style. `managed` providers are routed through the
+   *  inference provider; `byok` providers require a user-supplied key. */
+  readonly kind: SearchProviderKind;
+  /** Placeholder shown in the API-key input. BYOK providers only. */
+  readonly apiKeyPrefix?: string;
+  /** Environment variable name carrying the API key. BYOK providers only. */
+  readonly envVar?: string;
+  /** Secret-catalog key (the bare provider name accepted by
+   *  `getProviderKeyAsync`). BYOK providers only. */
+  readonly secretKey?: string;
+  /** Position in the daemon fallback chain (lower = earlier). BYOK only. */
+  readonly fallbackOrder?: number;
+  /** Privacy-policy URL surfaced in marketing data-sharing docs.
+   *  BYOK providers only. */
+  readonly privacyPolicyUrl?: string;
+}
+
+export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
+  {
+    id: "inference-provider-native",
+    displayName: "Provider Native",
+    kind: "managed",
+  },
+  {
+    id: "perplexity",
+    displayName: "Perplexity",
+    kind: "byok",
+    apiKeyPrefix: "pplx-...",
+    envVar: "PERPLEXITY_API_KEY",
+    secretKey: "perplexity",
+    fallbackOrder: 1,
+    privacyPolicyUrl: "https://www.perplexity.ai/hub/legal/privacy-policy",
+  },
+  {
+    id: "brave",
+    displayName: "Brave",
+    displayNameLong: "Brave Search",
+    kind: "byok",
+    apiKeyPrefix: "BSA...",
+    envVar: "BRAVE_API_KEY",
+    secretKey: "brave",
+    fallbackOrder: 2,
+    privacyPolicyUrl: "https://search.brave.com/help/privacy-policy",
+  },
+  {
+    id: "tavily",
+    displayName: "Tavily",
+    kind: "byok",
+    apiKeyPrefix: "tvly-...",
+    envVar: "TAVILY_API_KEY",
+    secretKey: "tavily",
+    fallbackOrder: 3,
+    privacyPolicyUrl: "https://tavily.com/privacy",
+  },
+];
+
+/** Provider ids accepted by the web-search config schema. */
+export const SEARCH_PROVIDER_IDS: readonly string[] = SEARCH_PROVIDER_CATALOG.map(
+  (p) => p.id,
+);
+
+/** Catalog entries that store an API key under their bare provider name. */
+export const BYOK_SEARCH_PROVIDERS: readonly SearchProviderCatalogEntry[] =
+  SEARCH_PROVIDER_CATALOG.filter((p) => p.kind === "byok");
+
+/** BYOK provider ids, ordered by `fallbackOrder` (ascending). */
+export const SEARCH_PROVIDER_FALLBACK_ORDER: readonly string[] = BYOK_SEARCH_PROVIDERS
+  .slice()
+  .sort((a, b) => (a.fallbackOrder ?? 0) - (b.fallbackOrder ?? 0))
+  .map((p) => p.id);
+
+/** Look up a single catalog entry by id. Returns `undefined` if unknown. */
+export function getSearchProvider(
+  id: string,
+): SearchProviderCatalogEntry | undefined {
+  return SEARCH_PROVIDER_CATALOG.find((p) => p.id === id);
+}

package/src/runtime/AGENTS.md

@@ -12,6 +12,10 @@ The single HTTP send endpoint is `POST /v1/messages`. Key behaviors:
 
 Do NOT add new send endpoints. All message ingress should go through `POST /v1/messages` (HTTP).
 
+### SSE backpressure shedding must be observable
+
+SSE handlers built on `ReadableStream` shed slow subscribers when `controller.desiredSize <= 0` to keep daemon memory bounded. Every shed site must emit a log line + Sentry capture so the daemon-side shed can be time-correlated with the client-side idle watchdog (otherwise stalls are invisible from both sides). See [WHATWG Streams — Backpressure](https://streams.spec.whatwg.org/#pipe-chains) and [Node `monitorEventLoopDelay`](https://nodejs.org/api/perf_hooks.html#perf_hooksmonitoreventloopdelayoptions).
+
 ### GET handler idempotency
 
 GET handlers must be safe and side-effect-free — they must not enqueue background jobs, mutate database state, or trigger writes. If a feature needs server-initiated work in response to a client request, use an explicit POST endpoint or a push-based flow (SSE event → client refetch). See [RFC 9110 §9.2.1 — Safe Methods](https://httpwg.org/specs/rfc9110.html#safe.methods).
@@ -65,6 +69,15 @@ Host browser allows the assistant to proxy CDP (Chrome DevTools Protocol) JSON-R
   - `POST /v1/host-browser-result` — `{ requestId, content, isError }`
 - **Tracking**: Uses the same `pending-interactions` tracker as the other host proxy types, with `kind: "host_browser"`. Registration happens in `conversation-routes.ts` and the route handler is in `host-browser-routes.ts`.
 
+### Host app-control (desktop proxy native-app control)
+
+Host app-control allows the assistant to proxy app-control actions (target a specific application by bundle ID or process name, capture window screenshots, drive UI) to the desktop host via the client, following the same pattern as host bash, host file, host CU, and host browser. App-control sessions are per-conversation, so the proxy reference lives on `Conversation.hostAppControlProxy` rather than as a singleton.
+
+- **Discovery**: Clients discover pending host app-control requests via SSE events (`host_app_control_request`) which include a `requestId`.
+- **Resolution**: Clients execute the app-control action on the host and respond via:
+  - `POST /v1/host-app-control-result` — `{ requestId, state, pngBase64?, windowBounds?, executionResult?, executionError? }`. `state` is one of `"running" | "missing" | "minimized"`.
+- **Tracking**: Uses the same `pending-interactions` tracker as the other host proxy types, with `kind: "host_app_control"`. The route handler is in `host-app-control-routes.ts` and forwards the payload to the owning conversation's `hostAppControlProxy.resolve()`. Late delivery is tolerated — the route returns 200 even when no pending interaction matches (e.g. the conversation was disposed before the client reported back).
+
 ### `chrome-extension` interface (Phase 2)
 
 The `chrome-extension` interface in `INTERFACE_IDS` is a non-interactive transport that supports only the `host_browser` capability — it does NOT support `host_bash`, `host_file`, or `host_cu`. This is encoded in `supportsHostProxy(id, capability)`: passing a capability argument returns `true` for `chrome-extension` only when the capability is `host_browser`; the no-arg form returns `false` for `chrome-extension` (so legacy desktop-only call sites that assume full-desktop proxy availability continue to gate correctly).
@@ -83,11 +96,11 @@ See `docs/browser-use-architecture-phase2.md` for the full wire diagram and comp
 
 On macOS-originated turns, the CDP factory (`tools/browser/cdp-client/factory.ts`) evaluates three browser backends in strict priority order. Each candidate is tried lazily; if the first command fails with a transport-level error, the factory falls over to the next candidate. CDP protocol errors (the browser understood the command but rejected it) do NOT trigger failover.
 
-| Priority | Backend                    | Condition                                                                                                                                                                                                | Transport                                                                                              |
-| -------- | -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
-| 1        | **Extension / host proxy** | `hostBrowserProxy` present AND `isAvailable()` returns `true`. On macOS, the proxy is always provisioned. On other interfaces, requires an active hub subscriber with `host_browser` capability | WS via `ChromeExtensionRegistry` (self-hosted), SSE via `assistantEventHub` with `targetCapability: "host_browser"` (cloud extension or macOS) |
-| 2        | **cdp-inspect**            | (a) `hostBrowser.cdpInspect.enabled` is `true` in config, OR (b) `transportInterface === "macos"` AND `desktopAuto.enabled` is `true` (default) AND the cooldown from a prior failure is not active      | Direct CDP WebSocket to `localhost:9222`                                                               |
-| 3        | **Local**                  | Always present as the final fallback                                                                                                                                                                     | In-process Playwright CDP via `browserManager`                                                         |
+| Priority | Backend                    | Condition                                                                                                                                                                                           | Transport                                                                                                                                      |
+| -------- | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| 1        | **Extension / host proxy** | `hostBrowserProxy` present AND `isAvailable()` returns `true`. On macOS, the proxy is always provisioned. On other interfaces, requires an active hub subscriber with `host_browser` capability     | WS via `ChromeExtensionRegistry` (self-hosted), SSE via `assistantEventHub` with `targetCapability: "host_browser"` (cloud extension or macOS) |
+| 2        | **cdp-inspect**            | (a) `hostBrowser.cdpInspect.enabled` is `true` in config, OR (b) `transportInterface === "macos"` AND `desktopAuto.enabled` is `true` (default) AND the cooldown from a prior failure is not active | Direct CDP WebSocket to `localhost:9222`                                                                                                       |
+| 3        | **Local**                  | Always present as the final fallback                                                                                                                                                                | In-process Playwright CDP via `browserManager`                                                                                                 |
 
 **Transport selection for the extension/host-proxy backend:**
 

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

@@ -68,6 +68,33 @@ mock.module("../../daemon/disk-pressure-guard.js", () => ({
   getDiskPressureStatus: () => mockDiskPressureStatus,
 }));
 
+const recordRequestLogCalls: Array<{
+  conversationId: string;
+  requestPayload: string;
+  responsePayload: string;
+  messageId?: string;
+  provider?: string;
+}> = [];
+mock.module("../../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: (
+    conversationId: string,
+    requestPayload: string,
+    responsePayload: string,
+    messageId?: string,
+    provider?: string,
+  ) => {
+    recordRequestLogCalls.push({
+      conversationId,
+      requestPayload,
+      responsePayload,
+      messageId,
+      provider,
+    });
+    return "log-id-test";
+  },
+  backfillMessageIdOnLogs: () => {},
+}));
+
 import type { AgentEvent } from "../../agent/loop.js";
 import type { Message } from "../../providers/types.js";
 import {
@@ -220,6 +247,7 @@ function makeTarget(options: {
 
 beforeEach(() => {
   __resetWakeChainForTests();
+  recordRequestLogCalls.length = 0;
   mockDiskPressureStatus = {
     enabled: false,
     state: "disabled",
@@ -1435,4 +1463,128 @@ describe("wakeAgentForOpportunity", () => {
       expect(uiBlock!.surfaceId).toBe(wakeProducedOutputCalls[0]);
     },
   );
+
+  test(
+    "silent no-op wake drops LLM request logs so a future backfillMessageIdOnLogs " +
+      "sweep cannot misattach them to an unrelated assistant reply",
+    async () => {
+      const usageEvent: AgentEvent = {
+        type: "usage",
+        inputTokens: 100,
+        outputTokens: 5,
+        model: "test-model",
+        actualProvider: "test-provider",
+        providerDurationMs: 10,
+        rawRequest: { request: "no-op wake" },
+        rawResponse: { response: "no output" },
+      };
+      const target = makeTarget({
+        baseline: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+        scriptedEvents: [usageEvent],
+        // Empty assistant text → silent no-op.
+        scriptedAssistant: {
+          role: "assistant",
+          content: [{ type: "text", text: "" }],
+        },
+      });
+
+      const result = await wakeAgentForOpportunity(
+        {
+          conversationId: target.conversationId,
+          hint: "consider doing nothing",
+          source: "unit-test",
+        },
+        { resolveTarget: async () => target },
+      );
+
+      expect(result).toEqual({ invoked: true, producedToolCalls: false });
+      // Nothing emitted, nothing persisted to the conversation.
+      expect(target.emittedEvents).toHaveLength(0);
+      expect(target.persistedTailCalls).toHaveLength(0);
+      // Critical: the LLM request log must NOT be inserted with messageId=NULL,
+      // otherwise the next user turn's backfillMessageIdOnLogs sweep would
+      // misattach this row to an unrelated future assistant reply.
+      expect(recordRequestLogCalls).toHaveLength(0);
+    },
+  );
+
+  test("wake that produces output persists buffered LLM request logs", async () => {
+    const usageEvent: AgentEvent = {
+      type: "usage",
+      inputTokens: 100,
+      outputTokens: 5,
+      model: "test-model",
+      actualProvider: "test-provider",
+      providerDurationMs: 10,
+      rawRequest: { request: "produced wake" },
+      rawResponse: { response: "real reply" },
+    };
+    const target = makeTarget({
+      baseline: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      scriptedEvents: [usageEvent],
+      scriptedAssistant: {
+        role: "assistant",
+        content: [{ type: "text", text: "real reply" }],
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "do reply",
+        source: "unit-test",
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(result).toEqual({ invoked: true, producedToolCalls: false });
+    expect(recordRequestLogCalls).toHaveLength(1);
+    expect(recordRequestLogCalls[0]).toMatchObject({
+      conversationId: target.conversationId,
+      provider: "test-provider",
+      messageId: undefined,
+    });
+  });
+
+  test("non-serializable usage payload does not abort the wake", async () => {
+    // Circular reference in rawRequest — JSON.stringify throws on this.
+    // Serialization must happen inside persistLog's try/catch so the
+    // failure is swallowed as a non-fatal log warning rather than
+    // escaping and aborting the wake.
+    const circular: Record<string, unknown> = { request: "produced wake" };
+    circular.self = circular;
+    const usageEvent: AgentEvent = {
+      type: "usage",
+      inputTokens: 100,
+      outputTokens: 5,
+      model: "test-model",
+      actualProvider: "test-provider",
+      providerDurationMs: 10,
+      rawRequest: circular,
+      rawResponse: { response: "real reply" },
+    };
+    const target = makeTarget({
+      baseline: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      scriptedEvents: [usageEvent],
+      scriptedAssistant: {
+        role: "assistant",
+        content: [{ type: "text", text: "real reply" }],
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "do reply",
+        source: "unit-test",
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(result).toEqual({ invoked: true, producedToolCalls: false });
+    // Wake still produced output even though logging failed.
+    expect(target.persistedTailCalls).toHaveLength(1);
+    // No log row was inserted because JSON.stringify threw.
+    expect(recordRequestLogCalls).toHaveLength(0);
+  });
 });