@vellumai/assistant 0.5.5 → 0.5.7

package/src/runtime/routes/integrations/vercel.ts

@@ -0,0 +1,89 @@
+/**
+ * Route handlers for Vercel integration config endpoints.
+ *
+ * GET    /v1/integrations/vercel/config — check if a Vercel API token is stored
+ * POST   /v1/integrations/vercel/config — set or delete token (dispatched via action field)
+ * DELETE /v1/integrations/vercel/config — delete the stored Vercel API token
+ *
+ * The Swift client sends all mutations as POST with an `action` field
+ * ("set" or "delete") rather than using HTTP verbs directly.
+ */
+
+import {
+  deleteVercelConfig,
+  getVercelConfig,
+  setVercelConfig,
+} from "../../../daemon/handlers/config-vercel.js";
+import type { RouteDefinition } from "../../http-router.js";
+
+/**
+ * GET /v1/integrations/vercel/config
+ */
+export async function handleGetVercelConfig(): Promise<Response> {
+  const result = await getVercelConfig();
+  return Response.json(result);
+}
+
+/**
+ * POST /v1/integrations/vercel/config
+ *
+ * Body: { action: "set" | "delete"; apiToken?: string }
+ *
+ * The Swift client uses POST for both set and delete operations,
+ * distinguished by the `action` field.
+ */
+export async function handlePostVercelConfig(req: Request): Promise<Response> {
+  const body = (await req.json()) as {
+    action?: "get" | "set" | "delete";
+    apiToken?: string;
+  };
+
+  switch (body.action) {
+    case "delete": {
+      const result = await deleteVercelConfig();
+      return Response.json(result);
+    }
+    case "get": {
+      const result = await getVercelConfig();
+      return Response.json(result);
+    }
+    case "set":
+    default: {
+      const result = await setVercelConfig(body.apiToken);
+      const status = result.success ? 200 : 400;
+      return Response.json(result, { status });
+    }
+  }
+}
+
+/**
+ * DELETE /v1/integrations/vercel/config
+ */
+export async function handleDeleteVercelConfig(): Promise<Response> {
+  const result = await deleteVercelConfig();
+  return Response.json(result);
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export function vercelRouteDefinitions(): RouteDefinition[] {
+  return [
+    {
+      endpoint: "integrations/vercel/config",
+      method: "GET",
+      handler: () => handleGetVercelConfig(),
+    },
+    {
+      endpoint: "integrations/vercel/config",
+      method: "POST",
+      handler: async ({ req }) => handlePostVercelConfig(req),
+    },
+    {
+      endpoint: "integrations/vercel/config",
+      method: "DELETE",
+      handler: async () => handleDeleteVercelConfig(),
+    },
+  ];
+}

package/src/runtime/routes/log-export-routes.ts

@@ -37,6 +37,7 @@ import {
   getWorkspaceConfigPath,
   getWorkspaceDir,
 } from "../../util/platform.js";
+import { APP_VERSION, COMMIT_SHA } from "../../version.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
 
@@ -264,12 +265,16 @@ async function handleExport(body: ExportRequestBody): Promise<Response> {
       ? {
           type: "conversation-export" as const,
           conversationId,
+          assistantVersion: APP_VERSION,
+          commitSha: COMMIT_SHA,
           ...(startTime !== undefined ? { startTime } : {}),
           ...(endTime !== undefined ? { endTime } : {}),
           exportedAt: new Date().toISOString(),
         }
       : {
           type: "global-export" as const,
+          assistantVersion: APP_VERSION,
+          commitSha: COMMIT_SHA,
           exportedAt: new Date().toISOString(),
         };
     writeFileSync(

package/src/runtime/routes/memory-item-routes.test.ts

@@ -37,13 +37,55 @@ mock.module("../../util/logger.js", () => ({
     }),
 }));
 
-// Stub config loader
+// Stub config loader — returns a config with memory enabled by default
 mock.module("../../config/loader.js", () => ({
-  loadConfig: () => ({}),
-  getConfig: () => ({}),
+  loadConfig: () => mockConfig,
+  getConfig: () => mockConfig,
   invalidateConfigCache: () => {},
 }));
 
+// ── Controllable mocks for semantic search ─────────────────────────────
+const mockConfig: unknown = {};
+
+let mockBackendStatus: {
+  enabled: boolean;
+  provider: string | null;
+  model: string | null;
+} = { enabled: false, provider: null, model: null };
+
+const mockEmbedResult: {
+  provider: string;
+  model: string;
+  vectors: number[][];
+} = { provider: "local", model: "test", vectors: [[0.1, 0.2, 0.3]] };
+
+let mockHybridSearchResults: Array<{
+  id: string;
+  score: number;
+  payload: Record<string, unknown>;
+}> = [];
+
+mock.module("../../memory/embedding-backend.js", () => ({
+  getMemoryBackendStatus: async () => mockBackendStatus,
+  embedWithBackend: async () => mockEmbedResult,
+  generateSparseEmbedding: () => ({
+    indices: [0, 1, 2],
+    values: [0.5, 0.3, 0.2],
+  }),
+}));
+
+mock.module("../../memory/qdrant-client.js", () => ({
+  getQdrantClient: () => ({
+    hybridSearch: async () => [...mockHybridSearchResults],
+    searchWithFilter: async () => [...mockHybridSearchResults],
+  }),
+  initQdrantClient: () => {},
+}));
+
+mock.module("../../memory/qdrant-circuit-breaker.js", () => ({
+  withQdrantBreaker: async (fn: () => Promise<unknown>) => fn(),
+}));
+
 import { and, eq } from "drizzle-orm";
 
 import { getDb, initializeDb, resetDb } from "../../memory/db.js";
@@ -392,6 +434,182 @@ describe("Memory Item Routes", () => {
       const res = await handler(ctx);
       expect(res.status).toBe(400);
     });
+
+    // ── Semantic / hybrid search ──────────────────────────────────────
+
+    test("uses semantic search when embedding backend is available", async () => {
+      insertItem({
+        id: "i1",
+        kind: "preference",
+        subject: "dark mode",
+        statement: "User prefers dark mode",
+      });
+      insertItem({
+        id: "i2",
+        kind: "identity",
+        subject: "name",
+        statement: "User name is Alice",
+      });
+
+      // Enable semantic search
+      mockBackendStatus = {
+        enabled: true,
+        provider: "local",
+        model: "test",
+      };
+      // Qdrant returns i2 first (higher relevance), then i1
+      mockHybridSearchResults = [
+        {
+          id: "pt-2",
+          score: 0.95,
+          payload: { target_type: "item", target_id: "i2" },
+        },
+        {
+          id: "pt-1",
+          score: 0.7,
+          payload: { target_type: "item", target_id: "i1" },
+        },
+      ];
+
+      const ctx = makeCtx({ search: "alice" });
+      const res = await handler(ctx);
+      const body = (await res.json()) as {
+        items: Array<{ id: string }>;
+        total: number;
+      };
+
+      // Results in Qdrant relevance order (i2 first)
+      expect(body.items.length).toBe(2);
+      expect(body.items[0].id).toBe("i2");
+      expect(body.items[1].id).toBe("i1");
+      expect(body.total).toBe(2);
+
+      // Reset
+      mockBackendStatus = { enabled: false, provider: null, model: null };
+      mockHybridSearchResults = [];
+    });
+
+    test("falls back to SQL LIKE when backend is unavailable", async () => {
+      insertItem({
+        id: "i1",
+        kind: "preference",
+        subject: "dark mode",
+        statement: "User prefers dark mode",
+      });
+      insertItem({
+        id: "i2",
+        kind: "identity",
+        subject: "name",
+        statement: "User name is Alice",
+      });
+
+      // Backend unavailable
+      mockBackendStatus = { enabled: false, provider: null, model: null };
+      mockHybridSearchResults = [];
+
+      const ctx = makeCtx({ search: "dark" });
+      const res = await handler(ctx);
+      const body = (await res.json()) as {
+        items: Array<{ id: string }>;
+        total: number;
+      };
+
+      // SQL LIKE fallback finds "dark" in subject/statement
+      expect(body.total).toBe(1);
+      expect(body.items[0].id).toBe("i1");
+    });
+
+    test("semantic search respects pagination", async () => {
+      insertItem({
+        id: "i1",
+        kind: "preference",
+        subject: "s1",
+        statement: "first item",
+      });
+      insertItem({
+        id: "i2",
+        kind: "preference",
+        subject: "s2",
+        statement: "second item",
+      });
+      insertItem({
+        id: "i3",
+        kind: "preference",
+        subject: "s3",
+        statement: "third item",
+      });
+
+      mockBackendStatus = {
+        enabled: true,
+        provider: "local",
+        model: "test",
+      };
+      mockHybridSearchResults = [
+        {
+          id: "pt-1",
+          score: 0.9,
+          payload: { target_type: "item", target_id: "i1" },
+        },
+        {
+          id: "pt-2",
+          score: 0.8,
+          payload: { target_type: "item", target_id: "i2" },
+        },
+        {
+          id: "pt-3",
+          score: 0.7,
+          payload: { target_type: "item", target_id: "i3" },
+        },
+      ];
+
+      // Request page 2 (offset=1, limit=1)
+      const ctx = makeCtx({ search: "item", limit: "1", offset: "1" });
+      const res = await handler(ctx);
+      const body = (await res.json()) as {
+        items: Array<{ id: string }>;
+        total: number;
+      };
+
+      expect(body.items.length).toBe(1);
+      expect(body.items[0].id).toBe("i2"); // second by relevance
+      expect(body.total).toBe(3);
+
+      // Reset
+      mockBackendStatus = { enabled: false, provider: null, model: null };
+      mockHybridSearchResults = [];
+    });
+
+    test("falls back to SQL when semantic returns empty results", async () => {
+      insertItem({
+        id: "i1",
+        kind: "preference",
+        subject: "dark mode",
+        statement: "User prefers dark mode",
+      });
+
+      mockBackendStatus = {
+        enabled: true,
+        provider: "local",
+        model: "test",
+      };
+      // Qdrant returns nothing
+      mockHybridSearchResults = [];
+
+      const ctx = makeCtx({ search: "dark" });
+      const res = await handler(ctx);
+      const body = (await res.json()) as {
+        items: Array<{ id: string }>;
+        total: number;
+      };
+
+      // Falls through to SQL LIKE
+      expect(body.total).toBe(1);
+      expect(body.items[0].id).toBe("i1");
+
+      // Reset
+      mockBackendStatus = { enabled: false, provider: null, model: null };
+      mockHybridSearchResults = [];
+    });
   });
 
   // =========================================================================

