@vellumai/assistant 0.8.2 → 0.8.4

package/src/runtime/pending-interactions.ts

@@ -18,7 +18,14 @@
  * resolve the interaction.
  */
 
+import type { InteractionResolutionState } from "../daemon/message-types/messages.js";
 import type { UserDecision } from "../permissions/types.js";
+import { getLogger } from "../util/logger.js";
+import { broadcastMessage } from "./assistant-event-hub.js";
+
+const log = getLogger("pending-interactions");
+
+export type { InteractionResolutionState } from "../daemon/message-types/messages.js";
 
 export interface ConfirmationDetails {
   toolName: string;
@@ -98,17 +105,50 @@ export function register(
  * Remove and return the pending interaction for the given requestId.
  * Auto-clears the proxy timer and detaches the abort listener if present.
  * Returns undefined if no interaction is registered.
+ *
+ * Emits `interaction_resolved` on the event hub when an interaction is
+ * actually removed (no-op when the entry was already consumed by another
+ * path). Callers pass `state` to communicate the lifecycle outcome
+ * — defaults to `"cancelled"`, the safest value when the call site has
+ * no extra context.
  */
-export function resolve(requestId: string): PendingInteraction | undefined {
+export function resolve(
+  requestId: string,
+  state: InteractionResolutionState = "cancelled",
+): PendingInteraction | undefined {
   const interaction = pending.get(requestId);
-  if (interaction) {
-    pending.delete(requestId);
-    if (interaction.timer != null) clearTimeout(interaction.timer);
-    interaction.detachAbort?.();
-  }
+  if (!interaction) return undefined;
+  pending.delete(requestId);
+  if (interaction.timer != null) clearTimeout(interaction.timer);
+  interaction.detachAbort?.();
+  emitResolved(requestId, interaction, state);
   return interaction;
 }
 
+function emitResolved(
+  requestId: string,
+  interaction: PendingInteraction,
+  state: InteractionResolutionState,
+): void {
+  log.info(
+    {
+      requestId,
+      conversationId: interaction.conversationId,
+      kind: interaction.kind,
+      state,
+    },
+    "Pending interaction resolved",
+  );
+  broadcastMessage({
+    type: "interaction_resolved",
+    requestId,
+    conversationId: interaction.conversationId,
+    conversationKey: interaction.conversationId,
+    kind: interaction.kind,
+    state,
+  });
+}
+
 /**
  * Return the pending interaction without removing it.
  * Used by trust-rule endpoint which doesn't resolve the confirmation itself.
@@ -146,7 +186,10 @@ export function getByConversation(
  * /v1/host-transfer-result after completing the operation, get a 404, and the
  * proxy timer would fire with a spurious timeout error.
  */
-export function removeByConversation(conversationId: string): void {
+export function removeByConversation(
+  conversationId: string,
+  state: InteractionResolutionState = "superseded",
+): void {
   // Snapshot keys to avoid mutation-during-iteration.
   for (const [requestId, interaction] of [...pending]) {
     if (
@@ -160,7 +203,7 @@ export function removeByConversation(conversationId: string): void {
       interaction.kind !== "acp_confirmation"
     ) {
       // resolve() clears the stored timer and detaches abort listeners.
-      resolve(requestId);
+      resolve(requestId, state);
     }
   }
 }

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

@@ -0,0 +1,258 @@
+/**
+ * Asserts `listConsolidationRuns` maps background-conversation rows tagged
+ * with `source = MEMORY_V2_CONSOLIDATION_SOURCE` into the heartbeat-runs
+ * response shape, derives `status` / `finishedAt` / `durationMs` from
+ * **assistant-message presence** (not `lastMessageAt`), and clamps the
+ * `limit` query param.
+ *
+ * Synthetic-field semantics covered here:
+ *   - `id` and `conversationId` both equal the conversation row's id.
+ *   - `scheduledFor` and `startedAt` both equal `conversation.createdAt`
+ *     (no separate schedule timestamp on the row).
+ *   - `finishedAt` is the `createdAt` of the LATEST assistant message,
+ *     NOT `conversation.lastMessageAt` — the kickoff user prompt bumps
+ *     `lastMessageAt` before the agent runs, so it cannot be used as a
+ *     completion signal.
+ *   - `durationMs` is `finishedAt − startedAt` when both are present, else
+ *     null.
+ *   - `status` is `"ok"` when the conversation has at least one assistant
+ *     message (positive evidence the agent emitted output) and `"running"`
+ *     otherwise — including the case where only the kickoff user prompt
+ *     has been persisted.
+ *   - `skipReason` and `error` are always null — the conversation row
+ *     alone cannot distinguish a clean run from a mid-flight crash even
+ *     once assistant output exists.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { createConversation } from "../../../memory/conversation-crud.js";
+import { getDb } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { rawRun } from "../../../memory/raw-query.js";
+import { ROUTES } from "../consolidation-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run(`DELETE FROM messages`);
+  db.run(`DELETE FROM conversations`);
+}
+
+function findHandler(operationId: string): RouteDefinition["handler"] {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+function insertMessage(
+  conversationId: string,
+  role: string,
+  createdAt: number,
+): void {
+  rawRun(
+    "INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)",
+    `msg-${conversationId}-${role}-${createdAt}`,
+    conversationId,
+    role,
+    "x",
+    createdAt,
+  );
+}
+
+interface RunRecord {
+  id: string;
+  scheduledFor: number;
+  startedAt: number | null;
+  finishedAt: number | null;
+  durationMs: number | null;
+  status: "ok" | "running";
+  skipReason: string | null;
+  error: string | null;
+  conversationId: string | null;
+  createdAt: number;
+}
+
+interface ListRunsResponse {
+  runs: RunRecord[];
+}
+
+describe("listConsolidationRuns handler", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns only conversations sourced from memory_v2_consolidation", async () => {
+    createConversation({ title: "c1", source: "memory_v2_consolidation" });
+    createConversation({ title: "h1", source: "heartbeat" });
+    createConversation({ title: "u1", source: "user" });
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs).toHaveLength(1);
+  });
+
+  test("synthesizes status='ok' with finishedAt from latest assistant message", async () => {
+    const conv = createConversation({
+      title: "c1",
+      source: "memory_v2_consolidation",
+    });
+    rawRun(
+      "UPDATE conversations SET created_at = ? WHERE id = ?",
+      1000,
+      conv.id,
+    );
+    // Kickoff user prompt at t=1100 (bumps lastMessageAt — must NOT be
+    // mistaken for completion).
+    insertMessage(conv.id, "user", 1100);
+    // Agent's first assistant turn at t=2000.
+    insertMessage(conv.id, "assistant", 2000);
+    // Agent's final assistant turn at t=2500.
+    insertMessage(conv.id, "assistant", 2500);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs).toHaveLength(1);
+    const run = result.runs[0]!;
+    expect(run.id).toBe(conv.id);
+    expect(run.conversationId).toBe(conv.id);
+    expect(run.status).toBe("ok");
+    expect(run.scheduledFor).toBe(1000);
+    expect(run.startedAt).toBe(1000);
+    // finishedAt = createdAt of LATEST assistant message (2500), NOT
+    // the conversation's lastMessageAt (which sqlite triggers may or may
+    // not have updated here — irrelevant to this endpoint).
+    expect(run.finishedAt).toBe(2500);
+    expect(run.durationMs).toBe(1500);
+    expect(run.createdAt).toBe(1000);
+  });
+
+  test("synthesizes status='running' when conversation has no assistant message", async () => {
+    createConversation({ title: "c1", source: "memory_v2_consolidation" });
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs).toHaveLength(1);
+    const run = result.runs[0]!;
+    expect(run.status).toBe("running");
+    expect(run.finishedAt).toBeNull();
+    expect(run.durationMs).toBeNull();
+  });
+
+  test("status stays 'running' when only the kickoff user prompt exists (Codex bug regression guard)", async () => {
+    // Regression guard for the original `status from lastMessageAt`
+    // heuristic. `processMessage` persists the background kickoff prompt as
+    // a user message BEFORE the agent runs, which bumps
+    // `conversation.lastMessageAt`. A run that timed out / threw before
+    // emitting any assistant turn must still report status='running' (or
+    // an explicit failure status once one exists) — never 'ok'.
+    const conv = createConversation({
+      title: "c1",
+      source: "memory_v2_consolidation",
+    });
+    rawRun(
+      "UPDATE conversations SET created_at = ?, last_message_at = ? WHERE id = ?",
+      1000,
+      1100,
+      conv.id,
+    );
+    insertMessage(conv.id, "user", 1100);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs).toHaveLength(1);
+    const run = result.runs[0]!;
+    expect(run.status).toBe("running");
+    expect(run.finishedAt).toBeNull();
+    expect(run.durationMs).toBeNull();
+  });
+
+  test("skipReason and error are always null (not derivable from conversation row)", async () => {
+    const conv = createConversation({
+      title: "c1",
+      source: "memory_v2_consolidation",
+    });
+    insertMessage(conv.id, "assistant", 2000);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs[0]!.skipReason).toBeNull();
+    expect(result.runs[0]!.error).toBeNull();
+  });
+
+  test("orders runs by createdAt descending", async () => {
+    const a = createConversation({
+      title: "a",
+      source: "memory_v2_consolidation",
+    });
+    const b = createConversation({
+      title: "b",
+      source: "memory_v2_consolidation",
+    });
+    const c = createConversation({
+      title: "c",
+      source: "memory_v2_consolidation",
+    });
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 1000, a.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 3000, b.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 2000, c.id);
+
+    const handler = findHandler("listConsolidationRuns");
+    const result = (await handler({})) as ListRunsResponse;
+
+    expect(result.runs.map((r) => r.id)).toEqual([b.id, c.id, a.id]);
+  });
+
+  test("limit defaults to 20, clamps to [1, 100], and falls back on non-numeric input", async () => {
+    for (let i = 0; i < 5; i++) {
+      createConversation({
+        title: `c${i}`,
+        source: "memory_v2_consolidation",
+      });
+    }
+
+    const handler = findHandler("listConsolidationRuns");
+
+    // Default — all 5 returned (under the 20 default).
+    const def = (await handler({})) as ListRunsResponse;
+    expect(def.runs).toHaveLength(5);
+
+    // Explicit limit honored.
+    const lim2 = (await handler({
+      queryParams: { limit: "2" },
+    })) as ListRunsResponse;
+    expect(lim2.runs).toHaveLength(2);
+
+    // Negative clamps to 1.
+    const neg = (await handler({
+      queryParams: { limit: "-5" },
+    })) as ListRunsResponse;
+    expect(neg.runs).toHaveLength(1);
+
+    // Zero clamps to 1.
+    const zero = (await handler({
+      queryParams: { limit: "0" },
+    })) as ListRunsResponse;
+    expect(zero.runs).toHaveLength(1);
+
+    // Non-numeric falls back to the default (20 → all 5 here).
+    const bad = (await handler({
+      queryParams: { limit: "garbage" },
+    })) as ListRunsResponse;
+    expect(bad.runs).toHaveLength(5);
+  });
+});

package/src/runtime/routes/__tests__/content-source-routes.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Unit tests for content-source-routes.ts.
+ *
+ * Drives the handler function directly (bypassing the router) and mocks
+ * out node:fs writes so no real I/O occurs.
+ */
+
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module mocks — must appear before any imports of the module under test
+// ---------------------------------------------------------------------------
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+const FAKE_WORKSPACE = "/tmp/content-source-routes-test-workspace";
+
+mock.module("../../../util/platform.js", () => ({
+  getWorkspaceDir: () => FAKE_WORKSPACE,
+}));
+
+const writtenFiles = new Map<string, string>();
+
+mock.module("node:fs", () => ({
+  mkdirSync: () => {},
+  writeFileSync: (path: string, content: string) => {
+    writtenFiles.set(path, content);
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Imports after mocks
+// ---------------------------------------------------------------------------
+
+import { ROUTES } from "../content-source-routes.js";
+import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
+
+afterAll(() => {
+  mock.restore();
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findHandler(operationId: string): RouteDefinition["handler"] {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+function makeArgs(body?: Record<string, unknown>): RouteHandlerArgs {
+  return { body };
+}
+
+const handler = findHandler("content_source_set");
+
+beforeEach(() => {
+  writtenFiles.clear();
+});
+
+// ---------------------------------------------------------------------------
+// URL validation
+// ---------------------------------------------------------------------------
+
+describe("content_source_set — URL validation", () => {
+  test("https URL is accepted and sidecar written", () => {
+    const result = handler(makeArgs({ url: "https://myblog.com/posts" }));
+    expect(result).toEqual({ ok: true });
+
+    const expectedPath = `${FAKE_WORKSPACE}/data/content-source.json`;
+    expect(writtenFiles.has(expectedPath)).toBe(true);
+    const written = JSON.parse(writtenFiles.get(expectedPath)!);
+    expect(written.url).toBe("https://myblog.com/posts");
+  });
+
+  test("http URL is accepted and sidecar written", () => {
+    const result = handler(makeArgs({ url: "http://intranet.example.com" }));
+    expect(result).toEqual({ ok: true });
+  });
+
+  test("URL with leading/trailing whitespace is trimmed", () => {
+    const result = handler(makeArgs({ url: "  https://blog.example.com  " }));
+    expect(result).toEqual({ ok: true });
+
+    const expectedPath = `${FAKE_WORKSPACE}/data/content-source.json`;
+    const written = JSON.parse(writtenFiles.get(expectedPath)!);
+    expect(written.url).toBe("https://blog.example.com/");
+  });
+
+  test("bare hostname without protocol returns invalid_url", () => {
+    const result = handler(makeArgs({ url: "myblog.com" }));
+    expect(result).toEqual({ ok: false, error: "invalid_url" });
+    expect(writtenFiles.size).toBe(0);
+  });
+
+  test("ftp:// URL is rejected", () => {
+    const result = handler(makeArgs({ url: "ftp://files.example.com" }));
+    expect(result).toEqual({ ok: false, error: "invalid_url" });
+    expect(writtenFiles.size).toBe(0);
+  });
+
+  test("empty string returns invalid_url", () => {
+    const result = handler(makeArgs({ url: "" }));
+    expect(result).toEqual({ ok: false, error: "invalid_url" });
+    expect(writtenFiles.size).toBe(0);
+  });
+
+  test("whitespace-only string returns invalid_url", () => {
+    const result = handler(makeArgs({ url: "   " }));
+    expect(result).toEqual({ ok: false, error: "invalid_url" });
+    expect(writtenFiles.size).toBe(0);
+  });
+
+  test("javascript: URL is rejected", () => {
+    const result = handler(makeArgs({ url: "javascript:alert(1)" }));
+    expect(result).toEqual({ ok: false, error: "invalid_url" });
+    expect(writtenFiles.size).toBe(0);
+  });
+
+  test("missing url field returns invalid_url", () => {
+    const result = handler(makeArgs({}));
+    expect(result).toEqual({ ok: false, error: "invalid_url" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sidecar content verification
+// ---------------------------------------------------------------------------
+
+describe("content_source_set — sidecar contents", () => {
+  test("writes url to data/content-source.json", () => {
+    handler(makeArgs({ url: "https://example.com/blog" }));
+
+    const expectedPath = `${FAKE_WORKSPACE}/data/content-source.json`;
+    expect(writtenFiles.has(expectedPath)).toBe(true);
+
+    const written = JSON.parse(writtenFiles.get(expectedPath)!);
+    expect(Object.keys(written)).toEqual(["url"]);
+  });
+
+  test("no sidecar written on invalid URL", () => {
+    handler(makeArgs({ url: "not-a-url" }));
+    expect(writtenFiles.size).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Policy key verification
+// ---------------------------------------------------------------------------
+
+describe("route policy key", () => {
+  test("content_source_set uses policyKey: secrets", () => {
+    const route = ROUTES.find((r) => r.operationId === "content_source_set");
+    expect(route?.policyKey).toBe("secrets");
+  });
+});

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

@@ -71,6 +71,10 @@ import {
   memoryV2ActivationLogs,
   messages,
 } from "../../../memory/schema.js";
+import {
+  createConnection,
+  getConnection,
+} from "../../../providers/inference/connections.js";
 import { ROUTES } from "../conversation-query-routes.js";
 
 // Local subset: this test only exercises a single concept row.
@@ -137,7 +141,11 @@ function seedConversationAndMessage(args: {
     .run();
 }
 
-function seedRequestLog(messageId: string, id: string): void {
+function seedRequestLog(
+  messageId: string,
+  id: string,
+  options: { agentLoopExitReason?: string | null } = {},
+): void {
   getDb()
     .insert(llmRequestLogs)
     .values({
@@ -150,6 +158,9 @@ function seedRequestLog(messageId: string, id: string): void {
         choices: [{ message: { content: "hi" } }],
       }),
       createdAt: 1_700_000_000_000,
+      ...(options.agentLoopExitReason != null
+        ? { agentLoopExitReason: options.agentLoopExitReason }
+        : {}),
     })
     .run();
 }
@@ -313,6 +324,53 @@ describe("GET /v1/messages/:id/llm-context — conversationTotalEstimatedCostUsd
   });
 });
 
+describe("GET /v1/messages/:id/llm-context — agentLoopExitReason", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("surfaces the stamped agent_loop_exit_reason on the terminal log", async () => {
+    const messageId = "msg-with-exit";
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId,
+      source: "user",
+      conversationType: "standard",
+    });
+    // Two logs in the same turn — only the terminal one is stamped.
+    seedRequestLog(messageId, "log-non-terminal");
+    seedRequestLog(messageId, "log-terminal", {
+      agentLoopExitReason: "no_tool_calls",
+    });
+
+    const body = (await dispatchLlmContext(messageId)) as {
+      logs: Array<{ id: string; agentLoopExitReason: string | null }>;
+    };
+
+    const byId = new Map(body.logs.map((l) => [l.id, l.agentLoopExitReason]));
+    expect(byId.get("log-non-terminal")).toBeNull();
+    expect(byId.get("log-terminal")).toBe("no_tool_calls");
+  });
+
+  test("returns null when no log in the turn has been stamped", async () => {
+    const messageId = "msg-no-exit";
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId,
+      source: "user",
+      conversationType: "standard",
+    });
+    seedRequestLog(messageId, "log-unstamped");
+
+    const body = (await dispatchLlmContext(messageId)) as {
+      logs: Array<{ id: string; agentLoopExitReason: string | null }>;
+    };
+
+    expect(body.logs).toHaveLength(1);
+    expect(body.logs[0]!.agentLoopExitReason).toBeNull();
+  });
+});
+
 describe("PUT /v1/config/llm/profiles/:name", () => {
   beforeEach(() => {
     savedRawConfig = null;
@@ -427,7 +485,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     expect(savedProfile.provider_connection).toBe("personal-openai");
   });
 
-  test("clears provider_connection when omitted from body (UI-owned key)", async () => {
+  test("auto-derives provider_connection when omitted from body (Any active)", async () => {
     // Seed an existing binding so the test starts from a non-empty state.
     (
       rawConfigFixture.llm as {
@@ -441,8 +499,37 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
         provider: "openai",
         model: "gpt-5.5",
         // provider_connection deliberately omitted — the UI cleared the
-        // picker back to "Any active" and the route must wipe the saved
-        // binding, not silently round-trip it.
+        // picker back to "Any active". The route auto-derives an active
+        // connection for the provider to prevent stale inheritance during
+        // config deep-merge.
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const savedProfile = (
+      savedRawConfig?.llm as {
+        profiles: Record<string, Record<string, unknown>>;
+      }
+    ).profiles.custom;
+
+    // The canonical "openai-managed" connection exists in the test DB;
+    // the route auto-derives it when the UI omits provider_connection.
+    expect(savedProfile.provider_connection).toBe("openai-managed");
+  });
+
+  test("auto-derives provider_connection for BYOK provider (Any active)", async () => {
+    // Seed a fireworks connection in the DB.
+    createConnection(getDb(), {
+      name: "fireworks",
+      provider: "fireworks",
+      auth: { type: "api_key", credential: "fireworks:api_key" },
+    });
+
+    const result = await replaceProfileRoute.handler({
+      pathParams: { name: "custom" },
+      body: {
+        provider: "fireworks",
+        model: "accounts/fireworks/models/llama-v3p1-8b-instruct",
       },
     });
 
@@ -453,7 +540,36 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
       }
     ).profiles.custom;
 
-    expect(savedProfile.provider_connection).toBeUndefined();
+    expect(savedProfile.provider).toBe("fireworks");
+    expect(savedProfile.provider_connection).toBe("fireworks");
+  });
+
+  test("auto-creates provider_connection when no connection exists for provider", async () => {
+    const result = await replaceProfileRoute.handler({
+      pathParams: { name: "custom" },
+      body: {
+        provider: "openrouter",
+        model: "anthropic/claude-sonnet-4-6",
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const savedProfile = (
+      savedRawConfig?.llm as {
+        profiles: Record<string, Record<string, unknown>>;
+      }
+    ).profiles.custom;
+
+    expect(savedProfile.provider).toBe("openrouter");
+    expect(savedProfile.provider_connection).toBe("openrouter-personal");
+
+    const conn = getConnection(getDb(), "openrouter-personal");
+    expect(conn).not.toBeNull();
+    expect(conn!.provider).toBe("openrouter");
+    expect(conn!.auth).toEqual({
+      type: "api_key",
+      credential: "credential/openrouter/api_key",
+    });
   });
 
   describe("managed profile guard", () => {