@vellumai/assistant 0.8.6 → 0.8.7

package/src/workspace/migrations/094-seed-avatar-manifest.ts

@@ -0,0 +1,155 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger("094-seed-avatar-manifest");
+
+// Filenames are inlined to keep this migration self-contained (see AGENTS.md).
+// They mirror the canonical constants in util/platform.ts and avatar-manifest.ts.
+const TRAITS_FILENAME = "character-traits.json";
+const AVATAR_IMAGE_FILENAME = "avatar-image.png";
+const AVATAR_MANIFEST_FILENAME = "avatar.json";
+
+type AvatarKind = "character" | "image" | "none";
+type AvatarSource = "builder" | "upload" | "ai";
+
+interface AvatarImageMeta {
+  updatedAt: string;
+  etag: string;
+}
+
+interface CharacterTraits {
+  bodyShape: string;
+  eyeStyle: string;
+  color: string;
+}
+
+interface AvatarState {
+  kind: AvatarKind;
+  traits: CharacterTraits | null;
+  source: AvatarSource | null;
+  image: AvatarImageMeta | null;
+}
+
+/** Narrows an unknown value to valid CharacterTraits (presence check only). */
+function isValidTraits(value: unknown): value is CharacterTraits {
+  if (!value || typeof value !== "object") return false;
+  const t = value as Record<string, unknown>;
+  return (
+    typeof t.bodyShape === "string" &&
+    !!t.bodyShape &&
+    typeof t.eyeStyle === "string" &&
+    !!t.eyeStyle &&
+    typeof t.color === "string" &&
+    !!t.color
+  );
+}
+
+/** Computes a stable etag for the avatar image from its size and mtime. */
+function computeImageEtag(sizeBytes: number, mtimeMs: number): string {
+  return createHash("sha256")
+    .update(`${sizeBytes}:${mtimeMs}`)
+    .digest("hex")
+    .slice(0, 16);
+}
+
+/**
+ * Derives avatar state from the legacy sidecar files (traits JSON + PNG).
+ *
+ * Inference is **traits-first**: whenever a valid `character-traits.json`
+ * exists, the result is `character` regardless of whether a PNG is also
+ * present. We deliberately do NOT compare mtimes to break the both-present
+ * tie, because the builder writes the rendered PNG *after* the traits file, so
+ * the PNG is always newer even when the character is the source of truth.
+ *
+ * Inlined from avatar-manifest.ts to keep this migration self-contained.
+ */
+function deriveStateFromLegacyFiles(avatarDir: string): AvatarState {
+  const traitsPath = join(avatarDir, TRAITS_FILENAME);
+  if (existsSync(traitsPath)) {
+    try {
+      const traits = JSON.parse(readFileSync(traitsPath, "utf-8")) as unknown;
+      if (isValidTraits(traits)) {
+        return { kind: "character", traits, source: null, image: null };
+      }
+    } catch (err) {
+      log.warn(
+        { err },
+        "Corrupt character-traits.json — falling back to image/none",
+      );
+    }
+  }
+
+  const imagePath = join(avatarDir, AVATAR_IMAGE_FILENAME);
+  if (existsSync(imagePath)) {
+    const stats = statSync(imagePath);
+    return {
+      kind: "image",
+      traits: null,
+      source: null,
+      image: {
+        updatedAt: new Date(stats.mtimeMs).toISOString(),
+        etag: computeImageEtag(stats.size, stats.mtimeMs),
+      },
+    };
+  }
+
+  return { kind: "none", traits: null, source: null, image: null };
+}
+
+/**
+ * Writes the avatar manifest atomically (tmp-write + rename), mirroring the
+ * write pattern in avatar-manifest.ts. Inlined to keep this migration
+ * self-contained.
+ */
+function writeManifest(state: AvatarState, avatarDir: string): void {
+  mkdirSync(avatarDir, { recursive: true });
+  const manifestPath = join(avatarDir, AVATAR_MANIFEST_FILENAME);
+  const tmp = `${manifestPath}.${randomUUID()}.tmp`;
+  writeFileSync(tmp, JSON.stringify(state, null, 2));
+  renameSync(tmp, manifestPath);
+}
+
+export const seedAvatarManifestMigration: WorkspaceMigration = {
+  id: "094-seed-avatar-manifest",
+  description:
+    "Seed avatar.json from legacy sidecar files (traits-first), backfilling existing workspaces",
+  run(workspaceDir: string): void {
+    const avatarDir = join(workspaceDir, "data", "avatar");
+    const manifestPath = join(avatarDir, AVATAR_MANIFEST_FILENAME);
+
+    // Idempotent: if a manifest already exists, leave it untouched.
+    if (existsSync(manifestPath)) return;
+
+    const state = deriveStateFromLegacyFiles(avatarDir);
+
+    // Only seed a manifest for a *real* avatar (character/image). An avatar-less
+    // workspace derives { kind: "none" }; we deliberately do NOT write that, so
+    // the workspace stays manifest-less and the read-time self-heal can still
+    // pick up a later legacy sidecar write (older clients / automation that set
+    // an avatar via the generic workspace-file API) instead of being shadowed by
+    // a stale `none` manifest. "No avatar" == absence of avatar.json everywhere.
+    if (state.kind === "none") return;
+
+    writeManifest(state, avatarDir);
+  },
+  down(workspaceDir: string): void {
+    const avatarDir = join(workspaceDir, "data", "avatar");
+    const manifestPath = join(avatarDir, AVATAR_MANIFEST_FILENAME);
+    // Remove only the manifest; leave legacy files intact so the old
+    // heuristic/fallback still works on rollback. `force` makes this
+    // idempotent (no-op when the manifest is already gone).
+    rmSync(manifestPath, { force: true });
+  },
+};

