@vellumai/assistant 0.7.3 → 0.8.1

package/src/runtime/routes/__tests__/connection-routes-vs-cli-parity.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Cutover-proof parity test: CLI create vs HTTP route create.
+ *
+ * Runs a CLI `createConnection` call and an HTTP-route `handleCreateConnection`
+ * call with the same payload, then asserts the resulting DB rows are identical
+ * (after normalizing timestamps). This proves the HTTP route wraps the same
+ * store path the CLI uses — no divergent code path.
+ *
+ * Rule: cc-cutover-proof (see PR_B_TASK.md).
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Module mocks (must come before imports) ──────────────────────────────────
+
+mock.module("../../../config/loader.js", () => ({
+  getConfigReadOnly: () => ({}),
+  getConfig: () => ({}),
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+// ── Real imports ──────────────────────────────────────────────────────────────
+
+import { getDb } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { providerConnections } from "../../../memory/schema/inference.js";
+import { createConnection, getConnection } from "../../../providers/inference/connections.js";
+import { ROUTES } from "../inference-provider-connection-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+// ── DB bootstrap ──────────────────────────────────────────────────────────────
+
+initializeDb();
+
+// ── 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 clearConnections(): void {
+  getDb().delete(providerConnections).run();
+}
+
+function normalizeTimestamps<T extends object>(obj: T): Omit<T, "createdAt" | "updatedAt"> {
+  const { createdAt: _c, updatedAt: _u, ...rest } = obj as T & { createdAt?: unknown; updatedAt?: unknown };
+  return rest as Omit<T, "createdAt" | "updatedAt">;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  clearConnections();
+});
+
+describe("CLI vs HTTP route parity", () => {
+  test("api_key connection: CLI createConnection and HTTP POST produce identical DB rows", async () => {
+    const payload = {
+      name: "parity-anthropic",
+      provider: "anthropic" as const,
+      auth: { type: "api_key" as const, credential: "vault/anthropic/key" },
+    };
+
+    // ── CLI path ──────────────────────────────────────────────────────────────
+    const cliResult = createConnection(getDb(), payload);
+    expect(cliResult.ok).toBe(true);
+    if (!cliResult.ok) throw new Error("CLI create failed");
+    const cliRow = getConnection(getDb(), payload.name);
+    expect(cliRow).not.toBeNull();
+
+    // Clean up CLI row before HTTP create so names don't collide.
+    clearConnections();
+
+    // ── HTTP route path ───────────────────────────────────────────────────────
+    const httpResult = (await findHandler("inference_provider_connections_create")({
+      body: {
+        name: payload.name,
+        provider: payload.provider,
+        auth: payload.auth,
+      },
+    })) as { name: string; provider: string; auth: object };
+
+    expect(httpResult.name).toBe(payload.name);
+    const httpRow = getConnection(getDb(), payload.name);
+    expect(httpRow).not.toBeNull();
+
+    // ── Compare ───────────────────────────────────────────────────────────────
+    // Both rows should have identical non-timestamp fields.
+    expect(normalizeTimestamps(httpRow!)).toEqual(normalizeTimestamps(cliRow!));
+  });
+
+  test("platform connection: CLI createConnection and HTTP POST produce identical DB rows", async () => {
+    const payload = {
+      name: "parity-openai-managed",
+      provider: "openai" as const,
+      auth: { type: "platform" as const },
+    };
+
+    const cliResult = createConnection(getDb(), payload);
+    expect(cliResult.ok).toBe(true);
+    if (!cliResult.ok) throw new Error("CLI create failed");
+    const cliRow = getConnection(getDb(), payload.name);
+
+    clearConnections();
+
+    await findHandler("inference_provider_connections_create")({
+      body: { name: payload.name, provider: payload.provider, auth: payload.auth },
+    });
+    const httpRow = getConnection(getDb(), payload.name);
+
+    expect(normalizeTimestamps(httpRow!)).toEqual(normalizeTimestamps(cliRow!));
+  });
+
+  test("none auth connection: CLI createConnection and HTTP POST produce identical DB rows", async () => {
+    const payload = {
+      name: "parity-ollama",
+      provider: "ollama" as const,
+      auth: { type: "none" as const },
+    };
+
+    const cliResult = createConnection(getDb(), payload);
+    expect(cliResult.ok).toBe(true);
+    if (!cliResult.ok) throw new Error("CLI create failed");
+    const cliRow = getConnection(getDb(), payload.name);
+
+    clearConnections();
+
+    await findHandler("inference_provider_connections_create")({
+      body: { name: payload.name, provider: payload.provider, auth: payload.auth },
+    });
+    const httpRow = getConnection(getDb(), payload.name);
+
+    expect(normalizeTimestamps(httpRow!)).toEqual(normalizeTimestamps(cliRow!));
+  });
+});

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

@@ -0,0 +1,315 @@
+/**
+ * Tests for inference-profile route handlers.
+ *
+ * Exercises:
+ *  - PUT /v1/conversations/:id/inference-profile (extended with ttlSeconds/sessionId)
+ *  - POST /v1/conversations/inference-profile-session (inference_profile_open)
+ *  - GET  /v1/conversations/inference-profile-sessions (inference_profile_list)
+ *  - POST /v1/conversations/inference-profile-session/close (inference_profile_close)
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Stub the event hub to avoid spinning up real SSE infrastructure.
+mock.module("../../assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    publish: async () => {},
+    subscribe: () => () => {},
+  },
+}));
+
+import { getDb } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { conversations } from "../../../memory/schema.js";
+import { ROUTES as CONVERSATION_MANAGEMENT_ROUTES } from "../conversation-management-routes.js";
+import { ROUTES as INFERENCE_PROFILE_SESSION_ROUTES } from "../inference-profile-session-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+// ---------------------------------------------------------------------------
+// DB bootstrap
+// ---------------------------------------------------------------------------
+
+initializeDb();
+
+// ---------------------------------------------------------------------------
+// Config fixture — must expose at least one profile so the handler can
+// validate profile names.
+// ---------------------------------------------------------------------------
+
+let configLlmProfiles: Record<string, unknown> = {};
+
+mock.module("../../../config/loader.js", () => ({
+  loadConfig: () => ({
+    llm: {
+      profiles: configLlmProfiles,
+      profileSession: { maxTtlSeconds: 43200 },
+    },
+  }),
+  getConfig: () => ({
+    llm: {
+      profiles: configLlmProfiles,
+      profileSession: { maxTtlSeconds: 43200 },
+    },
+  }),
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findHandler(routes: RouteDefinition[], operationId: string) {
+  const route = routes.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+const putHandler = findHandler(
+  CONVERSATION_MANAGEMENT_ROUTES,
+  "setConversationInferenceProfile",
+);
+const openHandler = findHandler(
+  INFERENCE_PROFILE_SESSION_ROUTES,
+  "inference_profile_open",
+);
+const listHandler = findHandler(
+  INFERENCE_PROFILE_SESSION_ROUTES,
+  "inference_profile_list",
+);
+const closeHandler = findHandler(
+  INFERENCE_PROFILE_SESSION_ROUTES,
+  "inference_profile_close",
+);
+
+function clearConversations(): void {
+  getDb().delete(conversations).run();
+}
+
+function seedConversation(id: string): void {
+  const now = Date.now();
+  getDb()
+    .insert(conversations)
+    .values({
+      id,
+      title: "Test conversation",
+      createdAt: now,
+      updatedAt: now,
+      source: "test",
+      conversationType: "standard",
+      memoryScopeId: "default",
+    })
+    .run();
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("PUT /v1/conversations/:id/inference-profile", () => {
+  beforeEach(() => {
+    clearConversations();
+    configLlmProfiles = { fast: { model: "model-a" }, slow: { model: "model-b" } };
+  });
+
+  test("PUT with ttlSeconds=600 → response includes sessionId (UUID), expiresAt, ttlSeconds=600", async () => {
+    const convId = crypto.randomUUID();
+    seedConversation(convId);
+
+    const result = (await putHandler({
+      pathParams: { id: convId },
+      body: { profile: "fast", ttlSeconds: 600 },
+    })) as {
+      conversationId: string;
+      profile: string;
+      sessionId: string | null;
+      expiresAt: number | null;
+      ttlSeconds: number | null;
+      replaced: unknown;
+    };
+
+    expect(result.conversationId).toBe(convId);
+    expect(result.profile).toBe("fast");
+    expect(result.sessionId).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
+    );
+    expect(result.expiresAt).toBeGreaterThan(Date.now());
+    expect(result.ttlSeconds).toBe(600);
+    expect(result.replaced).toBeNull();
+  });
+
+  test("PUT without ttlSeconds → sessionId=null, expiresAt=null (backwards-compatible sticky)", async () => {
+    const convId = crypto.randomUUID();
+    seedConversation(convId);
+
+    const result = (await putHandler({
+      pathParams: { id: convId },
+      body: { profile: "fast" },
+    })) as {
+      conversationId: string;
+      profile: string;
+      sessionId: string | null;
+      expiresAt: number | null;
+      ttlSeconds: unknown;
+    };
+
+    expect(result.conversationId).toBe(convId);
+    expect(result.profile).toBe("fast");
+    expect(result.sessionId).toBeNull();
+    expect(result.expiresAt).toBeNull();
+  });
+
+  test("PUT profile=A then PUT profile=B with ttlSeconds=600 → second response has replaced: { profile: A, sessionId, expiresAt }", async () => {
+    const convId = crypto.randomUUID();
+    seedConversation(convId);
+
+    // First PUT — session-backed A
+    const first = (await putHandler({
+      pathParams: { id: convId },
+      body: { profile: "fast", ttlSeconds: 300 },
+    })) as { sessionId: string | null };
+
+    const firstSessionId = first.sessionId;
+    expect(firstSessionId).toBeTruthy();
+
+    // Second PUT — session-backed B
+    const second = (await putHandler({
+      pathParams: { id: convId },
+      body: { profile: "slow", ttlSeconds: 600 },
+    })) as {
+      profile: string;
+      sessionId: string | null;
+      replaced: {
+        profile: string | null;
+        sessionId: string | null;
+        expiresAt: number | null;
+      } | null;
+    };
+
+    expect(second.profile).toBe("slow");
+    expect(second.replaced).not.toBeNull();
+    expect(second.replaced!.profile).toBe("fast");
+    expect(second.replaced!.sessionId).toBe(firstSessionId);
+    expect(second.replaced!.expiresAt).toBeGreaterThan(0);
+  });
+});
+
+describe("POST /v1/conversations/inference-profile-session (inference_profile_open)", () => {
+  beforeEach(() => {
+    clearConversations();
+    configLlmProfiles = { fast: { model: "model-a" } };
+  });
+
+  test("POST with ttlSeconds=600 → same shape as PUT: sessionId UUID, expiresAt, ttlSeconds=600", async () => {
+    const convId = crypto.randomUUID();
+    seedConversation(convId);
+
+    const result = (await openHandler({
+      body: { conversationId: convId, profile: "fast", ttlSeconds: 600 },
+    })) as {
+      conversationId: string;
+      profile: string;
+      sessionId: string | null;
+      expiresAt: number | null;
+      ttlSeconds: number | null;
+      replaced: unknown;
+    };
+
+    expect(result.conversationId).toBe(convId);
+    expect(result.profile).toBe("fast");
+    expect(result.sessionId).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
+    );
+    expect(result.expiresAt).toBeGreaterThan(Date.now());
+    expect(result.ttlSeconds).toBe(600);
+    expect(result.replaced).toBeNull();
+  });
+});
+
+describe("GET /v1/conversations/inference-profile-sessions (inference_profile_list)", () => {
+  beforeEach(() => {
+    clearConversations();
+    configLlmProfiles = { fast: { model: "model-a" } };
+  });
+
+  test("GET inference-profile-sessions → returns sessions array with remainingSeconds", async () => {
+    const convId = crypto.randomUUID();
+    seedConversation(convId);
+
+    // Open a session
+    await openHandler({
+      body: { conversationId: convId, profile: "fast", ttlSeconds: 600 },
+    });
+
+    const result = (await listHandler({ queryParams: {} })) as {
+      sessions: Array<{
+        conversationId: string;
+        profile: string;
+        sessionId: string;
+        expiresAt: number;
+        remainingSeconds: number;
+      }>;
+    };
+
+    expect(result.sessions).toHaveLength(1);
+    const session = result.sessions[0]!;
+    expect(session.conversationId).toBe(convId);
+    expect(session.profile).toBe("fast");
+    expect(typeof session.sessionId).toBe("string");
+    expect(session.remainingSeconds).toBeGreaterThan(0);
+    expect(session.remainingSeconds).toBeLessThanOrEqual(600);
+  });
+});
+
+describe("POST /v1/conversations/inference-profile-session/close (inference_profile_close)", () => {
+  beforeEach(() => {
+    clearConversations();
+    configLlmProfiles = { fast: { model: "model-a" } };
+  });
+
+  test("POST inference_profile_close → { noop: false, closed: { profile, sessionId } } after an open", async () => {
+    const convId = crypto.randomUUID();
+    seedConversation(convId);
+
+    // Open a session first
+    const opened = (await openHandler({
+      body: { conversationId: convId, profile: "fast", ttlSeconds: 600 },
+    })) as { sessionId: string | null };
+
+    const openedSessionId = opened.sessionId;
+
+    // Now close it
+    const result = (await closeHandler({
+      body: { conversationId: convId },
+    })) as {
+      conversationId: string;
+      noop: boolean;
+      closed: { profile: string | null; sessionId: string | null } | null;
+    };
+
+    expect(result.noop).toBe(false);
+    expect(result.closed).not.toBeNull();
+    expect(result.closed!.profile).toBe("fast");
+    expect(result.closed!.sessionId).toBe(openedSessionId);
+  });
+
+  test("POST inference_profile_close with no active session → { noop: true, closed: null }", async () => {
+    const convId = crypto.randomUUID();
+    seedConversation(convId);
+
+    const result = (await closeHandler({
+      body: { conversationId: convId },
+    })) as {
+      noop: boolean;
+      closed: unknown;
+    };
+
+    expect(result.noop).toBe(true);
+    expect(result.closed).toBeNull();
+  });
+});

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

@@ -78,6 +78,7 @@ function seedConversationAndMessage(args: {
   messageId: string;
   source: string;
   conversationType: ConversationCreateType;
+  totalEstimatedCost?: number;
 }): void {
   const now = Date.now();
   getDb()
@@ -90,6 +91,9 @@ function seedConversationAndMessage(args: {
       source: args.source,
       conversationType: args.conversationType,
       memoryScopeId: "default",
+      ...(args.totalEstimatedCost != null
+        ? { totalEstimatedCost: args.totalEstimatedCost }
+        : {}),
     })
     .run();
   getDb()
@@ -236,6 +240,51 @@ describe("GET /v1/messages/:id/llm-context — conversationKind", () => {
   });
 });
 
+describe("GET /v1/messages/:id/llm-context — conversationTotalEstimatedCostUsd", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("returns the conversation's running cost total when present", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-with-cost",
+      messageId: "msg-with-cost",
+      source: "user",
+      conversationType: "standard",
+      totalEstimatedCost: 1.234,
+    });
+
+    const body = (await dispatchLlmContext("msg-with-cost")) as {
+      conversationTotalEstimatedCostUsd: number | null;
+    };
+
+    expect(body.conversationTotalEstimatedCostUsd).toBeCloseTo(1.234, 5);
+  });
+
+  test("returns 0 when the conversation hasn't accrued any cost yet", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-no-cost",
+      messageId: "msg-no-cost",
+      source: "user",
+      conversationType: "standard",
+    });
+
+    const body = (await dispatchLlmContext("msg-no-cost")) as {
+      conversationTotalEstimatedCostUsd: number | null;
+    };
+
+    expect(body.conversationTotalEstimatedCostUsd).toBe(0);
+  });
+
+  test("returns null when the message can't be resolved to a conversation", async () => {
+    const body = (await dispatchLlmContext("msg-missing-cost")) as {
+      conversationTotalEstimatedCostUsd: number | null;
+    };
+
+    expect(body.conversationTotalEstimatedCostUsd).toBeNull();
+  });
+});
+
 describe("PUT /v1/config/llm/profiles/:name", () => {
   beforeEach(() => {
     savedRawConfig = null;
@@ -325,4 +374,144 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     });
     expect(savedProfile.openrouter).toEqual({ only: ["anthropic"] });
   });
+
+  test("writes provider_connection when present in body", () => {
+    const result = replaceProfileRoute.handler({
+      pathParams: { name: "custom" },
+      body: {
+        provider: "openai",
+        provider_connection: "personal-openai",
+        model: "gpt-5.5",
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const savedProfile = (
+      savedRawConfig?.llm as {
+        profiles: Record<string, Record<string, unknown>>;
+      }
+    ).profiles.custom;
+
+    expect(savedProfile.provider).toBe("openai");
+    expect(savedProfile.provider_connection).toBe("personal-openai");
+  });
+
+  test("clears provider_connection when omitted from body (UI-owned key)", () => {
+    // Seed an existing binding so the test starts from a non-empty state.
+    (
+      rawConfigFixture.llm as {
+        profiles: { custom: Record<string, unknown> };
+      }
+    ).profiles.custom.provider_connection = "stale-openai";
+
+    const result = replaceProfileRoute.handler({
+      pathParams: { name: "custom" },
+      body: {
+        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.
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const savedProfile = (
+      savedRawConfig?.llm as {
+        profiles: Record<string, Record<string, unknown>>;
+      }
+    ).profiles.custom;
+
+    expect(savedProfile.provider_connection).toBeUndefined();
+  });
+
+  describe("managed profile guard", () => {
+    beforeEach(() => {
+      // Seed a managed profile alongside the existing custom one.
+      (rawConfigFixture.llm as { profiles: Record<string, unknown> }).profiles[
+        "balanced"
+      ] = {
+        source: "managed",
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        label: "Balanced",
+        status: "active",
+      };
+    });
+
+    test("allows label edit on managed profile, preserving seed fields", () => {
+      const result = replaceProfileRoute.handler({
+        pathParams: { name: "balanced" },
+        body: { label: "My Balanced" },
+      });
+
+      expect(result).toEqual({ ok: true });
+      const savedProfile = (
+        savedRawConfig?.llm as {
+          profiles: Record<string, Record<string, unknown>>;
+        }
+      ).profiles.balanced;
+
+      expect(savedProfile.label).toBe("My Balanced");
+      // Seed fields preserved.
+      expect(savedProfile.provider).toBe("anthropic");
+      expect(savedProfile.model).toBe("claude-sonnet-4-6");
+      expect(savedProfile.source).toBe("managed");
+    });
+
+    test("allows status edit on managed profile", () => {
+      const result = replaceProfileRoute.handler({
+        pathParams: { name: "balanced" },
+        body: { status: "disabled" },
+      });
+
+      expect(result).toEqual({ ok: true });
+      const savedProfile = (
+        savedRawConfig?.llm as {
+          profiles: Record<string, Record<string, unknown>>;
+        }
+      ).profiles.balanced;
+
+      expect(savedProfile.status).toBe("disabled");
+      expect(savedProfile.provider).toBe("anthropic");
+    });
+
+    test("allows label+status edit together", () => {
+      const result = replaceProfileRoute.handler({
+        pathParams: { name: "balanced" },
+        body: { label: "Renamed", status: "disabled" },
+      });
+
+      expect(result).toEqual({ ok: true });
+      const savedProfile = (
+        savedRawConfig?.llm as {
+          profiles: Record<string, Record<string, unknown>>;
+        }
+      ).profiles.balanced;
+
+      expect(savedProfile.label).toBe("Renamed");
+      expect(savedProfile.status).toBe("disabled");
+    });
+
+    test("rejects provider edit on managed profile with disallowed-keys error", () => {
+      expect(() =>
+        replaceProfileRoute.handler({
+          pathParams: { name: "balanced" },
+          body: { provider: "openai", model: "gpt-5" },
+        }),
+      ).toThrow(/Cannot edit managed profile "balanced" fields \[provider, model\]/);
+    });
+
+    test("rejects mixed allowed+disallowed fields", () => {
+      // label is allowed but maxTokens is not — must reject without partially
+      // applying label, so saver should never be invoked.
+      expect(() =>
+        replaceProfileRoute.handler({
+          pathParams: { name: "balanced" },
+          body: { label: "Try", maxTokens: 999 },
+        }),
+      ).toThrow(/Cannot edit managed profile "balanced" fields \[maxTokens\]/);
+      expect(savedRawConfig).toBeNull();
+    });
+  });
 });