@vellumai/assistant 0.11.4 → 0.11.5-staging.2

package/src/runtime/effective-capabilities.ts

@@ -44,6 +44,31 @@ export function canActOnPrivilegedDocuments(actor: {
   );
 }
 
+/**
+ * Whether personal-memory content (memory pages, PKB, matched v3 card
+ * sections, the v2 static block) may be surfaced to an actor.
+ *
+ * The trust class decides, and nothing else. Personal memory is elevated
+ * access, and every other consumer of "no actor was bound" already fails
+ * closed for it: `FALLBACK_TURN_TRUST` is documented as low-trust and "never
+ * guardian", and the workflow resume path deliberately declines to fall back
+ * to the guardian context so a resumed run cannot gain trust it did not start
+ * with. A gate that granted memory for the same condition would contradict
+ * them.
+ *
+ * Notably this takes no channel. A surface is not an actor: arriving on the
+ * first-party console says nothing about who is asking, and an actor whose
+ * class could not be resolved fails closed to `unknown` upstream. Answering
+ * "who is this" is `resolveTrustClass`'s job -- including the local/native
+ * turns that resolve to guardian under a disabled-auth posture -- and this
+ * function only answers what that actor may see.
+ */
+export function canSeePersonalMemory(actor: {
+  trustClass: RawTrustClass;
+}): boolean {
+  return resolveCapabilities(actor.trustClass).canAccessMemory;
+}
+
 /**
  * Whether an archive-by-sender invocation is authorized. Any one of a surface
  * action, a task-batch authorization, or an explicit prompt approval suffices.

package/src/runtime/guardian-reply-router.ts

@@ -97,8 +97,12 @@ export interface GuardianReplyContext {
   channel: string;
   /** Actor identity context for the sender. */
   actor: ActorContext;
-  /** Conversation ID for this message (may be the guardian's conversation). */
-  conversationId: string;
+  /**
+   * Conversation the message arrived in (may be the guardian's own). Only the
+   * text and NL paths read it; reactions and `apr:` callbacks resolve their
+   * target by card address or embedded request id and may pass none.
+   */
+  conversationId?: string;
   /** Callback data from button presses (e.g. `apr:<requestId>:<action>`). */
   callbackData?: string;
   /**

package/src/runtime/http-errors.ts

@@ -17,6 +17,7 @@
  */
 export type HttpErrorCode =
   | "BAD_REQUEST"
+  | "CREDENTIAL_IN_USE"
   | "UNAUTHORIZED"
   | "FORBIDDEN"
   | "NOT_FOUND"

package/src/runtime/http-server.ts

@@ -27,6 +27,7 @@ import {
   isDbMigrationGateBypassed,
 } from "../daemon/daemon-readiness.js";
 import { processMessage } from "../daemon/process-message.js";
+import { makeAddrInUseError } from "../daemon/startup-error.js";
 import {
   createLiveVoiceConnection,
   type LiveVoiceConnection,
@@ -975,9 +976,14 @@ let instance: RuntimeHttpServer | null = null;
 
 /**
  * Start the runtime HTTP server singleton early in daemon startup so /healthz
- * answers ASAP. A bind failure (port in use, permission denied, fd exhaustion)
- * is non-fatal: it is logged and the daemon falls back to IPC-only operation,
- * leaving the singleton unset.
+ * answers ASAP.
+ *
+ * An occupied address (`EADDRINUSE`) aborts startup: whatever holds the port
+ * owns every HTTP client of this workspace, including the gateway proxy that
+ * fronts `/v1/*`. Continuing would leave a daemon that answers IPC (so `vellum
+ * ps` and platform status read healthy) while every proxied HTTP route 502s
+ * against a foreign listener. Any other bind failure (permission denied, fd
+ * exhaustion) is non-fatal, logged with the singleton left unset.
  */
 export async function startRuntimeHttpServer(): Promise<void> {
   const port = getRuntimeHttpPort();
@@ -992,11 +998,20 @@ export async function startRuntimeHttpServer(): Promise<void> {
       "Daemon startup: runtime HTTP server listening",
     );
   } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "EADDRINUSE") {
+      log.error(
+        { err, port, hostname },
+        "Runtime HTTP port already in use, aborting startup to avoid an HTTP-blind daemon",
+      );
+      throw makeAddrInUseError(
+        `Runtime HTTP port ${hostname}:${port} is already in use by another process. Stop it, or set RUNTIME_HTTP_PORT to a free port.`,
+        err,
+      );
+    }
     log.warn(
       { err, port },
       "Failed to start runtime HTTP server, continuing without it",
     );
