@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/persistence/migrations/385-create-document-revisions.test.ts

@@ -0,0 +1,67 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateCreateDocumentRevisions } from "./385-create-document-revisions.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/*sql*/ `
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE documents (
+      surface_id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL
+    );
+    INSERT INTO documents (surface_id, title, content) VALUES ('doc-1', 'Doc', 'body');
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function insertSnapshot(sqlite: Database, revision: number): void {
+  sqlite
+    .query(
+      /*sql*/ `INSERT INTO document_revisions (surface_id, revision, title, content, author, created_at)
+       VALUES ('doc-1', ?, 'Doc', 'body', 'user', 1000)`,
+    )
+    .run(revision);
+}
+
+describe("migration 385: document_revisions", () => {
+  test("creates the table keyed by (surface_id, revision)", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateCreateDocumentRevisions(db);
+
+    insertSnapshot(sqlite, 1);
+    expect(() => insertSnapshot(sqlite, 1)).toThrow(/UNIQUE/);
+  });
+
+  test("cascades from documents", () => {
+    const { sqlite, db } = createTestDb();
+    migrateCreateDocumentRevisions(db);
+    insertSnapshot(sqlite, 1);
+
+    sqlite.run("DELETE FROM documents WHERE surface_id = 'doc-1'");
+
+    const row = sqlite
+      .query("SELECT COUNT(*) AS n FROM document_revisions")
+      .get() as { n: number };
+    expect(row.n).toBe(0);
+  });
+
+  test("is idempotent", () => {
+    const { sqlite, db } = createTestDb();
+    migrateCreateDocumentRevisions(db);
+    insertSnapshot(sqlite, 1);
+
+    expect(() => migrateCreateDocumentRevisions(db)).not.toThrow();
+
+    const row = sqlite
+      .query("SELECT COUNT(*) AS n FROM document_revisions")
+      .get() as { n: number };
+    expect(row.n).toBe(1);
+  });
+});

package/src/persistence/migrations/385-create-document-revisions.ts

