@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/runtime/migrations/vbundle-builder.ts

@@ -71,6 +71,12 @@ export interface VBundleExportOptions {
   include_logs: boolean;
   include_browser_state: boolean;
   include_memory_vectors: boolean;
+  /**
+   * Debug profile: the bundle carries `gateway/export.tar.gz`, the gateway's
+   * database and recent logs, for Vellum staff to inspect. Absent on
+   * ordinary migration bundles.
+   */
+  include_gateway?: boolean;
 }
 
 export interface BuildVBundleOptions {
@@ -697,6 +703,11 @@ export interface BuildExportVBundleOptions {
   checkpoint?: () => void | Promise<void>;
   /** Optional credential entries to include in the archive under credentials/ prefix. */
   credentials?: Array<{ account: string; value: string }>;
+  /**
+   * Extra in-memory entries at exact archive paths, outside `workspace/`.
+   * The debug profile uses this for `gateway/export.tar.gz`.
+   */
+  extraFiles?: Array<{ archivePath: string; data: Uint8Array }>;
 }
 
 /**
@@ -722,6 +733,7 @@ export function buildExportVBundle(
     checkpoint,
     workspaceDir,
     credentials,
+    extraFiles,
   } = options;
 
   // Flush WAL to the main database file before reading so the export
@@ -732,6 +744,9 @@ export function buildExportVBundle(
   }
 
   const files: VBundleFileEntry[] = [];
+  for (const extra of extraFiles ?? []) {
+    files.push({ path: extra.archivePath, data: extra.data });
+  }
 
   // Walk the entire workspace directory, including binary files (DB,
   // attachments) but skipping large/regenerable subdirectories.
@@ -1176,6 +1191,7 @@ export async function streamExportVBundle(
     checkpoint,
     workspaceDir,
     credentials,
+    extraFiles,
   } = options;
 
   // Flush WAL to the main database file before reading. Awaiting allows
@@ -1236,8 +1252,15 @@ export async function streamExportVBundle(
     });
   }
 
-  // Build in-memory entries for credentials (not disk-backed)
+  // Build in-memory entries for credentials and any extra files (not disk-backed)
   const inMemoryEntries: InMemoryEntry[] = [];
+  for (const extra of extraFiles ?? []) {
+    inMemoryEntries.push({
+      archivePath: extra.archivePath,
+      data: extra.data,
+      size: extra.data.length,
+    });
+  }
   if (credentials?.length) {
     for (const { account, value } of credentials) {
       const data = new TextEncoder().encode(value);

package/src/runtime/migrations/vbundle-import-analyzer.ts

@@ -19,7 +19,10 @@ import { join, resolve } from "node:path";
 
 import { resolveGuardianPersonaPath } from "../../prompts/persona-resolver.js";
 import { getLogger } from "../../util/logger.js";
-import { isRetiredArchivePath } from "./vbundle-import-policy.js";
+import {
+  isGatewayArchivePath,
+  isRetiredArchivePath,
+} from "./vbundle-import-policy.js";
 import type { ManifestType } from "./vbundle-validator.js";
 
 const log = getLogger("vbundle-import-analyzer");
@@ -123,7 +126,10 @@ export class DefaultPathResolver implements PathResolver {
     // must never resolve to a disk target — resolving would write them
     // back into the workspace on import. The analyzer and both importers
     // turn the resulting null into a silent non-blocking skip.
-    if (isRetiredArchivePath(archivePath)) {
+    if (
+      isRetiredArchivePath(archivePath) ||
+      isGatewayArchivePath(archivePath)
+    ) {
       return null;
     }
 
@@ -297,10 +303,13 @@ export function analyzeImport(
       // Retired-feature file from a legacy bundle: nothing consumes it
       // anymore, so drop it silently instead of blocking the restore with
       // an UNKNOWN_ARCHIVE_PATH conflict.
-      if (isRetiredArchivePath(fileEntry.path)) {
+      if (
+        isRetiredArchivePath(fileEntry.path) ||
+        isGatewayArchivePath(fileEntry.path)
+      ) {
         log.info(
           { path: fileEntry.path },
-          "Retired archive path in legacy bundle — will be skipped on import",
+          "Archive path is not workspace data — will be skipped on import",
         );
         files.push({
           path: fileEntry.path,

package/src/runtime/migrations/vbundle-import-policy.ts

@@ -57,6 +57,16 @@ export function isRetiredArchivePath(archivePath: string): boolean {
   return RETIRED_ARCHIVE_PATHS.has(archivePath);
 }
 
+/**
+ * `gateway/` holds the gateway's own database and logs, added by the debug
+ * export profile for Vellum staff to open on a debug clone. It is never
+ * part of a workspace, so preflight and both importers skip it silently,
+ * the same way they skip retired paths.
+ */
+export function isGatewayArchivePath(archivePath: string): boolean {
+  return archivePath.startsWith("gateway/");
+}
+
 export function isConfigArchivePath(archivePath: string): boolean {
   return CONFIG_ARCHIVE_PATHS.has(archivePath);
 }
@@ -172,6 +182,20 @@ export function formatRuntimeCompatibilityMessage(
   return `Cannot import: bundle requires runtime ${range}, but this runtime is ${runtimeVersion}. Update your runtime before importing.`;
 }
 
+/**
+ * Whether `version` names a runtime built from a source checkout: the
+ * `<pkg.version>-local.<timestamp>.<sha>` `APP_VERSION` that the platform
+ * repo's `vel up` stamps on the assistant images it builds for its local
+ * minikube cluster. The triple is the checkout's package.json version,
+ * which only moves on release cuts, so it says nothing about whether the
+ * checkout is newer or older than a release. A CLI hatch from a checkout
+ * without an explicit `APP_VERSION` runs as the plain package version and
+ * is not covered.
+ */
+export function isLocalDevRuntimeVersion(version: string): boolean {
+  return /^\d+\.\d+\.\d+-local\./.test(version);
+}
+
 export function evaluateRuntimeCompatibility(
   compat: RuntimeCompatibility,
   runtimeVersion: string,
@@ -179,17 +203,25 @@ export function evaluateRuntimeCompatibility(
   if (compat.min_runtime_version === LEGACY_RUNTIME_VERSION_SENTINEL) {
     return { ok: true };
   }
-  const minCmp = compareSemver(runtimeVersion, compat.min_runtime_version);
-  if (minCmp === null) {
-    return { ok: true };
-  }
-  if (minCmp < 0) {
-    return {
-      ok: false,
-      reason: "version_incompatible",
-      bundle_compat: compat,
-      runtime_version: runtimeVersion,
-    };
+  // A local dev build skips the minimum bound, like an unparsable version
+  // does below: its triple is not comparable to release versions (see
+  // isLocalDevRuntimeVersion), so "runtime older than the bundle" cannot be
+  // decided from it. The maximum bound still applies: it is an explicit
+  // ceiling the bundle's producer recorded, and a local triple above it is
+  // as good a signal as any release's.
+  if (!isLocalDevRuntimeVersion(runtimeVersion)) {
+    const minCmp = compareSemver(runtimeVersion, compat.min_runtime_version);
+    if (minCmp === null) {
+      return { ok: true };
+    }
+    if (minCmp < 0) {
+      return {
+        ok: false,
+        reason: "version_incompatible",
+        bundle_compat: compat,
+        runtime_version: runtimeVersion,
+      };
+    }
   }
   if (compat.max_runtime_version !== null) {
     const maxCmp = compareSemver(runtimeVersion, compat.max_runtime_version);

package/src/runtime/migrations/vbundle-importer.ts

@@ -340,7 +340,10 @@ export function commitImport(options: ImportCommitOptions): ImportCommitResult {
         sha256: fileEntry.sha256,
         backup_path: null,
       });
-      if (!policy.isRetiredArchivePath(fileEntry.path)) {
+      if (
+        !policy.isRetiredArchivePath(fileEntry.path) &&
+        !policy.isGatewayArchivePath(fileEntry.path)
+      ) {
         warnings.push(
           `Skipped "${fileEntry.path}": no known disk target for this archive path`,
         );

package/src/runtime/migrations/vbundle-streaming-importer.ts

@@ -698,7 +698,10 @@ export async function streamCommitImport(
         // Retired-feature paths (see `policy.RETIRED_ARCHIVE_PATHS`) are
         // expected in legacy bundles and skip silently so the import report
         // matches preflight; anything else unresolvable earns a warning.
-        if (!policy.isRetiredArchivePath(archivePath)) {
+        if (
+          !policy.isRetiredArchivePath(archivePath) &&
+          !policy.isGatewayArchivePath(archivePath)
+        ) {
           warnings.push(
             `Skipped "${archivePath}": no known disk target for this archive path`,
           );

package/src/runtime/migrations/vbundle-validator.ts

@@ -53,6 +53,7 @@ const ExportOptions = z.object({
   include_logs: z.boolean(),
   include_browser_state: z.boolean(),
   include_memory_vectors: z.boolean(),
+  include_gateway: z.boolean().optional(),
 });
 
 export const ManifestSchema = z

package/src/runtime/pending-interactions-mode-session.test.ts

@@ -0,0 +1,62 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import * as pendingInteractions from "./pending-interactions.js";
+
+describe("pending interaction mode-session waits", () => {
+  const invalidateStructuralWait = mock(() => true);
+
+  beforeEach(() => {
+    pendingInteractions.clear();
+    clearConversations();
+    invalidateStructuralWait.mockClear();
+    setConversation("conv-1", {
+      modeSessions: { invalidateStructuralWait },
+    } as unknown as Conversation);
+  });
+
+  afterEach(() => {
+    pendingInteractions.clear();
+    clearConversations();
+  });
+
+  test.each([
+    ["question", "question"],
+    ["confirmation", "confirmation"],
+    ["acp_confirmation", "confirmation"],
+    ["secret", "secret"],
+  ] as const)(
+    "resolving %s invalidates its exact structural wait",
+    (interactionKind, structuralKind) => {
+      pendingInteractions.register("request-1", {
+        conversationId: "conv-1",
+        kind: interactionKind,
+      });
+
+      expect(pendingInteractions.resolve("request-1", "answered")).toEqual(
+        expect.objectContaining({ kind: interactionKind }),
+      );
+      expect(invalidateStructuralWait).toHaveBeenCalledTimes(1);
+      expect(invalidateStructuralWait).toHaveBeenCalledWith({
+        kind: structuralKind,
+        responseId: "request-1",
+      });
+    },
+  );
+
+  test("does not invalidate for a missing or non-structural interaction", () => {
+    expect(pendingInteractions.resolve("missing", "answered")).toBeUndefined();
+    pendingInteractions.register("host-request", {
+      conversationId: "conv-1",
+      kind: "host_cu",
+    });
+
+    pendingInteractions.resolve("host-request", "answered");
+
+    expect(invalidateStructuralWait).not.toHaveBeenCalled();
+  });
+});

package/src/runtime/pending-interactions.ts

@@ -20,6 +20,7 @@
 
 import type { InteractionResolutionState } from "../api/events/interaction-resolved.js";
 import type { QuestionEntry } from "../api/events/question-request.js";
+import { findConversationOrSubagent } from "../daemon/conversation-registry.js";
 import type { UserDecision } from "../permissions/types.js";
 import { getLogger } from "../util/logger.js";
 import { broadcastMessage } from "./assistant-event-hub.js";
@@ -135,6 +136,33 @@ export interface PendingInteraction {
 
 const pending = new Map<string, PendingInteraction>();
 
+function invalidateModeSessionStructuralWait(
+  requestId: string,
+  interaction: PendingInteraction,
+): void {
+  const kind =
+    interaction.kind === "acp_confirmation"
+      ? "confirmation"
+      : interaction.kind === "confirmation" ||
+          interaction.kind === "question" ||
+          interaction.kind === "secret"
+        ? interaction.kind
+        : undefined;
+  if (!kind) {
+    return;
+  }
+  try {
+    findConversationOrSubagent(
+      interaction.conversationId,
+    )?.modeSessions.invalidateStructuralWait({ kind, responseId: requestId });
+  } catch (err) {
+    log.warn(
+      { err, requestId, conversationId: interaction.conversationId, kind },
+      "Could not invalidate mode session structural wait",
+    );
+  }
+}
+
 export function register(
   requestId: string,
   interaction: PendingInteraction,
@@ -162,6 +190,7 @@ export function resolve(
     return undefined;
   }
   pending.delete(requestId);
+  invalidateModeSessionStructuralWait(requestId, interaction);
   if (interaction.timer != null) {
     clearTimeout(interaction.timer);
   }

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

@@ -0,0 +1,104 @@
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+const historyResult = {
+  events: [
+    {
+      id: "evt-1",
+      clientId: "client-123",
+      interfaceId: "chrome-extension",
+      connectionId: "conn-1",
+      reason: "sse_open" as const,
+      occurredAt: Date.parse("2026-09-16T12:00:00.000Z"),
+      actorPrincipalId: "user-123",
+      clientVersion: "0.12.1",
+      sseWatchdog: true,
+      machineName: null,
+    },
+  ],
+  sessions: [
+    {
+      clientId: "client-123",
+      interfaceId: "chrome-extension",
+      startedAt: Date.parse("2026-09-16T12:00:00.000Z"),
+      endedAt: null,
+      durationMs: 60_000,
+      flapCount: 1,
+      openReason: "sse_open" as const,
+      closeReason: null,
+      clientVersion: "0.12.1",
+      sseWatchdog: true,
+      machineName: null,
+      connectionIds: ["conn-1", "conn-2"],
+    },
+  ],
+};
+
+const listHistory = mock((params: Record<string, unknown>) => {
+  if (params.actorPrincipalId === "user-123") {
+    return historyResult;
+  }
+  return { events: [], sessions: [] };
+});
+
+mock.module("../../../config/env.js", () => ({
+  isHttpAuthDisabled: () => false,
+  hasUngatedHttpAuthDisabled: () => false,
+}));
+
+mock.module("../../../persistence/client-connection-events-store.js", () => ({
+  listClientConnectionHistory: listHistory,
+}));
+
+import { ROUTES } from "../client-routes.js";
+import { BadRequestError } from "../errors.js";
+import type { RouteDefinition } from "../types.js";
+
+afterAll(() => {
+  mock.restore();
+});
+
+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;
+}
+
+describe("list_client_history", () => {
+  test("returns ISO timestamps for the calling actor", () => {
+    const handler = findHandler("list_client_history");
+    const result = handler({
+      headers: { "x-vellum-actor-principal-id": "user-123" },
+      queryParams: { clientId: "client-123" },
+    }) as {
+      sessions: Array<{ startedAt: string; endedAt: string | null }>;
+      events: Array<{ occurredAt: string }>;
+    };
+
+    expect(listHistory).toHaveBeenCalled();
+    expect(result.sessions[0].startedAt).toBe("2026-09-16T12:00:00.000Z");
+    expect(result.sessions[0].endedAt).toBeNull();
+    expect(result.events[0].occurredAt).toBe("2026-09-16T12:00:00.000Z");
+  });
+
+  test("hides other actors' history", () => {
+    const handler = findHandler("list_client_history");
+    const result = handler({
+      headers: { "x-vellum-actor-principal-id": "user-other" },
+    }) as { sessions: unknown[]; events: unknown[] };
+
+    expect(result.sessions).toEqual([]);
+    expect(result.events).toEqual([]);
+  });
+
+  test("rejects an invalid since value", () => {
+    const handler = findHandler("list_client_history");
+    expect(() =>
+      handler({
+        headers: { "x-vellum-actor-principal-id": "user-123" },
+        queryParams: { since: "not-a-date" },
+      }),
+    ).toThrow(BadRequestError);
+  });
+});

package/src/runtime/routes/__tests__/image-generation-routes.test.ts

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { setConfig } from "../../../__tests__/helpers/set-config.js";
+import { BadRequestError } from "../errors.js";
+
+let lastGenerateProvider: unknown = null;
+let lastGenerateRequest: Record<string, unknown> | null = null;
+
+mock.module("../../../media/image-service.js", () => ({
+  generateImage: async (
+    provider: unknown,
+    _credentials: unknown,
+    request: Record<string, unknown>,
+  ) => {
+    lastGenerateProvider = provider;
+    lastGenerateRequest = request;
+    return {
+      images: [{ mimeType: "image/png", dataBase64: "generated" }],
+      resolvedModel: request.model,
+    };
+  },
+  mapImageGenError: () => "mapped",
+}));
+
+mock.module("../../../media/image-credentials.js", () => ({
+  resolveImageGenRouting: (
+    svc: { provider: string },
+    _model?: unknown,
+  ) => ({
+    backendProvider: svc.provider === "openrouter" ? "openrouter" : "gemini",
+    managed: false,
+  }),
+  resolveImageGenCredentials: async () => ({
+    credentials: { type: "direct", apiKey: "test-key" },
+  }),
+}));
+
+const { ROUTES } = await import("../image-generation-routes.js");
+const route = ROUTES[0];
+
+beforeEach(() => {
+  lastGenerateProvider = null;
+  lastGenerateRequest = null;
+  setConfig("services", {
+    "image-generation": {
+      provider: "openrouter",
+      model: "google/gemini-3.1-flash-image-preview",
+    },
+  });
+});
+
+describe("image-generation generate route", () => {
+  test("mentions OpenRouter in the route description", () => {
+    expect(route.description).toContain("OpenRouter");
+  });
+
+  test("accepts an arbitrary OpenRouter slug", async () => {
+    const result = await route.handler({
+      body: {
+        prompt: "a nebula",
+        model: "black-forest-labs/flux",
+      },
+    });
+
+    expect(lastGenerateProvider).toBe("openrouter");
+    expect(lastGenerateRequest?.model).toBe("black-forest-labs/flux");
+    expect(result).toMatchObject({
+      resolvedModel: "black-forest-labs/flux",
+    });
+  });
+
+  test("qualifies a built-in alias for OpenRouter", async () => {
+    await route.handler({
+      body: { prompt: "a robot", model: "fast" },
+    });
+
+    expect(lastGenerateRequest?.model).toBe(
+      "google/gemini-3.1-flash-image-preview",
+    );
+  });
+
+  test("rejects an unknown model when the provider is not OpenRouter", async () => {
+    setConfig("services", {
+      "image-generation": {
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+    });
+
+    await expect(
+      route.handler({
+        body: { prompt: "a cat", model: "black-forest-labs/flux" },
+      }),
+    ).rejects.toThrow(BadRequestError);
+    expect(lastGenerateProvider).toBeNull();
+  });
+});

package/src/runtime/routes/__tests__/inference-profiles-routes.test.ts

@@ -123,8 +123,7 @@ function seedVellumConnection(): void {
 
 function persistedProfiles(): Record<string, unknown> {
   const llm = loadRawConfig().llm as
-    | { profiles?: Record<string, unknown> }
-    | undefined;
+    { profiles?: Record<string, unknown> } | undefined;
   return llm?.profiles ?? {};
 }
 
@@ -923,6 +922,29 @@ describe("PUT inference/active-profile validation", () => {
     ).rejects.toThrow(/disabled/);
   });
 
+  test("rejects a profile whose catalog model does not produce chat text", async () => {
+    setConfig("llm", {
+      profiles: {
+        jev: {
+          source: "user",
+          provider: "typesafe",
+          model: "jev-latest",
+          status: "active",
+        },
+      },
+    });
+    const promise = call("inference_profiles_set_active", {
+      body: { name: "jev" },
+    });
+    await expect(promise).rejects.toBeInstanceOf(BadRequestError);
+    await expect(promise).rejects.toThrow(
+      /structured answers rather than chat text/,
+    );
+    expect(
+      (loadRawConfig().llm as { activeProfile?: string }).activeProfile,
+    ).toBeUndefined();
+  });
+
   test("rejects a profile that cannot serve requests — no escape hatch", async () => {
     setConfig("llm", {
       profiles: {

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

@@ -334,12 +334,35 @@ describe("roadmap writes", () => {
     });
   });
 
-  test("update can clear every tag", async () => {
+  test("update refuses the staff-only fields before calling out", async () => {
     stubFetch(UPSTREAM_ITEM);
 
-    await update({ pathParams: { slug: "dark-mode" }, body: { tags: [] } });
+    await expect(
+      update({
+        pathParams: { slug: "dark-mode" },
+        body: { title: "Dark mode", status: "planned" },
+      }),
+    ).rejects.toThrow(
+      "An assistant can change only an item's title and description; status is set by Vellum staff.",
+    );
+    await expect(
+      update({ pathParams: { slug: "dark-mode" }, body: { tags: [] } }),
+    ).rejects.toThrow("tags is set by Vellum staff");
+    expect(calls).toHaveLength(0);
+  });
 
-    expect(calls[0].body).toEqual({ tags: [] });
+  test("update names an unknown field as unknown, not as staff-only", async () => {
+    stubFetch(UPSTREAM_ITEM);
+
+    await expect(
+      update({
+        pathParams: { slug: "dark-mode" },
+        body: { titel: "Dark mode", status: "planned" },
+      }),
+    ).rejects.toThrow(
+      "An assistant can change only an item's title and description; status is set by Vellum staff; titel is not a roadmap update field.",
+    );
+    expect(calls).toHaveLength(0);
   });
 
   test("create rejects a blank title before calling out", async () => {
@@ -365,11 +388,11 @@ describe("roadmap writes", () => {
 
     await update({
       pathParams: { slug: "dark-mode" },
-      body: { status: "planned" },
+      body: { description: "Follow the OS setting" },
     });
 
     expect(calls[0].method).toBe("PATCH");
-    expect(calls[0].body).toEqual({ status: "planned" });
+    expect(calls[0].body).toEqual({ description: "Follow the OS setting" });
   });
 
   test("delete reports the removed slug", async () => {
@@ -403,7 +426,7 @@ describe("roadmap writes", () => {
     const writes = [
       () => create({ body: { title: "Add dark mode" } }),
       () =>
-        update({ pathParams: { slug: "dark-mode" }, body: { status: "open" } }),
+        update({ pathParams: { slug: "dark-mode" }, body: { title: "Dark" } }),
       () => remove({ pathParams: { slug: "dark-mode" } }),
       () => upvote({ pathParams: { slug: "dark-mode" } }),
       () => unvote({ pathParams: { slug: "dark-mode" } }),