package/src/workspace/migrations/__tests__/094-seed-avatar-manifest.test.ts

@@ -0,0 +1,136 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { seedAvatarManifestMigration } from "../094-seed-avatar-manifest.js";
+
+const VALID_TRAITS = {
+  bodyShape: "round",
+  eyeStyle: "wide",
+  color: "#123456",
+};
+
+let workspaceDir: string;
+let avatarDir: string;
+let manifestPath: string;
+
+function readManifest(): Record<string, unknown> {
+  return JSON.parse(readFileSync(manifestPath, "utf-8")) as Record<
+    string,
+    unknown
+  >;
+}
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "seed-avatar-manifest-"));
+  avatarDir = join(workspaceDir, "data", "avatar");
+  mkdirSync(avatarDir, { recursive: true });
+  manifestPath = join(avatarDir, "avatar.json");
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+describe("094-seed-avatar-manifest", () => {
+  test("has a unique, expected id", () => {
+    expect(seedAvatarManifestMigration.id).toBe("094-seed-avatar-manifest");
+  });
+
+  test("traits only → character", () => {
+    writeFileSync(
+      join(avatarDir, "character-traits.json"),
+      JSON.stringify(VALID_TRAITS),
+    );
+
+    seedAvatarManifestMigration.run(workspaceDir);
+
+    const manifest = readManifest();
+    expect(manifest.kind).toBe("character");
+    expect(manifest.traits).toEqual(VALID_TRAITS);
+    expect(manifest.image).toBeNull();
+  });
+
+  test("image only → image", () => {
+    writeFileSync(join(avatarDir, "avatar-image.png"), "fake-png-bytes");
+
+    seedAvatarManifestMigration.run(workspaceDir);
+
+    const manifest = readManifest();
+    expect(manifest.kind).toBe("image");
+    expect(manifest.traits).toBeNull();
+    const image = manifest.image as Record<string, unknown>;
+    expect(typeof image.updatedAt).toBe("string");
+    expect(typeof image.etag).toBe("string");
+  });
+
+  test("both present → character (traits-first)", () => {
+    writeFileSync(
+      join(avatarDir, "character-traits.json"),
+      JSON.stringify(VALID_TRAITS),
+    );
+    writeFileSync(join(avatarDir, "avatar-image.png"), "fake-png-bytes");
+
+    seedAvatarManifestMigration.run(workspaceDir);
+
+    const manifest = readManifest();
+    expect(manifest.kind).toBe("character");
+    expect(manifest.traits).toEqual(VALID_TRAITS);
+    expect(manifest.image).toBeNull();
+  });
+
+  test("neither present → no manifest written (none == absence of avatar.json)", () => {
+    seedAvatarManifestMigration.run(workspaceDir);
+
+    // An avatar-less workspace must stay manifest-less so a later legacy sidecar
+    // write is still picked up by the read-time self-heal.
+    expect(existsSync(manifestPath)).toBe(false);
+  });
+
+  test("re-run is a no-op (does not overwrite an existing manifest)", () => {
+    // Seed an image-derived manifest first.
+    writeFileSync(join(avatarDir, "avatar-image.png"), "fake-png-bytes");
+    seedAvatarManifestMigration.run(workspaceDir);
+    const first = readFileSync(manifestPath, "utf-8");
+
+    // Now add traits — a fresh derivation would flip to character, but the
+    // migration must leave the existing manifest untouched.
+    writeFileSync(
+      join(avatarDir, "character-traits.json"),
+      JSON.stringify(VALID_TRAITS),
+    );
+    seedAvatarManifestMigration.run(workspaceDir);
+
+    expect(readFileSync(manifestPath, "utf-8")).toBe(first);
+    expect((JSON.parse(first) as Record<string, unknown>).kind).toBe("image");
+  });
+
+  test("down() removes only avatar.json (legacy files remain)", () => {
+    const traitsPath = join(avatarDir, "character-traits.json");
+    const imagePath = join(avatarDir, "avatar-image.png");
+    writeFileSync(traitsPath, JSON.stringify(VALID_TRAITS));
+    writeFileSync(imagePath, "fake-png-bytes");
+
+    seedAvatarManifestMigration.run(workspaceDir);
+    expect(existsSync(manifestPath)).toBe(true);
+
+    seedAvatarManifestMigration.down(workspaceDir);
+
+    expect(existsSync(manifestPath)).toBe(false);
+    expect(existsSync(traitsPath)).toBe(true);
+    expect(existsSync(imagePath)).toBe(true);
+  });
+
+  test("down() is idempotent when no manifest exists", () => {
+    expect(() => seedAvatarManifestMigration.down(workspaceDir)).not.toThrow();
+    expect(existsSync(manifestPath)).toBe(false);
+  });
+});