@@ -0,0 +1,28 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Create `document_revisions`: snapshots of a document's title and body as
+ * they stood at a given revision, taken just before a write replaces them.
+ *
+ * `(surface_id, revision)` is the primary key, so a state is stored at most
+ * once. The FK cascades from `documents`, so deleting a document drops its
+ * history.
+ *
+ * Idempotent: `IF NOT EXISTS` makes a re-run a no-op.
+ */
+export function migrateCreateDocumentRevisions(database: DrizzleDb): void {
+  getSqliteFrom(database).exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS document_revisions (
+      surface_id TEXT NOT NULL,
+      revision INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      author TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (surface_id, revision),
+      FOREIGN KEY (surface_id) REFERENCES documents(surface_id) ON DELETE CASCADE
+    )
+  `);
+}

package/src/persistence/migrations/386-conversations-last-reopened-at.ts

@@ -0,0 +1,10 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+export function migrateConversationsLastReopenedAt(database: DrizzleDb): void {
+  if (!tableHasColumn(database, "conversations", "last_reopened_at")) {
+    getSqliteFrom(database).exec(
+      "ALTER TABLE conversations ADD COLUMN last_reopened_at INTEGER",
+    );
+  }
+}

package/src/persistence/migrations/__tests__/386-conversations-last-reopened-at.test.ts

@@ -0,0 +1,32 @@
+import { Database } from "bun:sqlite";
+import { expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../../schema/index.js";
+import { migrateConversationsLastReopenedAt } from "../386-conversations-last-reopened-at.js";
+
+test("adds a nullable reopen marker without changing existing chats and is idempotent", () => {
+  const sqlite = new Database(":memory:");
+  try {
+    sqlite.exec(
+      "CREATE TABLE conversations (id TEXT PRIMARY KEY, archived_at INTEGER)",
+    );
+    sqlite.exec("INSERT INTO conversations VALUES ('conv-123', 123)");
+    const db = drizzle(sqlite, { schema });
+    migrateConversationsLastReopenedAt(db);
+    migrateConversationsLastReopenedAt(db);
+    expect(sqlite.query("SELECT * FROM conversations").get()).toEqual({
+      id: "conv-123",
+      archived_at: 123,
+      last_reopened_at: null,
+    });
+    sqlite.exec("UPDATE conversations SET last_reopened_at = 456");
+    migrateConversationsLastReopenedAt(db);
+    expect(
+      sqlite.query("SELECT last_reopened_at FROM conversations").get(),
+    ).toEqual({ last_reopened_at: 456 });
+  } finally {
+    sqlite.close();
+  }
+});

package/src/persistence/schema/conversations.ts

@@ -83,6 +83,7 @@ export const conversations = sqliteTable(
     scheduleJobId: text("schedule_job_id"),
     lastMessageAt: integer("last_message_at"),
     archivedAt: integer("archived_at"),
+    lastReopenedAt: integer("last_reopened_at"),
     /**
      * Epoch-ms timestamp set when a background/scheduled conversation is
      * explicitly promoted into the sidebar's Recents grouping. NULL (the

package/src/persistence/schema/documents.ts

@@ -22,6 +22,8 @@ export const documents = sqliteTable(
     wordCount: integer("word_count").notNull().default(0),
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
+    // Bumped by one on every write; conditional saves compare against it.
+    revision: integer("revision").notNull().default(0),
     // Unused by the daemon: no code reads or writes the column, and some rows
     // carry a non-NULL path. It stays in the model because migration 360 puts
     // it in the physical table and the model must keep describing that table.
@@ -78,3 +80,21 @@ export const documentComments = sqliteTable(
     index("idx_document_comments_parent").on(table.parentCommentId),
   ],
 );
+
+// Snapshots of a document as it stood at `revision`, taken just before a write
+// replaced that state. `author` is who made the replacing write.
+export const documentRevisions = sqliteTable(
+  "document_revisions",
+  {
+    surfaceId: text("surface_id")
+      .notNull()
+      .references(() => documents.surfaceId, { onDelete: "cascade" }),
+    revision: integer("revision").notNull(),
+    title: text("title").notNull(),
+    content: text("content").notNull(),
+    wordCount: integer("word_count").notNull().default(0),
+    author: text("author").notNull(),
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [primaryKey({ columns: [table.surfaceId, table.revision] })],
+);

package/src/persistence/steps.ts

@@ -494,6 +494,9 @@ import {
 } from "./migrations/381-create-conversation-mode-sessions.js";
 import { migrateCreateClientConnectionEvents } from "./migrations/382-create-client-connection-events.js";
 import { migrateNormalizeOpencodeHostConnections } from "./migrations/383-normalize-opencode-host-connections.js";
+import { migrateAddDocumentRevision } from "./migrations/384-add-document-revision.js";
+import { migrateCreateDocumentRevisions } from "./migrations/385-create-document-revisions.js";
+import { migrateConversationsLastReopenedAt } from "./migrations/386-conversations-last-reopened-at.js";
 import type { MigrationStep } from "./migrations/run-migrations.js";
 
 export const migrationSteps: MigrationStep[] = [
@@ -1661,4 +1664,7 @@ export const migrationSteps: MigrationStep[] = [
       "migrateProviderConnectionBaseUrlAndModels",
     ],
   },
+  migrateAddDocumentRevision,
+  migrateCreateDocumentRevisions,
+  migrateConversationsLastReopenedAt,
 ];

package/src/platform/managed-speech.ts

@@ -17,6 +17,8 @@
  * imports — the vellum STT/TTS providers build on top of it.
  */
 
+import { z } from "zod";
+
 import { VellumPlatformClient } from "./client.js";
 
 export type ManagedSpeechResult<T> =
@@ -43,6 +45,11 @@ export interface ManagedSpeechTranscription {
   durationSeconds: number;
 }
 
+const ManagedSpeechTranscriptionSchema = z.object({
+  text: z.string(),
+  durationSeconds: z.number(),
+});
+
 export interface ManagedSpeechSynthesis {
   audio: Buffer;
   contentType: string;
@@ -125,13 +132,10 @@ export async function managedSpeechTranscribe(input: {
     return await platformError(response, "transcription");
   }
 
-  const body: unknown = await response.json().catch(() => null);
-  if (
-    !body ||
-    typeof body !== "object" ||
-    typeof (body as { text?: unknown }).text !== "string" ||
-    typeof (body as { durationSeconds?: unknown }).durationSeconds !== "number"
-  ) {
+  const parsed = ManagedSpeechTranscriptionSchema.safeParse(
+    await response.json().catch(() => null),
+  );
+  if (!parsed.success) {
     return {
       ok: false,
       kind: "platform-error",
@@ -139,10 +143,12 @@ export async function managedSpeechTranscribe(input: {
       message: "Managed speech transcription returned a malformed response.",
     };
   }
-  const parsed = body as { text: string; durationSeconds: number };
   return {
     ok: true,
-    value: { text: parsed.text, durationSeconds: parsed.durationSeconds },
+    value: {
+      text: parsed.data.text,
+      durationSeconds: parsed.data.durationSeconds,
+    },
   };
 }
 
@@ -211,25 +217,21 @@ export interface ManagedSpeechVoiceCatalog {
   defaultModel: string | null;
 }
 
-function parseVoice(value: unknown): ManagedSpeechVoice | null {
-  const voice = value as Partial<Record<keyof ManagedSpeechVoice, unknown>>;
-  if (
-    typeof voice?.model !== "string" ||
-    typeof voice.label !== "string" ||
-    typeof voice.description !== "string" ||
-    typeof voice.sampleUrl !== "string" ||
-    typeof voice.source !== "string"
-  ) {
-    return null;
-  }
-  return {
-    model: voice.model,
-    label: voice.label,
-    description: voice.description,
-    sampleUrl: voice.sampleUrl,
-    source: voice.source,
-  };
-}
+const ManagedSpeechVoiceSchema = z.object({
+  model: z.string(),
+  label: z.string(),
+  description: z.string(),
+  sampleUrl: z.string(),
+  source: z.string(),
+});
+const ManagedSpeechVoiceCatalogSchema = z.object({
+  voices: z.array(ManagedSpeechVoiceSchema.nullable().catch(null)),
+  defaultModel: z.string().nullable().optional().catch(null),
+});
+const ManagedSpeechErrorSchema = z.object({
+  code: z.string().optional().catch(undefined),
+  detail: z.string().optional().catch(undefined),
+});
 
 export async function managedSpeechVoices(input?: {
   signal?: AbortSignal;
@@ -249,12 +251,10 @@ export async function managedSpeechVoices(input?: {
     return await platformError(response, "voice listing");
   }
 
-  const body: unknown = await response.json().catch(() => null);
-  const raw = body as { voices?: unknown; defaultModel?: unknown } | null;
-  const voices = Array.isArray(raw?.voices)
-    ? raw.voices.map(parseVoice).filter((v): v is ManagedSpeechVoice => !!v)
-    : null;
-  if (!voices) {
+  const parsed = ManagedSpeechVoiceCatalogSchema.safeParse(
+    await response.json().catch(() => null),
+  );
+  if (!parsed.success) {
     return {
       ok: false,
       kind: "platform-error",
@@ -265,9 +265,10 @@ export async function managedSpeechVoices(input?: {
   return {
     ok: true,
     value: {
-      voices,
-      defaultModel:
-        typeof raw?.defaultModel === "string" ? raw.defaultModel : null,
+      voices: parsed.data.voices.filter(
+        (voice): voice is ManagedSpeechVoice => voice !== null,
+      ),
+      defaultModel: parsed.data.defaultModel ?? null,
     },
   };
 }
@@ -279,15 +280,10 @@ async function platformError(
   let code: string | undefined;
   let detail: string | undefined;
   try {
-    const body = (await response.json()) as {
-      code?: unknown;
-      detail?: unknown;
-    };
-    if (typeof body?.code === "string") {
-      code = body.code;
-    }
-    if (typeof body?.detail === "string") {
-      detail = body.detail;
+    const parsed = ManagedSpeechErrorSchema.safeParse(await response.json());
+    if (parsed.success) {
+      code = parsed.data.code;
+      detail = parsed.data.detail;
     }
   } catch {
     // Non-JSON error body; status alone will have to do.

package/src/plugin-api/vision-support.test.ts

@@ -91,7 +91,7 @@ describe("doesSupportVision", () => {
     setMockConfig({
       "text-profile": {
         provider: "fireworks",
-        model: "accounts/fireworks/models/glm-5p2",
+        model: "accounts/fireworks/models/glm-5p3",
       },
     });
     expect(doesSupportVision(profile("text-profile"))).toBe(false);
@@ -162,7 +162,7 @@ describe("doesSupportVision", () => {
       managed: { provider: "vellum", model: "claude-fable-5" },
       "managed-text": {
         provider: "vellum",
-        model: "accounts/fireworks/models/deepseek-v4-flash-0731",
+        model: "accounts/fireworks/models/glm-5p3",
       },
     });
     expect(doesSupportVision(profile("managed"))).toBe(true);
@@ -186,7 +186,7 @@ describe("doesSupportVision", () => {
       },
       "text-arm": {
         provider: "fireworks",
-        model: "accounts/fireworks/models/glm-5p2",
+        model: "accounts/fireworks/models/glm-5p3",
       },
       "vision-arm": { provider: "anthropic", model: "claude-opus-4-6" },
     });
@@ -203,7 +203,7 @@ describe("doesSupportVision", () => {
       },
       "text-arm": {
         provider: "fireworks",
-        model: "accounts/fireworks/models/glm-5p2",
+        model: "accounts/fireworks/models/glm-5p3",
       },
       "gateway-arm": {
         provider: "openai-compatible",
@@ -224,11 +224,11 @@ describe("doesSupportVision", () => {
       },
       "text-arm-1": {
         provider: "fireworks",
-        model: "accounts/fireworks/models/glm-5p2",
+        model: "accounts/fireworks/models/glm-5p3",
       },
       "text-arm-2": {
         provider: "fireworks",
-        model: "accounts/fireworks/models/glm-5p2",
+        model: "accounts/fireworks/models/glm-5p3",
       },
     });
     expect(doesSupportVision(profile("mix-profile"))).toBe(false);
@@ -237,19 +237,19 @@ describe("doesSupportVision", () => {
 
 describe("doesSupportVision with a BYO default provider", () => {
   test("judges a default profile against the default provider's column model", () => {
-    // Managed/vellum column: cost-optimized → deepseek-v4-flash (text-only,
-    // supportsVision: false). Anthropic column: cost-optimized carries
-    // intent "latency-optimized" → claude-haiku-4-5 (supportsVision: true).
+    // Managed/vellum column: cost-optimized → deepseek-v4p1-flash
+    // (supportsVision: true). OpenRouter column: cost-optimized →
+    // deepseek/deepseek-v4-flash (text-only, supportsVision: false).
     // The judged model must be the one the BYO install actually runs.
-    setMockConfig({}, { provider: "anthropic" });
-    expect(doesSupportVision(profile("cost-optimized"))).toBe(true);
+    setMockConfig({}, { provider: "openrouter" });
+    expect(doesSupportVision(profile("cost-optimized"))).toBe(false);
   });
 
   test("without a default provider, a default profile judges the managed column", () => {
     // Null-reduction: no defaultProvider resolves cost-optimized through the
-    // vellum column (deepseek-v4-flash, text-only).
+    // vellum column (deepseek-v4p1-flash, vision-capable).
     setMockConfig({});
-    expect(doesSupportVision(profile("cost-optimized"))).toBe(false);
+    expect(doesSupportVision(profile("cost-optimized"))).toBe(true);
   });
 
   test("mix arms naming a default profile resolve through the same column", () => {
@@ -263,14 +263,14 @@ describe("doesSupportVision with a BYO default provider", () => {
         },
         "text-arm": {
           provider: "fireworks",
-          model: "accounts/fireworks/models/glm-5p2",
+          model: "accounts/fireworks/models/glm-5p3",
         },
       },
-      { provider: "anthropic" },
+      { provider: "openrouter" },
     );
-    // The "cost-optimized" arm resolves to the anthropic column's
-    // vision-capable model, so the mix can route to vision.
-    expect(doesSupportVision(profile("mix-profile"))).toBe(true);
+    // The "cost-optimized" arm resolves to the openrouter column's
+    // text-only model, so no arm of the mix can route to vision.
+    expect(doesSupportVision(profile("mix-profile"))).toBe(false);
   });
 
   test("a user-owned profile is unaffected by the default provider", () => {
@@ -278,7 +278,7 @@ describe("doesSupportVision with a BYO default provider", () => {
       {
         "custom-text": {
           provider: "fireworks",
-          model: "accounts/fireworks/models/glm-5p2",
+          model: "accounts/fireworks/models/glm-5p3",
         },
       },
       { provider: "anthropic" },
@@ -369,7 +369,7 @@ describe("doesSupportVision with a bare string", () => {
   });
 
   test("returns false for a known text-only model id", () => {
-    expect(doesSupportVision("accounts/fireworks/models/glm-5p2")).toBe(false);
+    expect(doesSupportVision("accounts/fireworks/models/glm-5p3")).toBe(false);
   });
 
   test("falls back to resolving the string as a profile key", () => {
@@ -403,7 +403,7 @@ describe("doesSupportVision with a resolved target", () => {
     expect(
       doesSupportVision({
         provider: "fireworks",
-        model: "accounts/fireworks/models/glm-5p2",
+        model: "accounts/fireworks/models/glm-5p3",
         inputModalities: { image: { enabled: true, supported: true } },
       }),
     ).toBe(true);

package/src/plugins/defaults/empty-response/hooks/post-model-call.ts

@@ -203,12 +203,17 @@ const postModelCall: HookFunction<PostModelCallContext> = async (ctx) => {
     !priorAssistantHadVisibleText;
 
   if (isEmptyTurnAfterTools) {
-    // Only the user-facing reply gets the re-query nudge. Background, subagent,
-    // and compaction calls have no user awaiting a summary, and the
-    // post-model-call contract requires self-gating on call site to avoid
-    // re-querying them. The refusal-rewrite above is a user-facing terminal
-    // fallback, not a re-query, so it stays ungated.
-    if (ctx.callSite !== "mainAgent") {
+    // Only the user-facing reply and subagent runs get the re-query nudge.
+    // Background and compaction calls have no consumer awaiting a summary, and
+    // the post-model-call contract requires self-gating on call site to avoid
+    // re-querying them. Subagents DO need the nudge: without it, an empty
+    // model response after a tool result makes the agent loop exit via
+    // "no_tool_calls" and the runner reports the subagent as `completed` with
+    // empty output — a silent failure the parent can't distinguish from a
+    // real result (see vellum-ai/vellum-assistant#43327). The refusal-rewrite
+    // above is a user-facing terminal fallback, not a re-query, so it stays
+    // ungated.
+    if (ctx.callSite !== "mainAgent" && ctx.callSite !== "subagentSpawn") {
       return;
     }
 

package/src/providers/__tests__/dispatch-connection-routing.test.ts

@@ -374,7 +374,7 @@ describe("routing identities", () => {
       expectedProvider: "anthropic",
     });
     expect(
-      resolveRoutingIdentity("vellum", "accounts/fireworks/models/glm-5p2"),
+      resolveRoutingIdentity("vellum", "accounts/fireworks/models/glm-5p3"),
     ).toEqual({ connectionName: "vellum", expectedProvider: "fireworks" });
     expect(resolveRoutingIdentity("vellum", "qwen/qwen3-8b")).toEqual({
       connectionName: "vellum",

package/src/providers/__tests__/search-provider-catalog.test.ts

@@ -112,4 +112,12 @@ describe("search-provider-catalog", () => {
     expect(exa?.supportsApiBase).toBeUndefined();
     expect(exa?.envVar).toBe("EXA_API_KEY");
   });
+
+  test("Serply is a keyed BYOK provider without a custom API base", () => {
+    const serply = getSearchProvider("serply");
+    expect(serply?.kind).toBe("byok");
+    expect(serply?.keyless).toBeUndefined();
+    expect(serply?.supportsApiBase).toBeUndefined();
+    expect(serply?.envVar).toBe("SERPLY_API_KEY");
+  });
 });

package/src/providers/__tests__/unparseable-tool-args.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  boundUnparseableToolArgs,
+  boundUnparseableToolArgsRaw,
   isUnparseableToolArgs,
   unparseableToolArgsMessage,
   wrapUnparseableToolArgs,
@@ -31,6 +33,29 @@ describe("unparseable tool args marker", () => {
     expect(isUnparseableToolArgs({})).toBe(false);
   });
 
+  test("bounds long raw args while preserving the marker shape", () => {
+    const raw = "a".repeat(1_000);
+    const bounded = boundUnparseableToolArgs(wrapUnparseableToolArgs(raw));
+
+    expect(isUnparseableToolArgs(bounded)).toBe(true);
+    expect(bounded).toEqual({ _raw: "a".repeat(200) + "…" });
+  });
+
+  test("bounds raw diagnostic copies with the same preview contract", () => {
+    expect(boundUnparseableToolArgsRaw("a".repeat(1_000))).toBe(
+      "a".repeat(200) + "…",
+    );
+    expect(boundUnparseableToolArgsRaw("short")).toBe("short");
+  });
+
+  test("leaves short markers and ordinary input unchanged", () => {
+    const marker = wrapUnparseableToolArgs("short");
+    const ordinary = { command: "ls" };
+
+    expect(boundUnparseableToolArgs(marker)).toBe(marker);
+    expect(boundUnparseableToolArgs(ordinary)).toBe(ordinary);
+  });
+
   test("message includes tool name, raw preview, and retry instruction", () => {
     const msg = unparseableToolArgsMessage("ui_show", '{"surface_type": ');
     expect(msg).toContain('"ui_show"');

package/src/providers/anthropic/client.ts

@@ -1008,7 +1008,7 @@ export class AnthropicProvider implements Provider {
       const isHaiku = effectiveModel.includes("haiku");
       // Effort support is per-model: Haiku and Sonnet 4.5 reject the param (see isEffortSupported).
       const supportsEffort = isEffortSupported(effectiveModel);
-      // opus-4-7 / opus-4-8 / opus-5 / opus-5-5 and sonnet-5 reject `temperature`,
+      // opus-4-7 / opus-4-8 / opus-5 / opus-5-5 and sonnet-5 / sonnet-5-5 reject `temperature`,
       // `top_p`, and `top_k` with a 400 "`temperature`/`top_p` is deprecated
       // for this model" — model-wide, not effort-conditional (verified
       // 2026-06-23). opus-4-6 / sonnet-4-6 / haiku-4-5 still accept them.