package/src/runtime/routes/memory-item-routes.ts

@@ -11,18 +11,29 @@
 import { and, asc, count, desc, eq, inArray, like, ne, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { getConfig } from "../../config/loader.js";
 import { getDb } from "../../memory/db.js";
+import {
+  embedWithBackend,
+  generateSparseEmbedding,
+  getMemoryBackendStatus,
+} from "../../memory/embedding-backend.js";
 import { computeMemoryFingerprint } from "../../memory/fingerprint.js";
 import { enqueueMemoryJob } from "../../memory/jobs-store.js";
+import { withQdrantBreaker } from "../../memory/qdrant-circuit-breaker.js";
+import { getQdrantClient } from "../../memory/qdrant-client.js";
 import {
   conversations,
   memoryEmbeddings,
   memoryItems,
 } from "../../memory/schema.js";
+import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
 import { httpError } from "../http-errors.js";
 import type { RouteContext, RouteDefinition } from "../http-router.js";
 
+const log = getLogger("memory-item-routes");
+
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -34,6 +45,7 @@ const VALID_KINDS = [
   "decision",
   "constraint",
   "event",
+  "capability",
 ] as const;
 
 type MemoryItemKind = (typeof VALID_KINDS)[number];
@@ -116,11 +128,80 @@ function buildConversationTitleMap(
   return map;
 }
 
+// ---------------------------------------------------------------------------
+// Semantic search helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Attempt hybrid semantic search for memory items via Qdrant.
+ * Returns ordered item IDs + total count on success, or `null` when
+ * the embedding backend / Qdrant is unavailable (caller falls back to SQL).
+ */
+async function searchItemsSemantic(
+  query: string,
+  fetchLimit: number,
+  kindFilter: string | null,
+  statusFilter: string,
+): Promise<{ ids: string[]; total: number } | null> {
+  try {
+    const config = getConfig();
+    const backendStatus = await getMemoryBackendStatus(config);
+    if (!backendStatus.provider) return null;
+
+    const embedded = await embedWithBackend(config, [query]);
+    const queryVector = embedded.vectors[0];
+    if (!queryVector) return null;
+
+    const sparse = generateSparseEmbedding(query);
+    const sparseVector = { indices: sparse.indices, values: sparse.values };
+
+    // Build Qdrant filter — items only, exclude sentinel
+    const mustConditions: Array<Record<string, unknown>> = [
+      { key: "target_type", match: { value: "item" } },
+    ];
+    if (statusFilter && statusFilter !== "all") {
+      mustConditions.push({ key: "status", match: { value: statusFilter } });
+    }
+    if (kindFilter) {
+      mustConditions.push({ key: "kind", match: { value: kindFilter } });
+    }
+
+    const filter = {
+      must: mustConditions,
+      must_not: [
+        { key: "_meta", match: { value: true } },
+      ],
+    };
+
+    const qdrant = getQdrantClient();
+    const results = await withQdrantBreaker(() =>
+      qdrant.hybridSearch({
+        denseVector: queryVector,
+        sparseVector,
+        filter,
+        limit: fetchLimit,
+        prefetchLimit: fetchLimit,
+      }),
+    );
+
+    const ids = results.map((r) => r.payload.target_id);
+
+    // Use the vector search result count as the pagination total.
+    // A DB-wide COUNT would include items with no embedding yet (lagging) and
+    // items irrelevant to the search query, inflating the total and causing
+    // clients to paginate into empty pages.
+    return { ids, total: ids.length };
+  } catch (err) {
+    log.warn({ err }, "Semantic memory search failed, falling back to SQL");
+    return null;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // GET /v1/memory-items
 // ---------------------------------------------------------------------------
 
-export function handleListMemoryItems(url: URL): Response {
+export async function handleListMemoryItems(url: URL): Promise<Response> {
   const kindParam = url.searchParams.get("kind");
   const statusParam = url.searchParams.get("status") ?? "active";
   const searchParam = url.searchParams.get("search");
@@ -155,10 +236,69 @@ export function handleListMemoryItems(url: URL): Response {
 
   const db = getDb();
 
-  // Build WHERE conditions
+  // ── Semantic search path ────────────────────────────────────────────
+  // When a search query is present, try Qdrant hybrid search first.
+  // Falls back to SQL LIKE when embeddings / Qdrant are unavailable.
+  if (searchParam) {
+    const semanticResult = await searchItemsSemantic(
+      searchParam,
+      limitParam + offsetParam,
+      kindParam,
+      statusParam,
+    );
+
+    if (semanticResult && semanticResult.ids.length > 0) {
+      // Slice for pagination
+      const pageIds = semanticResult.ids.slice(
+        offsetParam,
+        offsetParam + limitParam,
+      );
+
+      if (pageIds.length === 0) {
+        return Response.json({ items: [], total: semanticResult.total });
+      }
+
+      // Re-apply the same DB-side filters used in the SQL path as defense-
+      // in-depth against stale Qdrant payloads leaking deleted/mismatched rows.
+      const hydrationConditions = [
+        inArray(memoryItems.id, pageIds),
+      ];
+      if (statusParam && statusParam !== "all") {
+        hydrationConditions.push(eq(memoryItems.status, statusParam));
+      }
+      if (kindParam) {
+        hydrationConditions.push(eq(memoryItems.kind, kindParam));
+      }
+
+      const rows = db
+        .select()
+        .from(memoryItems)
+        .where(and(...hydrationConditions))
+        .all();
+
+      // Preserve Qdrant relevance ordering
+      const idOrder = new Map(pageIds.map((id, i) => [id, i]));
+      rows.sort((a, b) => (idOrder.get(a.id) ?? 0) - (idOrder.get(b.id) ?? 0));
+
+      const titleMap = buildConversationTitleMap(
+        db,
+        rows.map((i) => i.scopeId),
+      );
+      const enrichedItems = rows.map((item) => ({
+        ...item,
+        scopeLabel: resolveScopeLabel(item.scopeId, titleMap),
+      }));
+
+      return Response.json({
+        items: enrichedItems,
+        total: semanticResult.total,
+      });
+    }
+    // semanticResult was null (Qdrant unavailable) or empty — fall through to SQL
+  }
+
+  // ── SQL path (default or fallback) ──────────────────────────────────
   const conditions = [];
-  // Hide system-managed capability memories (skill announcements) from the UI
-  conditions.push(ne(memoryItems.kind, "capability"));
   if (statusParam && statusParam !== "all") {
     conditions.push(eq(memoryItems.status, statusParam));
   }