package/src/workspace/migrations/__tests__/backfill-leaf-ids.test.ts

@@ -0,0 +1,175 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+
+import { parse as parseYaml } from "yaml";
+
+import { backfillLeafIdsMigration } from "../093-backfill-leaf-ids.js";
+
+const LEAVES_REL = join("memory", "v3", "data", "leaves");
+
+function leafPath(workspaceDir: string, rel: string): string {
+  return join(workspaceDir, LEAVES_REL, rel);
+}
+
+function writeLeaf(
+  workspaceDir: string,
+  rel: string,
+  frontmatter: Record<string, unknown>,
+  body: string,
+): void {
+  const full = leafPath(workspaceDir, rel);
+  mkdirSync(dirname(full), { recursive: true });
+  const fm = Object.entries(frontmatter)
+    .map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
+    .join("\n");
+  writeFileSync(full, `---\n${fm}\n---\n${body}`, "utf8");
+}
+
+function readLeaf(
+  workspaceDir: string,
+  rel: string,
+): { frontmatter: Record<string, unknown>; body: string } {
+  const raw = readFileSync(leafPath(workspaceDir, rel), "utf8");
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+  if (!match) throw new Error(`leaf ${rel} lost its frontmatter`);
+  return {
+    frontmatter: parseYaml(match[1]) as Record<string, unknown>,
+    body: match[2],
+  };
+}
+
+describe("093-backfill-leaf-ids migration", () => {
+  let workspaceDir: string;
+
+  beforeEach(() => {
+    workspaceDir = mkdtempSync(join(tmpdir(), "backfill-leaf-ids-"));
+  });
+
+  afterEach(() => {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  });
+
+  it("is a no-op when the leaves dir is absent", () => {
+    expect(() => backfillLeafIdsMigration.run(workspaceDir)).not.toThrow();
+  });
+
+  it("backfills a stable, unique id into every leaf lacking one", () => {
+    writeLeaf(
+      workspaceDir,
+      "domain-a/topic-x.md",
+      { path: "domain-a/topic-x", in_core: true },
+      "First leaf description.\n",
+    );
+    writeLeaf(
+      workspaceDir,
+      "domain-b/nested/topic-y.md",
+      { path: "domain-b/nested/topic-y", in_core: false },
+      "Second leaf description.\n",
+    );
+
+    backfillLeafIdsMigration.run(workspaceDir);
+
+    const a = readLeaf(workspaceDir, "domain-a/topic-x.md");
+    const b = readLeaf(workspaceDir, "domain-b/nested/topic-y.md");
+
+    expect(typeof a.frontmatter.id).toBe("string");
+    expect(typeof b.frontmatter.id).toBe("string");
+    expect(a.frontmatter.id).not.toBe(b.frontmatter.id);
+
+    // Preserves other frontmatter fields and the body.
+    expect(a.frontmatter.path).toBe("domain-a/topic-x");
+    expect(a.frontmatter.in_core).toBe(true);
+    expect(a.body).toBe("First leaf description.\n");
+    expect(b.frontmatter.in_core).toBe(false);
+    expect(b.body).toBe("Second leaf description.\n");
+  });
+
+  it("leaves pre-existing ids untouched", () => {
+    writeLeaf(
+      workspaceDir,
+      "domain-a/topic-x.md",
+      { path: "domain-a/topic-x", in_core: true, id: "preexisting01" },
+      "Body.\n",
+    );
+
+    backfillLeafIdsMigration.run(workspaceDir);
+
+    expect(readLeaf(workspaceDir, "domain-a/topic-x.md").frontmatter.id).toBe(
+      "preexisting01",
+    );
+  });
+
+  it("is idempotent and deterministic across re-runs", () => {
+    writeLeaf(
+      workspaceDir,
+      "domain-a/topic-x.md",
+      { path: "domain-a/topic-x", in_core: true },
+      "Body.\n",
+    );
+
+    backfillLeafIdsMigration.run(workspaceDir);
+    const firstRaw = readFileSync(
+      leafPath(workspaceDir, "domain-a/topic-x.md"),
+      "utf8",
+    );
+
+    backfillLeafIdsMigration.run(workspaceDir);
+    const secondRaw = readFileSync(
+      leafPath(workspaceDir, "domain-a/topic-x.md"),
+      "utf8",
+    );
+
+    // Re-run rewrites nothing — same id, byte-for-byte identical file.
+    expect(secondRaw).toBe(firstRaw);
+  });
+
+  it("generates the same id for the same relative path (stable)", () => {
+    writeLeaf(
+      workspaceDir,
+      "domain-a/topic-x.md",
+      { path: "domain-a/topic-x", in_core: true },
+      "Body.\n",
+    );
+    backfillLeafIdsMigration.run(workspaceDir);
+    const idA = readLeaf(workspaceDir, "domain-a/topic-x.md").frontmatter.id;
+
+    const other = mkdtempSync(join(tmpdir(), "backfill-leaf-ids-2-"));
+    try {
+      writeLeaf(
+        other,
+        "domain-a/topic-x.md",
+        { path: "domain-a/topic-x", in_core: false },
+        "Different body.\n",
+      );
+      backfillLeafIdsMigration.run(other);
+      expect(readLeaf(other, "domain-a/topic-x.md").frontmatter.id).toBe(idA);
+    } finally {
+      rmSync(other, { recursive: true, force: true });
+    }
+  });
+
+  it("down is a no-op that preserves backfilled ids", () => {
+    writeLeaf(
+      workspaceDir,
+      "domain-a/topic-x.md",
+      { path: "domain-a/topic-x", in_core: true },
+      "Body.\n",
+    );
+    backfillLeafIdsMigration.run(workspaceDir);
+    const id = readLeaf(workspaceDir, "domain-a/topic-x.md").frontmatter.id;
+
+    backfillLeafIdsMigration.down(workspaceDir);
+
+    expect(readLeaf(workspaceDir, "domain-a/topic-x.md").frontmatter.id).toBe(
+      id,
+    );
+  });
+});

