@vellumai/assistant 0.7.0 → 0.7.2

package/src/ipc/__tests__/browser-ipc.test.ts

@@ -23,16 +23,13 @@ let mockOperationCalls: Array<{
   input: Record<string, unknown>;
   conversationId: string;
   trustClass?: string;
-  hostBrowserProxy?: unknown;
   transportInterface?: string;
 }> = [];
 
 /** When set, findConversation returns a fake conversation object. */
 let mockConversation: {
   trustContext?: { trustClass: string };
-  hostBrowserProxy?: unknown;
   transportInterface?: string;
-  hostBrowserSenderOverride?: unknown;
 } | null = null;
 
 let mockFindConversationCalls: string[] = [];
@@ -44,7 +41,6 @@ mock.module("../../browser/operations.js", () => ({
     context: {
       conversationId: string;
       trustClass?: string;
-      hostBrowserProxy?: unknown;
       transportInterface?: string;
     },
   ) => {
@@ -53,7 +49,6 @@ mock.module("../../browser/operations.js", () => ({
       input,
       conversationId: context.conversationId,
       trustClass: context.trustClass,
-      hostBrowserProxy: context.hostBrowserProxy,
       transportInterface: context.transportInterface,
     });
     return mockOperationResult;
@@ -68,9 +63,8 @@ mock.module("../../daemon/conversation-store.js", () => ({
 }));
 
 // Import after mocking — now from the shared routes location
-const { ROUTES, browserCliConversationKey } = await import(
-  "../../runtime/routes/browser-routes.js"
-);
+const { ROUTES, browserCliConversationKey } =
+  await import("../../runtime/routes/browser-routes.js");
 
 const browserExecuteHandler = ROUTES.find(
   (r) => r.operationId === "browser_execute",
@@ -190,12 +184,9 @@ describe("browser_execute route", () => {
   });
 
   test("uses live conversation context fields when found", async () => {
-    const fakeProxy = { isAvailable: () => true };
     mockConversation = {
       trustContext: { trustClass: "trusted" },
-      hostBrowserProxy: fakeProxy,
       transportInterface: "chrome-extension",
-      hostBrowserSenderOverride: { some: "sender" },
     };
 
     await callHandler({
@@ -209,7 +200,6 @@ describe("browser_execute route", () => {
     expect(mockOperationCalls[0]).toMatchObject({
       conversationId: "conv-live-456",
       trustClass: "trusted",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "chrome-extension",
     });
   });

package/src/ipc/__tests__/route-error-envelope.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Unit tests for the IPC error envelope built from `RouteError` instances.
+ *
+ * Asserts that `AssistantIpcServer.buildErrorResponse` forwards the full
+ * `RouteError` shape — including the `details` field — into the IPC response
+ * envelope so IPC clients (e.g. gateway→daemon) receive the same structured
+ * payload as HTTP clients (e.g. `version_incompatible` migration imports).
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  RouteError,
+  UnprocessableEntityError,
+} from "../../runtime/routes/errors.js";
+import { AssistantIpcServer, type IpcResponse } from "../assistant-server.js";
+
+/**
+ * `buildErrorResponse` is private; access it through an interface cast so the
+ * test exercises the actual production code path without exporting a
+ * test-only API on the server class.
+ */
+type PrivateApi = {
+  buildErrorResponse(id: string, err: unknown): IpcResponse;
+};
+
+function buildErrorResponse(err: unknown): IpcResponse {
+  const server = new AssistantIpcServer() as unknown as PrivateApi;
+  return server.buildErrorResponse("req-1", err);
+}
+
+describe("AssistantIpcServer error envelope", () => {
+  test("forwards RouteError message, statusCode, and code", () => {
+    const err = new RouteError("boom", "BOOM", 418);
+    const response = buildErrorResponse(err);
+
+    expect(response.id).toBe("req-1");
+    expect(response.error).toBe("boom");
+    expect(response.statusCode).toBe(418);
+    expect(response.errorCode).toBe("BOOM");
+    expect(response.errorDetails).toBeUndefined();
+  });
+
+  test("forwards RouteError.details into errorDetails when present", () => {
+    const details = {
+      reason: "version_incompatible" as const,
+      bundle_compat: { engineMin: "0.7.0" },
+      runtime_version: "0.6.0",
+    };
+    const err = new UnprocessableEntityError(
+      "incompatible bundle version",
+      details,
+    );
+
+    const response = buildErrorResponse(err);
+
+    expect(response.errorCode).toBe("UNPROCESSABLE_ENTITY");
+    expect(response.statusCode).toBe(422);
+    expect(response.errorDetails).toEqual(details);
+  });
+
+  test("omits errorDetails when RouteError has no details", () => {
+    const err = new UnprocessableEntityError("plain validation failure");
+
+    const response = buildErrorResponse(err);
+
+    expect(response.errorCode).toBe("UNPROCESSABLE_ENTITY");
+    // `errorDetails` must be omitted entirely (not `undefined` value) so the
+    // serialized JSON envelope stays minimal.
+    expect("errorDetails" in response).toBe(false);
+  });
+
+  test("non-RouteError errors are stringified into `error`", () => {
+    const response = buildErrorResponse(new Error("raw"));
+
+    expect(response.error).toBe("Error: raw");
+    expect(response.errorCode).toBeUndefined();
+    expect(response.errorDetails).toBeUndefined();
+  });
+});

package/src/ipc/__tests__/skill-server-bidirectional.test.ts

@@ -84,7 +84,6 @@ async function startPair(): Promise<{
     skillId: "bidir-test",
   });
   // Stub the routes the contracts client prefetches at connect-time.
-  srv.registerMethod("host.identity.getInternalAssistantId", () => "self");
   srv.registerMethod("host.identity.getAssistantName", () => null);
   srv.registerMethod("host.platform.workspaceDir", () => "/tmp/workspace");
   srv.registerMethod("host.platform.vellumRoot", () => "/tmp/vellum");

package/src/ipc/assistant-server.ts

@@ -44,7 +44,7 @@ import {
   writeStreamChunk,
   writeStreamEnd,
 } from "./ipc-framing.js";
-import { type DbProxyParams,handleDbProxy } from "./routes/db-proxy.js";
+import { type DbProxyParams, handleDbProxy } from "./routes/db-proxy.js";
 import { routeDefinitionsToIpcMethods } from "./routes/route-adapter.js";
 import { ensureSocketPathFree } from "./socket-cleanup.js";
 import { resolveIpcSocketPath } from "./socket-path.js";
@@ -70,12 +70,17 @@ export type IpcResponse = {
   statusCode?: number;
   /** Machine-readable error code (e.g. "NOT_FOUND") for RouteError instances. */
   errorCode?: string;
+  /**
+   * Structured error payload mirroring `RouteError.details` — present only
+   * when the originating `RouteError` carries a `details` field (e.g.
+   * `version_incompatible` migration imports). Mirrors the HTTP adapter's
+   * `error.details` envelope so IPC clients can recover the same
+   * machine-readable context as HTTP clients.
+   */
+  errorDetails?: unknown;
   headers?: Record<string, string>;
 };
 
-
-
-
 /**
  * Wrapper returned by route handlers that produce a streaming response.
  * The IPC server detects this and pipes the ReadableStream as chunked
@@ -95,9 +100,7 @@ export interface IpcBinaryResponse {
   headers: Record<string, string>;
 }
 
-export function isIpcStreamingResponse(
-  value: unknown,
-): value is IpcStreamingResponse {
+function isIpcStreamingResponse(value: unknown): value is IpcStreamingResponse {
   return (
     value != null &&
     typeof value === "object" &&
@@ -108,9 +111,7 @@ export function isIpcStreamingResponse(
   );
 }
 
-export function isIpcBinaryResponse(
-  value: unknown,
-): value is IpcBinaryResponse {
+function isIpcBinaryResponse(value: unknown): value is IpcBinaryResponse {
   return (
     value != null &&
     typeof value === "object" &&
@@ -143,6 +144,7 @@ export class AssistantIpcServer {
     }
 
     // ⚠️  TEMPORARY — gateway→assistant DB proxy (see ipc/routes/db-proxy.ts).
+    // This is the ONLY route defined directly here; all other routes go in ROUTES.
     // Remove once contacts/guardian-binding logic is fully migrated to the
     // gateway's own database.
     this.methods.set("db_proxy", (params) =>
@@ -280,12 +282,16 @@ export class AssistantIpcServer {
 
   private buildErrorResponse(id: string, err: unknown): IpcResponse {
     if (err instanceof RouteError) {
-      return {
+      const response: IpcResponse = {
         id,
         error: err.message,
         statusCode: err.statusCode,
         errorCode: err.code,
       };
+      if (err.details !== undefined) {
+        response.errorDetails = err.details;
+      }
+      return response;
     }
     return { id, error: String(err) };
   }

package/src/ipc/cli-client.ts

@@ -30,6 +30,16 @@ type IpcResponse = {
   id: string;
   result?: unknown;
   error?: string;
+  /** HTTP-style status code mirrored from `RouteError.statusCode`. */
+  statusCode?: number;
+  /** Machine-readable error code (e.g. "UNPROCESSABLE_ENTITY"). */
+  errorCode?: string;
+  /**
+   * Structured error payload mirroring `RouteError.details` — present only
+   * when the originating error carried a `details` field. Mirrors the HTTP
+   * adapter's `error.details` envelope.
+   */
+  errorDetails?: unknown;
 };
 
 // ---------------------------------------------------------------------------
@@ -43,6 +53,15 @@ export interface CliIpcCallResult<T = unknown> {
   ok: boolean;
   result?: T;
   error?: string;
+  /** HTTP-style status code surfaced from a daemon-side `RouteError`. */
+  statusCode?: number;
+  /** Machine-readable error code (e.g. "UNPROCESSABLE_ENTITY"). */
+  errorCode?: string;
+  /**
+   * Structured error payload mirroring `RouteError.details` — present only
+   * when the originating daemon-side error carried a `details` field.
+   */
+  errorDetails?: unknown;
 }
 
 /**
@@ -115,7 +134,19 @@ export async function cliIpcCall<T = unknown>(
             const msg = JSON.parse(line) as IpcResponse;
             if (msg.id === reqId) {
               if (msg.error) {
-                finish({ ok: false, error: msg.error });
+                finish({
+                  ok: false,
+                  error: msg.error,
+                  ...(msg.statusCode !== undefined && {
+                    statusCode: msg.statusCode,
+                  }),
+                  ...(msg.errorCode !== undefined && {
+                    errorCode: msg.errorCode,
+                  }),
+                  ...(msg.errorDetails !== undefined && {
+                    errorDetails: msg.errorDetails,
+                  }),
+                });
               } else {
                 finish({ ok: true, result: msg.result as T });
               }

package/src/ipc/routes/__tests__/memory-v2-backfill.test.ts

@@ -8,7 +8,7 @@
  * Coverage:
  *   1. method name is the public verb expected by the CLI.
  *   2. unknown params are rejected (defensive — the schema is `.strict()`).
- *   3. each of the four ops dispatches to the correct `MemoryJobType`.
+ *   3. each of the three ops dispatches to the correct `MemoryJobType`.
  *   4. `migrate` with `force: true` propagates the flag in the payload.
  *   5. `migrate` without `force` (and ops that ignore `force`) sends an
  *      empty payload — the `false` default never reaches the queue.
@@ -17,6 +17,8 @@
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import * as realJobsStore from "../../../memory/jobs-store.js";
+
 // ---------------------------------------------------------------------------
 // Module-level mock — capture every enqueue call so each test can assert the
 // route forwarded the correct (type, payload) tuple. The route file is
@@ -29,15 +31,35 @@ const enqueueCalls: Array<{
 }> = [];
 let nextJobId = 0;
 
+// Spread the real module's exports so transitive importers (e.g.
+// memory/auto-analysis-enqueue.ts pulled in via the CLI program → memory
+// indexer chain) get every named export they bind to at module-load time;
+// only `enqueueMemoryJob` is overridden so the route under test forwards
+// to the test stub. jobs-store.ts has no side-effecting top-level
+// statements, so loading it for the spread is safe.
 mock.module("../../../memory/jobs-store.js", () => ({
+  ...realJobsStore,
   enqueueMemoryJob: (type: string, payload: Record<string, unknown>) => {
     enqueueCalls.push({ type, payload });
     nextJobId += 1;
     return `test-job-${nextJobId}`;
   },
+  upsertAutoAnalysisJob: () => {},
+  upsertDebouncedJob: () => `test-debounced-${++nextJobId}`,
+  hasActiveJobOfType: () => false,
+  enqueuePruneOldLlmRequestLogsJob: () => `test-prune-${++nextJobId}`,
+  enqueuePruneOldConversationsJob: () => `test-prune-conv-${++nextJobId}`,
+  claimMemoryJobs: () => [],
+  completeMemoryJob: () => {},
+  deferMemoryJob: () => "deferred",
+  failMemoryJob: () => {},
+  resetRunningJobsToPending: () => 0,
+  failStalledJobs: () => 0,
+  getMemoryJobCounts: () => ({}),
 }));
 
-const { ROUTES: memoryV2Routes } = await import("../../../runtime/routes/memory-v2-routes.js");
+const { ROUTES: memoryV2Routes } =
+  await import("../../../runtime/routes/memory-v2-routes.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -45,7 +67,9 @@ const { ROUTES: memoryV2Routes } = await import("../../../runtime/routes/memory-
 
 type BackfillResult = { jobId: string };
 
-const backfillRoute = memoryV2Routes.find(r => r.operationId === "memory_v2_backfill")!;
+const backfillRoute = memoryV2Routes.find(
+  (r) => r.operationId === "memory_v2_backfill",
+)!;
 
 async function runRoute(
   params: Record<string, unknown>,
@@ -109,27 +133,22 @@ describe("memory_v2_backfill route", () => {
     expect(enqueueCalls).toEqual([{ type: "memory_v2_migrate", payload: {} }]);
   });
 
-  test("rebuild-edges enqueues memory_v2_rebuild_edges with empty payload", async () => {
-    await runRoute({ op: "rebuild-edges" });
+  test("rebuild-edges op is rejected (no longer supported)", async () => {
+    await expect(runRoute({ op: "rebuild-edges" })).rejects.toThrow();
+    expect(enqueueCalls).toEqual([]);
+  });
 
-    expect(enqueueCalls).toEqual([
-      { type: "memory_v2_rebuild_edges", payload: {} },
-    ]);
+  test("reembed enqueues memory_v2_reembed with empty payload", async () => {
+    await runRoute({ op: "reembed" });
+
+    expect(enqueueCalls).toEqual([{ type: "memory_v2_reembed", payload: {} }]);
   });
 
-  test("rebuild-edges ignores force flag", async () => {
+  test("reembed ignores force flag", async () => {
     // `force` only has meaning for `migrate`. For other ops we still accept
     // the field (so a single CLI flag works across all ops without
     // branching) but never forward it to the queue.
-    await runRoute({ op: "rebuild-edges", force: true });
-
-    expect(enqueueCalls).toEqual([
-      { type: "memory_v2_rebuild_edges", payload: {} },
-    ]);
-  });
-
-  test("reembed enqueues memory_v2_reembed with empty payload", async () => {
-    await runRoute({ op: "reembed" });
+    await runRoute({ op: "reembed", force: true });
 
     expect(enqueueCalls).toEqual([{ type: "memory_v2_reembed", payload: {} }]);
   });
@@ -143,8 +162,8 @@ describe("memory_v2_backfill route", () => {
   });
 
   test("returns the jobId emitted by enqueueMemoryJob", async () => {
-    const first = await runRoute({ op: "rebuild-edges" });
-    const second = await runRoute({ op: "reembed" });
+    const first = await runRoute({ op: "reembed" });
+    const second = await runRoute({ op: "activation-recompute" });
 
     expect(first.jobId).toBe("test-job-1");
     expect(second.jobId).toBe("test-job-2");

package/src/ipc/routes/route-adapter.ts

@@ -6,7 +6,7 @@
 import type { RouteDefinition } from "../../runtime/routes/types.js";
 
 function isIpcEligible(r: RouteDefinition): boolean {
-  return !r.requireGuardian && !r.isPublic && !r.requirePolicyEnforcement;
+  return !r.requireGuardian && !r.isPublic;
 }
 
 export function routeDefinitionsToIpcMethods(

package/src/ipc/routes/trust-rules.test.ts

@@ -3,9 +3,6 @@
  *
  * Covers:
  * - trust_rules_list: no params, tool filter, include_all, origin filter
- * - trust_rules_create: correct POST URL and JSON body
- * - trust_rules_update: PATCH URL, partial body, throws when id missing
- * - trust_rules_remove: DELETE URL, throws when id missing
  * - error path: non-OK gateway response surfaces body .error message
  */
 
@@ -111,98 +108,6 @@ describe("trustRuleRoutes", () => {
     });
   });
 
-  describe("trust_rules_create", () => {
-    test("POSTs to /v1/trust-rules with correct JSON body", async () => {
-      mockFetchResponse = {
-        ok: true,
-        status: 201,
-        json: async () => ({ rule: { id: "rule-1" } }),
-      };
-
-      const route = findRoute("trust_rules_create");
-      await route.handler({ body: {
-        tool: "bash",
-        pattern: "rm -rf *",
-        risk: "high",
-        description: "Dangerous remove",
-      } });
-
-      expect(capturedFetchCalls).toHaveLength(1);
-      const call = capturedFetchCalls[0];
-      expect(call.url).toBe("http://localhost:7822/v1/trust-rules");
-      expect(call.init?.method).toBe("POST");
-      expect((call.init?.headers as Record<string, string>)["Content-Type"]).toBe(
-        "application/json",
-      );
-      const body = JSON.parse(call.init?.body as string) as Record<
-        string,
-        unknown
-      >;
-      expect(body).toEqual({
-        tool: "bash",
-        pattern: "rm -rf *",
-        risk: "high",
-        description: "Dangerous remove",
-      });
-    });
-  });
-
-  describe("trust_rules_update", () => {
-    test("PATCHes /v1/trust-rules/abc-123", async () => {
-      const route = findRoute("trust_rules_update");
-      await route.handler({ body: { id: "abc-123", risk: "low", description: "Safe" } });
-
-      expect(capturedFetchCalls).toHaveLength(1);
-      const call = capturedFetchCalls[0];
-      expect(call.url).toBe("http://localhost:7822/v1/trust-rules/abc-123");
-      expect(call.init?.method).toBe("PATCH");
-    });
-
-    test("body contains only fields present in params (partial update)", async () => {
-      const route = findRoute("trust_rules_update");
-      await route.handler({ body: { id: "abc-123", risk: "low" } });
-
-      const body = JSON.parse(
-        capturedFetchCalls[0].init?.body as string,
-      ) as Record<string, unknown>;
-      expect(body.risk).toBe("low");
-      expect("description" in body).toBe(false);
-    });
-
-    test("throws when id is missing", async () => {
-      const route = findRoute("trust_rules_update");
-      await expect(
-        route.handler({ body: { risk: "low" } }),
-      ).rejects.toThrow("id is required");
-    });
-
-    test("throws when id is empty string", async () => {
-      const route = findRoute("trust_rules_update");
-      await expect(
-        route.handler({ body: { id: "", risk: "low" } }),
-      ).rejects.toThrow("id is required");
-    });
-  });
-
-  describe("trust_rules_remove", () => {
-    test("DELETEs /v1/trust-rules/abc-123", async () => {
-      const route = findRoute("trust_rules_remove");
-      await route.handler({ body: { id: "abc-123" } });
-
-      expect(capturedFetchCalls).toHaveLength(1);
-      const call = capturedFetchCalls[0];
-      expect(call.url).toBe("http://localhost:7822/v1/trust-rules/abc-123");
-      expect(call.init?.method).toBe("DELETE");
-    });
-
-    test("throws when id is missing", async () => {
-      const route = findRoute("trust_rules_remove");
-      await expect(
-        route.handler({ body: {} }),
-      ).rejects.toThrow("id is required");
-    });
-  });
-
   describe("error path", () => {
     test("non-OK response surfaces body .error message", async () => {
       mockFetchResponse = {

package/src/ipc/skill-ipc-types.ts

@@ -11,3 +11,44 @@ export type SkillIpcRoute = {
   method: string;
   handler: SkillMethodHandler;
 };
+
+// ---------------------------------------------------------------------------
+// Streaming types
+// ---------------------------------------------------------------------------
+
+export interface SkillIpcStream {
+  /** The original request id that opened this stream (used as the stream id). */
+  readonly id: string;
+  /**
+   * Send a delivery frame to the client. No-op after the stream has been
+   * closed (client disconnect, explicit close, or server shutdown).
+   */
+  send(payload: unknown): void;
+  /**
+   * Terminate the stream from the server side. Sends a final error frame to
+   * the client (if `errorMessage` is provided and the socket is still
+   * writable), invokes the handler-returned dispose, and unregisters the
+   * stream from the per-socket subscription map. Idempotent — subsequent
+   * calls are no-ops.
+   */
+  close(errorMessage?: string): void;
+  /** True until the stream has been disposed. */
+  readonly active: boolean;
+}
+
+/**
+ * Handler signature for long-lived streaming methods (e.g.
+ * `host.events.subscribe`). Runs synchronously with the opening request and
+ * returns a dispose callback that the server invokes on client disconnect,
+ * explicit close, or server shutdown.
+ */
+export type SkillIpcStreamingHandler = (
+  stream: SkillIpcStream,
+  params?: Record<string, unknown>,
+) => () => void;
+
+/** Long-lived streaming route — method name + handler function. */
+export type SkillIpcStreamingRoute = {
+  method: string;
+  handler: SkillIpcStreamingHandler;
+};