@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/__tests__/gemini-provider.test.ts

@@ -773,6 +773,144 @@ describe("GeminiProvider", () => {
     });
   });
 
+  test("splits functionResponse from following text in a user Content", async () => {
+    /** Gemini serializes function responses separately from following text. */
+
+    // GIVEN streamed output and a history containing a tool result followed by text
+    fakeChunks = [textChunk("Done"), finishChunk("STOP", 20, 10)];
+
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Read /tmp/test" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "call_split",
+            name: "file_read",
+            input: { path: "/tmp/test" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "call_split",
+            content: "file content here",
+          },
+          { type: "text", text: "Summarize that." },
+        ],
+      },
+    ];
+
+    // WHEN the provider sends the message
+    await provider.sendMessage(messages);
+
+    // THEN the function response is isolated in its own user Content
+    const contents = lastStreamParams!.contents as Array<{
+      role: string;
+      parts: Array<Record<string, unknown>>;
+    }>;
+    expect(contents).toHaveLength(4);
+
+    // AND the function response Content appears before the text Content
+    expect(contents[2]).toMatchObject({
+      role: "user",
+      parts: [
+        {
+          functionResponse: {
+            name: "file_read",
+            response: { output: "file content here" },
+          },
+        },
+      ],
+    });
+
+    // AND the text remains in a separate user Content
+    expect(contents[3]).toEqual({
+      role: "user",
+      parts: [{ text: "Summarize that." }],
+    });
+  });
+
+  test("orders tool result media before following text", async () => {
+    /** Gemini receives tool result attachments before text that refers to them. */
+
+    // GIVEN streamed output and a history with an image tool result followed by text
+    fakeChunks = [textChunk("Done"), finishChunk("STOP", 20, 10)];
+
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Read /tmp/test" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "call_image",
+            name: "file_read",
+            input: { path: "/tmp/test" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "call_image",
+            content: "image result",
+            contentBlocks: [
+              {
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: "image/png",
+                  data: "iVBORw0KGgo=",
+                },
+              },
+            ],
+          },
+          { type: "text", text: "Describe that image." },
+        ],
+      },
+    ];
+
+    // WHEN the provider sends the message
+    await provider.sendMessage(messages);
+
+    const contents = lastStreamParams!.contents as Array<{
+      role: string;
+      parts: Array<Record<string, unknown>>;
+    }>;
+
+    // THEN the tool result Contents are ordered by function response, media, and text
+    expect(contents.slice(2)).toEqual([
+      {
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              name: "file_read",
+              response: { output: "image result" },
+            },
+          },
+        ],
+      },
+      {
+        role: "user",
+        parts: [
+          { inlineData: { mimeType: "image/png", data: "iVBORw0KGgo=" } },
+        ],
+      },
+      {
+        role: "user",
+        parts: [{ text: "Describe that image." }],
+      },
+    ]);
+  });
+
   function toolResultWithAudio(mediaType: string, data: string): Message[] {
     return [
       { role: "user", content: [{ type: "text", text: "Read clip" }] },

package/src/__tests__/history-repair.test.ts

@@ -1,8 +1,11 @@
 import { describe, expect, test } from "bun:test";
 
-import { deepRepairHistory } from "../agent/history-repair/history-repair.js";
-import { isRepairableOrderingError } from "../agent/history-repair/history-repair.js";
-import { repairHistory } from "../agent/history-repair/history-repair.js";
+import {
+  deepRepairHistory,
+  isRepairableOrderingError,
+  isUserTerminalHistoryError,
+  repairHistory,
+} from "../agent/history-repair/history-repair.js";
 import type { Message } from "../providers/types.js";
 
 describe("repairHistory", () => {
@@ -1172,6 +1175,88 @@ describe("deepRepairHistory", () => {
     expect(repaired[1].content[0]).toEqual({ type: "text", text: "Hi" });
   });
 
+  test("removes blank text messages so blank assistant tails become user-terminal", () => {
+    /** Blank-text assistant turns carry nothing a provider can serialize. */
+
+    // GIVEN a history whose assistant turns hold only whitespace text
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      { role: "assistant", content: [{ type: "text", text: "  \n" }] },
+      { role: "user", content: [{ type: "text", text: "Continue" }] },
+      { role: "assistant", content: [{ type: "text", text: "" }] },
+    ];
+
+    // WHEN it is deep-repaired
+    const { messages: repaired } = deepRepairHistory(messages);
+
+    // THEN only the merged user turn survives
+    expect(repaired).toHaveLength(1);
+    expect(repaired[0].role).toBe("user");
+    expect(repaired[0].content).toEqual([
+      { type: "text", text: "Hello" },
+      { type: "text", text: "Continue" },
+    ]);
+  });
+
+  test("preserves a non-empty assistant tail by default", () => {
+    /** Providers that accept an assistant-terminal history keep the reply. */
+
+    // GIVEN a history ending with a real assistant reply
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      { role: "assistant", content: [{ type: "text", text: "Hi" }] },
+    ];
+
+    // WHEN it is deep-repaired without a user-terminal requirement
+    const { messages: repaired } = deepRepairHistory(messages);
+
+    // THEN the reply is kept
+    expect(repaired).toEqual(messages);
+  });
+
+  test("drops a non-empty assistant tail when user-terminal history is required", () => {
+    /** Providers rejecting a model-terminal request get a user-terminal history. */
+
+    // GIVEN a history ending with a real assistant reply
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      { role: "assistant", content: [{ type: "text", text: "Hi" }] },
+    ];
+
+    // WHEN it is deep-repaired for a provider requiring a user-terminal history
+    const { messages: repaired } = deepRepairHistory(messages, {
+      requireUserTerminal: true,
+    });
+
+    // THEN the trailing reply is dropped
+    expect(repaired).toEqual([messages[0]]);
+  });
+
+  test("drops multiple trailing assistant messages and allows an assistant-only history to empty", () => {
+    /** The whole assistant tail is dropped, even when nothing is left. */
+
+    // GIVEN a history ending with several assistant turns
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      { role: "assistant", content: [{ type: "text", text: "One" }] },
+      { role: "assistant", content: [{ type: "text", text: "Two" }] },
+    ];
+
+    // WHEN it is deep-repaired for a provider requiring a user-terminal history
+    const { messages: repaired } = deepRepairHistory(messages, {
+      requireUserTerminal: true,
+    });
+
+    // THEN every trailing assistant turn is gone
+    expect(repaired).toEqual([messages[0]]);
+
+    // AND an assistant-only history repairs to an empty history
+    expect(
+      deepRepairHistory(messages.slice(1), { requireUserTerminal: true })
+        .messages,
+    ).toEqual([]);
+  });
+
   test("applies standard repair after deep pass", () => {
     // Consecutive assistant messages with tool_use but missing tool_result
     const messages: Message[] = [
@@ -1242,6 +1327,23 @@ describe("isRepairableOrderingError", () => {
     ).toBe(true);
   });
 
+  test("matches user-terminal history rejections", () => {
+    /** A model-terminal rejection is recognized as repairable. */
+
+    // GIVEN Gemini's rejection of a request ending with a model turn
+    const message = "Requests ending with a model turn are not supported.";
+
+    // WHEN the message is classified
+    // THEN it is repairable and identified as a user-terminal requirement
+    expect(isRepairableOrderingError(message)).toBe(true);
+    expect(isUserTerminalHistoryError(message)).toBe(true);
+
+    // AND an unrelated provider error is not
+    expect(
+      isUserTerminalHistoryError("The provider returned an unrelated error"),
+    ).toBe(false);
+  });
+
   test("does not match unrelated provider errors", () => {
     expect(isRepairableOrderingError("Rate limit exceeded")).toBe(false);
     expect(

package/src/__tests__/identity-routes.test.ts

@@ -165,6 +165,7 @@ describe("identity routes — health endpoint", () => {
       expect(body.capabilities).toEqual({
         memoryOptOut: true,
         retryLastTurn: true,
+        appPins: true,
       });
 
       // Profiler should either be absent or show enabled: false

package/src/__tests__/llm-catalog-parity.test.ts

@@ -244,6 +244,51 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
+  test("OpenRouter supportsCaching requires cache-read pricing", () => {
+    const openrouter = PROVIDER_CATALOG.find((entry) => entry.id === "openrouter");
+    expect(openrouter).toBeDefined();
+
+    for (const model of openrouter!.models) {
+      if (model.supportsCaching) {
+        expect(
+          model.pricing?.cacheReadPer1mTokens,
+          `openrouter/${model.id} supportsCaching requires cacheReadPer1mTokens`,
+        ).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  test("OpenRouter cache-read pricing implies supportsCaching except xAI", () => {
+    const openrouter = PROVIDER_CATALOG.find((entry) => entry.id === "openrouter");
+    expect(openrouter).toBeDefined();
+
+    for (const model of openrouter!.models) {
+      if (model.pricing?.cacheReadPer1mTokens === undefined) {
+        continue;
+      }
+      if (model.id.startsWith("x-ai/")) {
+        expect(
+          model.supportsCaching,
+          `openrouter/${model.id} keeps supportsCaching false: OpenRouter xAI routes do not report cached tokens`,
+        ).toBe(false);
+        continue;
+      }
+      expect(
+        model.supportsCaching,
+        `openrouter/${model.id} publishes cacheReadPer1mTokens so supportsCaching must be true`,
+      ).toBe(true);
+    }
+  });
+
+  test("OpenRouter catalog drops ids OpenRouter no longer serves", () => {
+    const openrouter = PROVIDER_CATALOG.find((entry) => entry.id === "openrouter");
+    expect(openrouter).toBeDefined();
+    const ids = new Set(openrouter!.models.map((model) => model.id));
+    expect(ids.has("deepseek/deepseek-v3.2-speciale")).toBe(false);
+    expect(ids.has("mistralai/devstral-2512")).toBe(false);
+    expect(ids.has("openrouter/owl-alpha")).toBe(false);
+  });
+
   test("every model default context is capped by its context window", () => {
     const json = loadClientCatalog();
 

package/src/__tests__/migration-import-from-path.test.ts

@@ -0,0 +1,349 @@
+/**
+ * HTTP tests for JSON `{ path }` on POST /v1/migrations/import and
+ * POST /v1/migrations/import-preflight.
+ *
+ * The daemon only opens a regular `.vbundle` that realpath-resolves
+ * under `${workspace}/.restore-staging/`.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+mock.module("../permissions/trust-store.js", () => ({
+  getAllRules: () => [],
+  isStarterBundleAccepted: () => false,
+  clearCache: () => {},
+}));
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => true,
+  hasUngatedHttpAuthDisabled: () => false,
+  getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
+  getGatewayPort: () => 7830,
+  getRuntimeHttpPort: () => 7821,
+  getRuntimeHttpHost: () => "127.0.0.1",
+  getRuntimeGatewayOriginSecret: () => undefined,
+  getIngressPublicBaseUrl: () => undefined,
+  setIngressPublicBaseUrl: () => {},
+}));
+
+import { defaultV1Options } from "../runtime/migrations/__tests__/v1-test-helpers.js";
+import { RESTORE_STAGING_DIRNAME } from "../runtime/migrations/staged-import-path.js";
+import { buildVBundle } from "../runtime/migrations/vbundle-builder.js";
+import {
+  handleMigrationImport,
+  handleMigrationImportPreflight,
+} from "../runtime/routes/migration-routes.js";
+import { callHandler } from "./helpers/call-route-handler.js";
+
+const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+
+function freshWorkspaceRoot(): string {
+  const parent = realpathSync(
+    mkdtempSync(join(tmpdir(), "migration-import-from-path-")),
+  );
+  const workspaceDir = join(parent, "workspace");
+  mkdirSync(workspaceDir, { recursive: true });
+  return workspaceDir;
+}
+
+function setWorkspaceDir(dir: string): void {
+  process.env.VELLUM_WORKSPACE_DIR = dir;
+}
+
+function makeSmallValidBundle(): Uint8Array {
+  const { archive } = buildVBundle({
+    files: [
+      {
+        path: "workspace/data/db/assistant.db",
+        data: new TextEncoder().encode("SQLite format 3\0"),
+      },
+      {
+        path: "workspace/config.json",
+        data: new TextEncoder().encode(
+          JSON.stringify({ provider: "anthropic", model: "test-model" }),
+        ),
+      },
+    ],
+    ...defaultV1Options(),
+  });
+  return archive;
+}
+
+function stageBundle(workspaceDir: string, archive: Uint8Array): string {
+  const staging = join(workspaceDir, RESTORE_STAGING_DIRNAME);
+  mkdirSync(staging, { recursive: true });
+  const filename = "backup.vbundle";
+  writeFileSync(join(staging, filename), archive);
+  return `${RESTORE_STAGING_DIRNAME}/${filename}`;
+}
+
+interface ImportCommitResponse {
+  success: boolean;
+  summary: {
+    total_files: number;
+    files_created: number;
+    files_overwritten: number;
+    files_skipped: number;
+    backups_created: number;
+  };
+  files: Array<{ path: string }>;
+  manifest: Record<string, unknown>;
+}
+
+interface PreflightResponse {
+  can_import: boolean;
+  summary?: {
+    files_to_create: number;
+    files_to_overwrite: number;
+    files_unchanged: number;
+    total_files: number;
+  };
+  validation?: { is_valid: false; errors: Array<{ code: string }> };
+}
+
+interface BadRequestResponse {
+  error: { code: string; message: string };
+}
+
+let testWorkspaceRoot: string;
+let testParent: string;
+
+beforeEach(() => {
+  testWorkspaceRoot = freshWorkspaceRoot();
+  testParent = join(testWorkspaceRoot, "..");
+  setWorkspaceDir(testWorkspaceRoot);
+});
+
+afterEach(() => {
+  try {
+    rmSync(testParent, { recursive: true, force: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+afterAll(() => {
+  if (originalWorkspaceDir !== undefined) {
+    process.env.VELLUM_WORKSPACE_DIR = originalWorkspaceDir;
+  } else {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  }
+});
+
+describe("handleMigrationImport — JSON {path} body", () => {
+  test("happy path: streams a staged .vbundle and imports it", async () => {
+    const relativePath = stageBundle(
+      testWorkspaceRoot,
+      makeSmallValidBundle(),
+    );
+
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: relativePath }),
+    });
+
+    const res = await callHandler(handleMigrationImport, req);
+    const body = (await res.json()) as ImportCommitResponse;
+
+    expect(res.status).toBe(200);
+    expect(body.success).toBe(true);
+    expect(body.summary.total_files).toBeGreaterThan(0);
+    expect(body.files.length).toBeGreaterThan(0);
+    expect(existsSync(join(testWorkspaceRoot, "data", "db", "assistant.db"))).toBe(
+      true,
+    );
+    expect(existsSync(join(testWorkspaceRoot, "config.json"))).toBe(true);
+  });
+
+  test("absolute path inside staging is accepted", async () => {
+    const relativePath = stageBundle(
+      testWorkspaceRoot,
+      makeSmallValidBundle(),
+    );
+    const absolutePath = join(testWorkspaceRoot, relativePath);
+
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: absolutePath }),
+    });
+
+    const res = await callHandler(handleMigrationImport, req);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as ImportCommitResponse;
+    expect(body.success).toBe(true);
+  });
+
+  test("both url and path returns 400", async () => {
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        url: "https://storage.googleapis.com/b/o?X-Goog-Signature=x",
+        path: `${RESTORE_STAGING_DIRNAME}/backup.vbundle`,
+      }),
+    });
+
+    const res = await callHandler(handleMigrationImport, req);
+    const body = (await res.json()) as BadRequestResponse;
+
+    expect(res.status).toBe(400);
+    expect(body.error.code).toBe("BAD_REQUEST");
+    expect(body.error.message).toContain("exactly one");
+  });
+
+  test("missing staged file returns 400", async () => {
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        path: `${RESTORE_STAGING_DIRNAME}/missing.vbundle`,
+      }),
+    });
+
+    const res = await callHandler(handleMigrationImport, req);
+    const body = (await res.json()) as BadRequestResponse;
+
+    expect(res.status).toBe(400);
+    expect(body.error.code).toBe("BAD_REQUEST");
+    expect(body.error.message.toLowerCase()).toContain("not found");
+  });
+
+  test("traversal out of staging returns 400", async () => {
+    writeFileSync(join(testWorkspaceRoot, "secret.vbundle"), "nope");
+
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        path: `${RESTORE_STAGING_DIRNAME}/../secret.vbundle`,
+      }),
+    });
+
+    const res = await callHandler(handleMigrationImport, req);
+    const body = (await res.json()) as BadRequestResponse;
+
+    expect(res.status).toBe(400);
+    expect(body.error.code).toBe("BAD_REQUEST");
+    expect(body.error.message.toLowerCase()).toContain("staging");
+  });
+
+  test("path outside the workspace returns 400", async () => {
+    const outside = join(testParent, "outside.vbundle");
+    writeFileSync(outside, "nope");
+
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: outside }),
+    });
+
+    const res = await callHandler(handleMigrationImport, req);
+    const body = (await res.json()) as BadRequestResponse;
+
+    expect(res.status).toBe(400);
+    expect(body.error.code).toBe("BAD_REQUEST");
+    expect(body.error.message.toLowerCase()).toContain("staging");
+  });
+
+  test("symlink in staging returns 400", async () => {
+    const relativePath = stageBundle(
+      testWorkspaceRoot,
+      makeSmallValidBundle(),
+    );
+    const target = join(testWorkspaceRoot, relativePath);
+    const link = join(testWorkspaceRoot, RESTORE_STAGING_DIRNAME, "alias.vbundle");
+    symlinkSync(target, link);
+
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        path: `${RESTORE_STAGING_DIRNAME}/alias.vbundle`,
+      }),
+    });
+
+    const res = await callHandler(handleMigrationImport, req);
+    const body = (await res.json()) as BadRequestResponse;
+
+    expect(res.status).toBe(400);
+    expect(body.error.code).toBe("BAD_REQUEST");
+    expect(body.error.message.toLowerCase()).toContain("symlink");
+  });
+});
+
+describe("handleMigrationImportPreflight — JSON {path} body", () => {
+  test("happy path: analyzes a staged .vbundle without writing files", async () => {
+    const relativePath = stageBundle(
+      testWorkspaceRoot,
+      makeSmallValidBundle(),
+    );
+
+    const req = new Request("http://localhost/v1/migrations/import-preflight", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: relativePath }),
+    });
+
+    const res = await callHandler(handleMigrationImportPreflight, req);
+    const body = (await res.json()) as PreflightResponse;
+
+    expect(res.status).toBe(200);
+    expect(body.can_import).toBe(true);
+    expect(body.summary?.total_files).toBeGreaterThan(0);
+    expect(existsSync(join(testWorkspaceRoot, "config.json"))).toBe(false);
+  });
+
+  test("empty path returns 400", async () => {
+    const req = new Request("http://localhost/v1/migrations/import-preflight", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: "" }),
+    });
+
+    const res = await callHandler(handleMigrationImportPreflight, req);
+    const body = (await res.json()) as BadRequestResponse;
+
+    expect(res.status).toBe(400);
+    expect(body.error.code).toBe("BAD_REQUEST");
+  });
+
+  test("non-.vbundle staging file returns 400", async () => {
+    const staging = join(testWorkspaceRoot, RESTORE_STAGING_DIRNAME);
+    mkdirSync(staging, { recursive: true });
+    writeFileSync(join(staging, "notes.txt"), "nope");
+
+    const req = new Request("http://localhost/v1/migrations/import-preflight", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: `${RESTORE_STAGING_DIRNAME}/notes.txt` }),
+    });
+
+    const res = await callHandler(handleMigrationImportPreflight, req);
+    const body = (await res.json()) as BadRequestResponse;
+
+    expect(res.status).toBe(400);
+    expect(body.error.code).toBe("BAD_REQUEST");
+    expect(body.error.message.toLowerCase()).toContain(".vbundle");
+  });
+});