package/src/workspace/migrations/__tests__/backfill-v3-leaves.test.ts

@@ -0,0 +1,124 @@
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+
+import { readPage, writePage } from "../../../memory/v2/page-store.js";
+import type { ConceptPageFrontmatter } from "../../../memory/v2/types.js";
+import { backfillV3LeavesMigration } from "../092-backfill-v3-leaves.js";
+
+describe("092 backfill v3 leaves", () => {
+  let workspaceDir: string;
+
+  beforeEach(async () => {
+    workspaceDir = await fs.mkdtemp(path.join(tmpdir(), "ws-mig-leaves-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(workspaceDir, { recursive: true, force: true });
+  });
+
+  async function writeAssignments(
+    assignments: Record<string, string[]>,
+  ): Promise<void> {
+    const dataDir = path.join(workspaceDir, "memory", "v3", "data");
+    await fs.mkdir(dataDir, { recursive: true });
+    await fs.writeFile(
+      path.join(dataDir, "assignments.json"),
+      JSON.stringify(assignments),
+      "utf8",
+    );
+  }
+
+  async function seedPage(
+    slug: string,
+    frontmatter: Partial<ConceptPageFrontmatter> = {},
+    body = "Body text.\n",
+  ): Promise<void> {
+    await writePage(workspaceDir, {
+      slug,
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        ref_urls: [],
+        ...frontmatter,
+      },
+      body,
+    });
+  }
+
+  it("backfills leaves from assignments.json onto assigned pages", async () => {
+    await writeAssignments({
+      "page-a": ["domain-a/topic-x", "domain-a/topic-y"],
+      "page-b": ["domain-b/topic-z"],
+    });
+    await seedPage("page-a", { summary: "Page A summary" });
+    await seedPage("page-b");
+
+    await backfillV3LeavesMigration.run(workspaceDir);
+
+    const pageA = await readPage(workspaceDir, "page-a");
+    const pageB = await readPage(workspaceDir, "page-b");
+    expect(pageA?.frontmatter.leaves).toEqual([
+      "domain-a/topic-x",
+      "domain-a/topic-y",
+    ]);
+    expect(pageB?.frontmatter.leaves).toEqual(["domain-b/topic-z"]);
+    // Other frontmatter and body preserved.
+    expect(pageA?.frontmatter.summary).toBe("Page A summary");
+    expect(pageA?.body).toContain("Body text.");
+  });
+
+  it("never clobbers a page that already has non-empty leaves", async () => {
+    await writeAssignments({ "page-a": ["domain-a/topic-new"] });
+    await seedPage("page-a", { leaves: ["domain-a/topic-existing"] });
+
+    await backfillV3LeavesMigration.run(workspaceDir);
+
+    const pageA = await readPage(workspaceDir, "page-a");
+    expect(pageA?.frontmatter.leaves).toEqual(["domain-a/topic-existing"]);
+  });
+
+  it("fills a page whose leaves field is present but empty", async () => {
+    await writeAssignments({ "page-a": ["domain-a/topic-x"] });
+    await seedPage("page-a", { leaves: [] });
+
+    await backfillV3LeavesMigration.run(workspaceDir);
+
+    const pageA = await readPage(workspaceDir, "page-a");
+    expect(pageA?.frontmatter.leaves).toEqual(["domain-a/topic-x"]);
+  });
+
+  it("is idempotent across re-runs", async () => {
+    await writeAssignments({ "page-a": ["domain-a/topic-x"] });
+    await seedPage("page-a");
+
+    await backfillV3LeavesMigration.run(workspaceDir);
+    const pagePath = path.join(workspaceDir, "memory", "concepts", "page-a.md");
+    const first = await fs.readFile(pagePath, "utf8");
+
+    await backfillV3LeavesMigration.run(workspaceDir);
+    const second = await fs.readFile(pagePath, "utf8");
+
+    expect(second).toBe(first);
+  });
+
+  it("skips slugs that have no matching page", async () => {
+    await writeAssignments({ "page-missing": ["domain-a/topic-x"] });
+
+    // Should not throw even though no page exists for the slug.
+    await backfillV3LeavesMigration.run(workspaceDir);
+
+    const missing = await readPage(workspaceDir, "page-missing");
+    expect(missing).toBeNull();
+  });
+
+  it("is a no-op when assignments.json is absent", async () => {
+    await seedPage("page-a");
+
+    await backfillV3LeavesMigration.run(workspaceDir);
+
+    const pageA = await readPage(workspaceDir, "page-a");
+    expect(pageA?.frontmatter.leaves).toBeUndefined();
+  });
+});

package/src/workspace/migrations/registry.ts

@@ -89,6 +89,9 @@ import { deprecateBackgroundConversationOverrideMigration } from "./088-deprecat
 import { moveMemoryTreeOutOfV3Migration } from "./089-move-memory-tree-out-of-v3.js";
 import { memoryRouterCostOptimizedProfileMigration } from "./090-memory-router-cost-optimized-profile.js";
 import { retightenMigrationOnboardingThreadMigration } from "./091-retighten-migration-onboarding-thread.js";
+import { backfillV3LeavesMigration } from "./092-backfill-v3-leaves.js";
+import { backfillLeafIdsMigration } from "./093-backfill-leaf-ids.js";
+import { seedAvatarManifestMigration } from "./094-seed-avatar-manifest.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -189,4 +192,7 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   moveMemoryTreeOutOfV3Migration,
   memoryRouterCostOptimizedProfileMigration,
   retightenMigrationOnboardingThreadMigration,
+  backfillV3LeavesMigration,
+  backfillLeafIdsMigration,
+  seedAvatarManifestMigration,
 ];