-    instance = null;
   }
 }
 
@@ -1007,7 +1022,7 @@ export async function startRuntimeHttpServer(): Promise<void> {
  * expiry, profile reaping) must still run; the retry sweep additionally skips
  * its cycles while readiness is unready. Never called before migrations settle,
  * so the sweeps can't race a schema mid-migration. No-op if the HTTP server
- * failed to bind (IPC-only mode) or sweeps already started.
+ * isn't running or sweeps already started.
  */
 export function startRuntimeHttpServerBackgroundSweeps(): void {
   instance?.startBackgroundSweeps();

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

@@ -333,3 +333,153 @@ describe("report_client_presence route", () => {
     ).toBeUndefined();
   });
 });
+
+describe("report_web_presence route", () => {
+  beforeEach(() => {
+    fakeHttpAuthDisabled = false;
+    clearHubClients(assistantEventHub);
+  });
+
+  function registerWebClient(args: {
+    clientId: string;
+    actorPrincipalId?: string;
+  }): void {
+    registerHubClient({
+      hub: assistantEventHub,
+      clientId: args.clientId,
+      interfaceId: "web",
+      actorPrincipalId: args.actorPrincipalId,
+    });
+  }
+
+  test("records visibility and focused conversation against the client named by the header", () => {
+    registerWebClient({ clientId: "client-A1", actorPrincipalId: "user-A" });
+
+    const handler = findHandler("report_web_presence");
+    const result = handler({
+      headers: {
+        "x-vellum-client-id": "client-A1",
+        "x-vellum-actor-principal-id": "user-A",
+      },
+      body: { visible: true, focusedConversationId: "conv-1" },
+    }) as { recorded: boolean };
+
+    expect(result).toEqual({ recorded: true });
+    expect(
+      assistantEventHub.getClientById("client-A1")?.webPresence,
+    ).toMatchObject({
+      visible: true,
+      focusedConversationId: "conv-1",
+    });
+  });
+
+  test("accepts a null focusedConversationId", () => {
+    registerWebClient({ clientId: "client-A1", actorPrincipalId: "user-A" });
+
+    const handler = findHandler("report_web_presence");
+    const result = handler({
+      headers: {
+        "x-vellum-client-id": "client-A1",
+        "x-vellum-actor-principal-id": "user-A",
+      },
+      body: { visible: false, focusedConversationId: null },
+    }) as { recorded: boolean };
+
+    expect(result).toEqual({ recorded: true });
+    expect(
+      assistantEventHub.getClientById("client-A1")?.webPresence,
+    ).toMatchObject({
+      visible: false,
+      focusedConversationId: null,
+    });
+  });
+
+  test("returns recorded false when the reported client is not connected", () => {
+    const handler = findHandler("report_web_presence");
+    const result = handler({
+      headers: {
+        "x-vellum-client-id": "client-gone",
+        "x-vellum-actor-principal-id": "user-A",
+      },
+      body: { visible: true, focusedConversationId: "conv-1" },
+    }) as { recorded: boolean };
+
+    expect(result).toEqual({ recorded: false });
+  });
+
+  test("returns recorded false when the caller does not own the client", () => {
+    registerWebClient({ clientId: "client-A1", actorPrincipalId: "user-A" });
+
+    const handler = findHandler("report_web_presence");
+    const result = handler({
+      headers: {
+        "x-vellum-client-id": "client-A1",
+        "x-vellum-actor-principal-id": "user-B",
+      },
+      body: { visible: true, focusedConversationId: "conv-1" },
+    }) as { recorded: boolean };
+
+    expect(result).toEqual({ recorded: false });
+    expect(
+      assistantEventHub.getClientById("client-A1")?.webPresence,
+    ).toBeUndefined();
+  });
+
+  test("returns recorded false for a client with no stored actorPrincipalId", () => {
+    registerWebClient({ clientId: "client-noprincipal" });
+
+    const handler = findHandler("report_web_presence");
+    const result = handler({
+      headers: {
+        "x-vellum-client-id": "client-noprincipal",
+        "x-vellum-actor-principal-id": "user-A",
+      },
+      body: { visible: true, focusedConversationId: "conv-1" },
+    }) as { recorded: boolean };
+
+    expect(result).toEqual({ recorded: false });
+    expect(
+      assistantEventHub.getClientById("client-noprincipal")?.webPresence,
+    ).toBeUndefined();
+  });
+
+  test("dev-bypass mode records presence without an ownership check", () => {
+    fakeHttpAuthDisabled = true;
+    registerWebClient({ clientId: "client-A1", actorPrincipalId: "user-A" });
+
+    const handler = findHandler("report_web_presence");
+    const result = handler({
+      headers: {
+        "x-vellum-client-id": "client-A1",
+        "x-vellum-actor-principal-id": "user-B",
+      },
+      body: { visible: true, focusedConversationId: "conv-1" },
+    }) as { recorded: boolean };
+
+    expect(result).toEqual({ recorded: true });
+  });
+
+  test("throws BadRequestError when the client-id header is missing", () => {
+    const handler = findHandler("report_web_presence");
+
+    expect(() =>
+      handler({ body: { visible: true, focusedConversationId: "conv-1" } }),
+    ).toThrow(BadRequestError);
+  });
+
+  test("throws BadRequestError for a malformed body", () => {
+    registerWebClient({ clientId: "client-A1", actorPrincipalId: "user-A" });
+
+    const handler = findHandler("report_web_presence");
+
+    expect(() =>
+      handler({
+        headers: {
+          "x-vellum-client-id": "client-A1",
+          "x-vellum-actor-principal-id": "user-A",
+        },
+        body: { visible: "yes", focusedConversationId: "conv-1" },
+      }),
+    ).toThrow(BadRequestError);
+  });
+});

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

