@vellumai/assistant 0.8.1 → 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);
 }
 
@@ -482,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/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);
+  });
 });

package/src/runtime/agent-wake.ts

@@ -330,7 +330,7 @@ function classifyWakeDiskPressurePolicy(opts: WakeOptions): {
   const status = getDiskPressureStatus();
   const decision = classifyDiskPressureTurnPolicy(status, {
     conversationSource: opts.source,
-    callSite: "mainAgent",
+    callSite: opts.callSite ?? "mainAgent",
     isDirectWake: true,
     sourceChannel: opts.sourceChannel ?? opts.trustContext?.sourceChannel,
     sourceInterface: opts.sourceInterface,
@@ -537,6 +537,33 @@ export async function wakeAgentForOpportunity(
     // only after `agentLoop.run()` returns.
     let mode: "buffering" | "live" = "buffering";
     const buffered: AgentEvent[] = [];
+    // LLM request logs accumulated while buffering. Persisted only if the
+    // wake transitions to live (i.e. produced output). A silent no-op wake
+    // drops them — otherwise the next user-turn's `backfillMessageIdOnLogs`
+    // sweep would misattach these NULL-messageId rows to an unrelated
+    // future assistant message, contaminating inspector context.
+    type PendingLog = {
+      rawRequest: unknown;
+      rawResponse: unknown;
+      provider?: string;
+    };
+    const pendingLogs: PendingLog[] = [];
+    const persistLog = (record: PendingLog): void => {
+      try {
+        recordRequestLog(
+          conversationId,
+          JSON.stringify(record.rawRequest),
+          JSON.stringify(record.rawResponse),
+          undefined,
+          record.provider,
+        );
+      } catch (err) {
+        log.warn(
+          { err, conversationId, source },
+          "agent-wake: failed to persist LLM request log (non-fatal)",
+        );
+      }
+    };
     const safeEmit = (event: AgentEvent): void => {
       try {
         target.emitAgentEvent(event);
@@ -550,20 +577,17 @@ export async function wakeAgentForOpportunity(
     const onEvent = (event: AgentEvent): void => {
       // Replicates the recordRequestLog side-effect in `handleUsage` because
       // wakes own their own onEvent and never reach `dispatchAgentEvent`.
+      // Defer persistence while buffering — see `pendingLogs` above.
       if (event.type === "usage" && event.rawRequest && event.rawResponse) {
-        try {
-          recordRequestLog(
-            conversationId,
-            JSON.stringify(event.rawRequest),
-            JSON.stringify(event.rawResponse),
-            undefined,
-            event.actualProvider,
-          );
-        } catch (err) {
-          log.warn(
-            { err, conversationId, source },
-            "agent-wake: failed to persist LLM request log (non-fatal)",
-          );
+        const record = {
+          rawRequest: event.rawRequest,
+          rawResponse: event.rawResponse,
+          provider: event.actualProvider,
+        };
+        if (mode === "buffering") {
+          pendingLogs.push(record);
+        } else {
+          persistLog(record);
         }
       }
       if (mode === "buffering") {
@@ -620,6 +644,10 @@ export async function wakeAgentForOpportunity(
         safeEmit(event);
       }
       buffered.length = 0;
+      for (const record of pendingLogs) {
+        persistLog(record);
+      }
+      pendingLogs.length = 0;
       mode = "live";
     };
 

package/src/runtime/auth/route-policy.ts

@@ -164,6 +164,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "confirm", scopes: ["approval.write"] },
   { endpoint: "secret", scopes: ["approval.write"] },
   { endpoint: "trust-rules", scopes: ["approval.write"] },
+  { endpoint: "question-response", scopes: ["approval.write"] },
   { endpoint: "host-app-control-result", scopes: ["approval.write"] },
   { endpoint: "host-bash-result", scopes: ["approval.write"] },
   { endpoint: "host-browser-result", scopes: ["approval.write"] },
@@ -285,7 +286,8 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "slack/channels", scopes: ["settings.read"] },
   { endpoint: "slack/share", scopes: ["settings.write"] },
 
-  // Channel readiness
+  // Channel availability + readiness
+  { endpoint: "channels/available", scopes: ["settings.read"] },
   { endpoint: "channels/readiness", scopes: ["settings.read"] },
   { endpoint: "channels/readiness/refresh", scopes: ["settings.write"] },
 
@@ -342,6 +344,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
 
   // Lifecycle telemetry
   { endpoint: "telemetry/lifecycle", scopes: ["settings.write"] },
+  { endpoint: "telemetry/flush", scopes: ["settings.write"] },
 
   // Debug / introspection
   { endpoint: "clients", scopes: ["settings.read"] },
@@ -1079,6 +1082,10 @@ registerPolicy("oauth/mode.set", {
   requiredScopes: ["settings.write"],
   allowedPrincipalTypes: ["local"],
 });
+registerPolicy("oauth/connection-changed", {
+  requiredScopes: ["settings.write"],
+  allowedPrincipalTypes: ["local"],
+});
 registerPolicy("oauth/status", {
   requiredScopes: ["settings.read"],
   allowedPrincipalTypes: ["local"],

package/src/runtime/btw-sidechain.ts

@@ -70,6 +70,8 @@ export async function runBtwSidechain(
   const tools = params.tools;
   const history = params.messages ?? params.conversation?.getMessages() ?? [];
   const messages = [...history, userMessage(trimmedContent)];
+  // Side-chains force `tool_choice: { type: "none" }` below, so tool usage
+  // guidance must stay in tool descriptions rather than this system prompt.
   const systemPrompt =
     params.systemPrompt ??
     (params.conversation?.hasSystemPromptOverride

package/src/runtime/http-types.ts

@@ -115,6 +115,11 @@ export interface RuntimeMessageConversationOptions {
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   /** Slack-only non-persisted notice injected into the active model turn. */
   slackRuntimeContextNotice?: string;
+  /**
+   * Persisted user-facing content. When present, storage/UI use this value
+   * while the model-facing turn continues to use `content`.
+   */
+  displayContent?: string;
   /** Optional callback to receive real-time agent loop events (text deltas, tool starts, etc.). */
   onEvent?: (msg: ServerMessage) => void;
   /**
@@ -227,5 +232,19 @@ export interface RuntimeMessagePayload {
     status: string;
     error?: string;
     conversationId?: string;
+    objective?: string;
+  };
+  slackMessage?: {
+    channelId: string;
+    channelTs: string;
+    threadTs?: string;
+    messageLink?: {
+      appUrl?: string;
+      webUrl?: string;
+    };
+    threadLink?: {
+      appUrl?: string;
+      webUrl?: string;
+    };
   };
 }

package/src/runtime/migrations/origin-mode.ts

@@ -14,7 +14,7 @@
  * combination logic.
  */
 
-import { hasManagedProxyPrereqs } from "../../providers/managed-proxy/context.js";
+import { hasManagedProxyPrereqs } from "../../providers/platform-proxy/context.js";
 import { getDaemonRuntimeMode } from "../runtime-mode.js";
 
 export type VBundleOriginMode =

package/src/runtime/pending-interactions.ts

@@ -47,6 +47,7 @@ export interface PendingInteraction {
   kind:
     | "confirmation"
     | "secret"
+    | "question"
     | "host_bash"
     | "host_file"
     | "host_cu"

package/src/runtime/routes/__tests__/bookmark-routes.test.ts

@@ -241,6 +241,23 @@ describe("bookmark routes", () => {
     ).toBe("msg-6");
   });
 
+  test("duplicate POSTs only broadcast one bookmark.created event", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-dup",
+      messageId: "msg-dup",
+    });
+
+    await call(createHandler, {
+      body: { messageId: "msg-dup", conversationId: "conv-dup" },
+    });
+    await call(createHandler, {
+      body: { messageId: "msg-dup", conversationId: "conv-dup" },
+    });
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(publishedTypes()).toEqual(["bookmark.created"]);
+  });
+
   test("DELETE on a non-existent messageId does not publish", async () => {
     await call(deleteByMessageHandler, {
       pathParams: { messageId: "does-not-exist" },

package/src/runtime/routes/__tests__/conversation-management-routes.test.ts

@@ -23,6 +23,7 @@ mock.module("../../assistant-event-hub.js", () => ({
     publish: async () => {},
     subscribe: () => () => {},
   },
+  broadcastMessage: () => {},
 }));
 
 import { getDb } from "../../../memory/db-connection.js";
@@ -114,7 +115,10 @@ function seedConversation(id: string): void {
 describe("PUT /v1/conversations/:id/inference-profile", () => {
   beforeEach(() => {
     clearConversations();
-    configLlmProfiles = { fast: { model: "model-a" }, slow: { model: "model-b" } };
+    configLlmProfiles = {
+      fast: { model: "model-a" },
+      slow: { model: "model-b" },
+    };
   });
 
   test("PUT with ttlSeconds=600 → response includes sessionId (UUID), expiresAt, ttlSeconds=600", async () => {