package/src/workspace/provider-commit-message-generator.ts

@@ -147,7 +147,9 @@ class ProviderCommitMessageGenerator {
         return buildDeterministicResult(context, "missing_provider_api_key");
       }
       log.debug(
-        { provider: resolveCallSiteConfig("commitMessage", config.llm).provider },
+        {
+          provider: resolveCallSiteConfig("commitMessage", config.llm).provider,
+        },
         "Provider not initialized; falling back to deterministic",
       );
       return buildDeterministicResult(context, "provider_not_initialized");
@@ -234,23 +236,19 @@ class ProviderCommitMessageGenerator {
 
       let response;
       try {
-        response = await provider.sendMessage(
-          messages,
-          undefined,
-          SYSTEM_PROMPT,
-          {
-            signal: ac.signal,
-            config: {
-              // `callSite` lets the provider resolve model, max_tokens, and
-              // temperature from `llm.callSites.commitMessage` (with
-              // `llm.default` as the fallback). Operational fields
-              // (`enabled`, `timeoutMs`, `breaker`, `maxFilesInPrompt`,
-              // `maxDiffBytes`, `minRemainingTurnBudgetMs`) remain on
-              // `workspaceGit.commitMessageLLM` and are read above.
-              callSite: "commitMessage",
-            },
+        response = await provider.sendMessage(messages, {
+          systemPrompt: SYSTEM_PROMPT,
+          signal: ac.signal,
+          config: {
+            // `callSite` lets the provider resolve model, max_tokens, and
+            // temperature from `llm.callSites.commitMessage` (with
+            // `llm.default` as the fallback). Operational fields
+            // (`enabled`, `timeoutMs`, `breaker`, `maxFilesInPrompt`,
+            // `maxDiffBytes`, `minRemainingTurnBudgetMs`) remain on
+            // `workspaceGit.commitMessageLLM` and are read above.
+            callSite: "commitMessage",
           },
-        );
+        });
       } catch (err: unknown) {
         clearTimeout(timer);
         if (ac.signal.aborted) {

package/tsconfig.json

@@ -13,7 +13,10 @@
     "sourceMap": true,
     "outDir": "./dist",
     "jsx": "react-jsx",
-    "types": ["bun-types"]
+    "types": ["bun-types"],
+    "paths": {
+      "@vellumai/plugin-api": ["./src/plugin-api/index.ts"]
+    }
   },
   "include": ["src/**/*", "src/**/*.tsx", "examples/**/*.ts"],
   "exclude": ["node_modules", "dist", "drizzle"]