@@ -683,6 +683,139 @@ describe("GET /v1/conversations with needsAttention", () => {
   });
 });
 
+describe("GET /v1/conversations with foregroundOnly", () => {
+  function fileIntoGroup(conversationId: string, groupId: string): void {
+    rawRun(
+      "test:fileIntoGroup",
+      "UPDATE conversations SET group_id = ? WHERE id = ?",
+      groupId,
+      conversationId,
+    );
+  }
+
+  function surface(conversationId: string): void {
+    rawRun(
+      "test:surfaceConversation",
+      "UPDATE conversations SET surfaced_at = ? WHERE id = ?",
+      Date.now(),
+      conversationId,
+    );
+  }
+
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  test("drops the automated runs the standard listing admits through a custom group", async () => {
+    /* The standard listing shows a background run filed in a custom group,
+       so a caller reading page one to find "the newest chat" can lead with
+       one; the filter is what lets that caller ask for chats alone. A
+       surfaced run is a chat for this purpose, exactly as the unread count
+       treats it. */
+    const group = createGroup("Work");
+    createConversation("plain-chat");
+    const bgInGroup = createConversation({
+      title: "bg-in-group",
+      conversationType: "background",
+    });
+    fileIntoGroup(bgInGroup.id, group.id);
+    const surfacedBg = createConversation({
+      title: "surfaced-bg",
+      conversationType: "background",
+    });
+    surface(surfacedBg.id);
+
+    const unfiltered = await invoke();
+    expect(unfiltered.conversations.map((c) => c.title).sort()).toEqual([
+      "bg-in-group",
+      "plain-chat",
+      "surfaced-bg",
+    ]);
+
+    const result = await invoke({ foregroundOnly: "true" });
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "plain-chat",
+      "surfaced-bg",
+    ]);
+  });
+
+  test("hasMore and the total describe the filtered set, not the whole table", async () => {
+    /* The reason for the filter is a limit=1 read whose first row is the
+       answer; that read is only right if the page and its total come from
+       the same predicate. */
+    const group = createGroup("Work");
+    for (let i = 0; i < 3; i++) {
+      const bg = createConversation({
+        title: `bg-${i}`,
+        conversationType: "background",
+      });
+      fileIntoGroup(bg.id, group.id);
+    }
+    createConversation("the-only-chat");
+
+    const page = await invoke({ foregroundOnly: "true", limit: "1" });
+
+    expect(page.conversations.map((c) => c.title)).toEqual(["the-only-chat"]);
+    expect(page.hasMore).toBe(false);
+  });
+
+  test("a foreground-only first page has no pinned rows appended to it", async () => {
+    /* Same rule as the attention- and group-scoped pages: the injection is
+       for a client reading Pinned out of the unfiltered list, and a caller
+       that asked for the newest chat in one row is not that client. The
+       older pinned chat is a member of the filter, so only the injection
+       could put it on a limit=1 page. */
+    const older = createConversation("older-pinned-chat");
+    rawRun(
+      "test:pinConversation",
+      "UPDATE conversations SET is_pinned = 1, group_id = 'system:pinned', last_message_at = ? WHERE id = ?",
+      Date.now() - 60_000,
+      older.id,
+    );
+    const newer = createConversation("newest-chat");
+    rawRun(
+      "test:bumpRecency",
+      "UPDATE conversations SET last_message_at = ? WHERE id = ?",
+      Date.now(),
+      newer.id,
+    );
+
+    const unfiltered = await invoke({ limit: "1" });
+    expect(unfiltered.conversations.map((c) => c.title)).toEqual([
+      "newest-chat",
+      "older-pinned-chat",
+    ]);
+
+    const result = await invoke({ foregroundOnly: "true", limit: "1" });
+    expect(result.conversations.map((c) => c.title)).toEqual(["newest-chat"]);
+  });
+
+  test("composes with the other filters", async () => {
+    const group = createGroup("Work");
+    const chatInGroup = createConversation("chat-in-group");
+    fileIntoGroup(chatInGroup.id, group.id);
+    const bgInGroup = createConversation({
+      title: "bg-in-group",
+      conversationType: "background",
+    });
+    fileIntoGroup(bgInGroup.id, group.id);
+    createConversation("chat-outside");
+
+    const result = await invoke({
+      foregroundOnly: "true",
+      groupId: group.id,
+    });
+
+    expect(result.conversations.map((c) => c.title)).toEqual(["chat-in-group"]);
+  });
+
+  test('any value other than "true" is rejected with a 400', () => {
+    for (const bad of ["false", "1", "yes", "TRUE"]) {
+      expect(() => invoke({ foregroundOnly: bad })).toThrow(BadRequestError);
+    }
+  });
+});
+
 describe("GET /v1/conversations/unread-count", () => {
   const unreadCountHandler = findHandler(
     CONVERSATION_LIST_ROUTES,

package/src/runtime/routes/__tests__/credential-delete-in-use.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Deleting a credential an LLM connection dispatches with must be refused
+ * until the caller confirms, because losing it silently takes that connection
+ * offline: the adapter keeps routing to the provider with no key and the turn
+ * comes back empty.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getDb } from "../../../persistence/db-connection.js";
+import { initializeDb } from "../../../persistence/db-init.js";
+import { providerConnections } from "../../../persistence/schema/inference.js";
+import { createConnection } from "../../../providers/inference/connections.js";
+import { credentialKey } from "../../../security/credential-key.js";
+import {
+  deleteSecureKeyAsync,
+  getSecureKeyAsync,
+  setSecureKeyAsync,
+} from "../../../security/secure-keys.js";
+import { CredentialInUseError } from "../credential-in-use.js";
+import { ROUTES as CREDENTIAL_ROUTES } from "../credential-routes.js";
+import { ROUTES as SECRET_ROUTES } from "../secret-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+await initializeDb();
+
+const SERVICE = "agentrouter";
+const FIELD = "api_key";
+const ACCOUNT = credentialKey(SERVICE, FIELD);
+
+function findHandler(
+  routes: RouteDefinition[],
+  operationId: string,
+): RouteDefinition["handler"] {
+  const route = routes.find(
+    (candidate) => candidate.operationId === operationId,
+  );
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
+  return route.handler;
+}
+
+const deleteCredential = findHandler(CREDENTIAL_ROUTES, "credentials_delete");
+const deleteSecret = findHandler(SECRET_ROUTES, "secrets_delete");
+
+/** Run a handler and hand back whatever it rejected with, or null on success. */
+async function rejection(run: () => unknown): Promise<unknown> {
+  try {
+    await run();
+    return null;
+  } catch (error) {
+    return error;
+  }
+}
+
+/** Point an api_key connection at the credential under test. */
+function createConnectionUsing(name: string, credential: string): void {
+  const result = createConnection(getDb(), {
+    name,
+    provider: "openai",
+    auth: { type: "api_key", credential },
+  });
+  if (!result.ok) {
+    throw new Error(`Failed to create connection ${name}`);
+  }
+}
+
+beforeEach(async () => {
+  getDb().delete(providerConnections).run();
+  await deleteSecureKeyAsync(ACCOUNT);
+});
+
+describe("credential delete in-use guard", () => {
+  test("refuses a delete while a connection resolves auth through the credential", async () => {
+    // GIVEN a stored credential
+    await setSecureKeyAsync(ACCOUNT, "sk-test-value");
+
+    // AND two LLM connections that dispatch with it
+    createConnectionUsing("router-primary", `${SERVICE}:${FIELD}`);
+    createConnectionUsing("router-fallback", ACCOUNT);
+
+    // WHEN the credential is deleted without confirmation
+    const error = await rejection(() =>
+      deleteCredential({ body: { service: SERVICE, field: FIELD } }),
+    );
+
+    // THEN the delete is refused as a client error naming the connections
+    expect(error).toBeInstanceOf(CredentialInUseError);
+    const refusal = error as CredentialInUseError;
+    expect(refusal.statusCode).toBe(400);
+    expect(refusal.code).toBe("CREDENTIAL_IN_USE");
+    expect(refusal.connections).toEqual(["router-fallback", "router-primary"]);
+    expect(refusal.message).toContain("router-primary");
+
+    // AND the credential is left in place, so those connections keep working
+    expect(await getSecureKeyAsync(ACCOUNT)).toBe("sk-test-value");
+  });
+
+  test("deletes the credential when the caller confirms with force", async () => {
+    // GIVEN a stored credential a connection dispatches with
+    await setSecureKeyAsync(ACCOUNT, "sk-test-value");
+    createConnectionUsing("router-primary", `${SERVICE}:${FIELD}`);
+
+    // WHEN the delete is retried with force
+    const result = await deleteCredential({
+      body: { service: SERVICE, field: FIELD, force: true },
+    });
+
+    // THEN it succeeds and reports the connections it took offline
+    expect(result).toMatchObject({
+      service: SERVICE,
+      field: FIELD,
+      affectedConnections: ["router-primary"],
+    });
+
+    // AND the credential is gone from secure storage
+    expect(await getSecureKeyAsync(ACCOUNT)).toBeUndefined();
+  });
+
+  test("deletes an unreferenced credential without confirmation", async () => {
+    // GIVEN a stored credential no connection references
+    await setSecureKeyAsync(ACCOUNT, "sk-test-value");
+    createConnectionUsing("other-connection", "credential/openai/api_key");
+
+    // WHEN it is deleted without force
+    const result = await deleteCredential({
+      body: { service: SERVICE, field: FIELD },
+    });
+
+    // THEN the delete goes through with no affected connections
+    expect(result).toMatchObject({ affectedConnections: [] });
+    expect(await getSecureKeyAsync(ACCOUNT)).toBeUndefined();
+  });
+
+  test("guards the api-key delete surface too", async () => {
+    // GIVEN a provider API key a connection dispatches with
+    const apiKeyAccount = credentialKey("openrouter", FIELD);
+    await setSecureKeyAsync(apiKeyAccount, "sk-test-value");
+    createConnectionUsing("router-primary", apiKeyAccount);
+
+    // WHEN it is deleted through the secrets route without confirmation
+    const error = await rejection(() =>
+      deleteSecret({ body: { type: "api_key", name: "openrouter" } }),
+    );
+
+    // THEN the same refusal applies and the key survives
+    expect(error).toBeInstanceOf(CredentialInUseError);
+    expect((error as CredentialInUseError).connections).toEqual([
+      "router-primary",
+    ]);
+    expect(await getSecureKeyAsync(apiKeyAccount)).toBe("sk-test-value");
+    await deleteSecureKeyAsync(apiKeyAccount);
+  });
+});

package/src/runtime/routes/__tests__/inference-provider-connection-routes.test.ts

@@ -313,8 +313,59 @@ describe("POST inference/provider-connections (create)", () => {
           auth: { type: "none" },
         },
       },
-    )) as { auth: object };
+    )) as { auth: object; baseUrl: string | null };
+    expect(result.auth).toEqual({ type: "none" });
+    expect(result.baseUrl).toBeNull();
+  });
+
+  test("creates an ollama connection with an optional base_url", async () => {
+    const result = (await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "ollama-remote",
+          provider: "ollama",
+          auth: { type: "none" },
+          base_url: "http://192.168.1.50:11434/v1",
+        },
+      },
+    )) as { auth: object; baseUrl: string | null };
     expect(result.auth).toEqual({ type: "none" });
+    expect(result.baseUrl).toBe("http://192.168.1.50:11434/v1");
+  });
+
+  test("updates an ollama connection base_url and can clear it", async () => {
+    await call(findHandler("inference_provider_connections_create"), {
+      body: {
+        name: "ollama-editable",
+        provider: "ollama",
+        auth: { type: "none" },
+      },
+    });
+
+    const updated = (await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "ollama-editable" },
+        body: {
+          auth: { type: "none" },
+          base_url: "http://127.0.0.1:11434/v1",
+        },
+      },
+    )) as { baseUrl: string | null };
+    expect(updated.baseUrl).toBe("http://127.0.0.1:11434/v1");
+
+    const cleared = (await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "ollama-editable" },
+        body: {
+          auth: { type: "none" },
+          base_url: null,
+        },
+      },
+    )) as { baseUrl: string | null };
+    expect(cleared.baseUrl).toBeNull();
   });
 
   test("derives api_key auth from provider + credential when auth is omitted", async () => {

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

@@ -148,6 +148,7 @@ describe("monitoring_status", () => {
       memoryStat: {
         anonBytes: 4 * 1024 * 1024 * 1024,
         fileBytes: 1024 * 1024 * 1024,
+        inactiveFileBytes: 768 * 1024 * 1024,
         kernelBytes: 512 * 1024 * 1024,
         slabReclaimableBytes: 400 * 1024 * 1024,
         slabUnreclaimableBytes: 100 * 1024 * 1024,