@vellumai/assistant 0.10.6-staging.1 → 0.10.6

package/src/__tests__/workspace-migration-125-repoint-managed-connections-to-vellum.test.ts

@@ -0,0 +1,140 @@
+import {
+  existsSync,
+  mkdirSync,
+  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 { repointManagedConnectionsToVellumMigration } from "../workspace/migrations/125-repoint-managed-connections-to-vellum.js";
+
+let workspaceDir: string;
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function readLlm(): Record<string, unknown> {
+  return readConfig().llm as Record<string, unknown>;
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-125-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("125-repoint-managed-connections-to-vellum migration", () => {
+  test("no-op when config.json does not exist", () => {
+    repointManagedConnectionsToVellumMigration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    repointManagedConnectionsToVellumMigration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("repoints legacy managed connections across default, profiles, and callSites", () => {
+    writeConfig({
+      llm: {
+        default: {
+          provider: "anthropic",
+          provider_connection: "anthropic-managed",
+        },
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+          },
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            provider_connection: "anthropic-managed",
+          },
+          "os-beta": {
+            source: "managed",
+            provider: "together",
+            provider_connection: "together-managed",
+          },
+          // User-owned copy referencing a managed connection is repointed too.
+          "my-quality": {
+            source: "user",
+            provider: "openai",
+            provider_connection: "openai-managed",
+          },
+        },
+        callSites: {
+          replySuggestion: {
+            provider: "gemini",
+            provider_connection: "gemini-managed",
+          },
+        },
+      },
+    });
+
+    repointManagedConnectionsToVellumMigration.run(workspaceDir);
+
+    const llm = readLlm();
+    const profiles = llm.profiles as Record<string, Record<string, unknown>>;
+    const callSites = llm.callSites as Record<string, Record<string, unknown>>;
+
+    expect((llm.default as Record<string, unknown>).provider_connection).toBe(
+      "vellum",
+    );
+    expect(profiles.balanced.provider_connection).toBe("vellum");
+    expect(profiles["quality-optimized"].provider_connection).toBe("vellum");
+    expect(profiles["os-beta"].provider_connection).toBe("vellum");
+    expect(profiles["my-quality"].provider_connection).toBe("vellum");
+    expect(callSites.replySuggestion.provider_connection).toBe("vellum");
+
+    // The provider field is left intact — that is how vellum recovers the
+    // upstream at dispatch time.
+    expect(profiles.balanced.provider).toBe("fireworks");
+    expect(profiles["quality-optimized"].provider).toBe("anthropic");
+  });
+
+  test("leaves non-managed connections (personal, openrouter) untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          "custom-balanced": {
+            source: "user",
+            provider: "anthropic",
+            provider_connection: "anthropic-personal",
+          },
+          "my-router": {
+            source: "user",
+            provider: "openrouter",
+            provider_connection: "openrouter-personal",
+          },
+        },
+      },
+    };
+    writeConfig(original);
+    repointManagedConnectionsToVellumMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+});

package/src/agent/attachments.ts

@@ -8,6 +8,13 @@ export interface MessageAttachmentInput {
   data: string;
   extractedText?: string;
   filePath?: string;
+  /**
+   * Path of the canonical copy in the conversation's attachments/ directory,
+   * known once the attachment is linked to a message. Name collisions are
+   * resolved with a -2/-3 suffix, so this may differ from `filename` — and
+   * from `filePath`, which is where the upload originally came from.
+   */
+  storedPath?: string;
 }
 
 export function attachmentsToContentBlocks(
@@ -44,26 +51,61 @@ export function attachmentsToContentBlocks(
 }
 
 /**
- * Return a copy of the message with text annotations for image source paths.
- * The annotations are appended as a text content block so the LLM knows where
- * the images came from on disk. The caller should persist the ORIGINAL message
- * (without annotations) so the UI stays clean.
+ * Annotation line for where an attached image originally came from (e.g. a
+ * desktop client path). Shared with the history-reload reinjection so the
+ * reloaded content block stays byte-identical to the one built at persist
+ * time (prefix-cache parity).
+ */
+export function formatImageSourceAnnotation(filePath: string): string {
+  return `[Attached image source: ${filePath}]`;
+}
+
+/**
+ * Annotation line binding an attachment's user-facing filename to its
+ * canonical on-disk copy. The stored path is the one the model must use to
+ * read the attachment — the plain filename in the attachments/ directory may
+ * belong to an older upload with the same name. Shared with the
+ * history-reload reinjection (prefix-cache parity).
+ */
+export function formatStoredPathAnnotation(
+  filename: string,
+  storedPath: string,
+): string {
+  return `[Attachment "${filename}" is stored at: ${storedPath}]`;
+}
+
+/**
+ * Return a copy of the message with text annotations for attachment paths:
+ * source paths for images (where the file came from) and stored paths for
+ * any attachment whose canonical copy in the conversation's attachments/
+ * directory is known. The annotations are appended as a text content block
+ * so the LLM knows where to find the files on disk. The caller should
+ * persist the ORIGINAL message (without annotations) so the UI stays clean.
  */
 export function enrichMessageWithSourcePaths(
   message: Message,
   attachments: MessageAttachmentInput[],
 ): Message {
-  const imageAttachments = attachments.filter(
-    (a) => a.mimeType.toLowerCase().startsWith("image/") && a.filePath,
-  );
-  if (imageAttachments.length === 0) return message;
-
-  const annotation = imageAttachments
-    .map((a) => `[Attached image source: ${a.filePath}]`)
-    .join("\n");
+  const lines: string[] = [];
+  for (const a of attachments) {
+    if (a.mimeType.toLowerCase().startsWith("image/") && a.filePath) {
+      lines.push(formatImageSourceAnnotation(a.filePath));
+    }
+  }
+  for (const a of attachments) {
+    if (a.storedPath) {
+      lines.push(formatStoredPathAnnotation(a.filename, a.storedPath));
+    }
+  }
+  if (lines.length === 0) {
+    return message;
+  }
 
   return {
     ...message,
-    content: [...message.content, { type: "text" as const, text: annotation }],
+    content: [
+      ...message.content,
+      { type: "text" as const, text: lines.join("\n") },
+    ],
   };
 }

package/src/cli/commands/platform/__tests__/credits.test.ts

@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+let mockCalls: Array<[string, Record<string, unknown>]> = [];
+let mockResponse: unknown = {
+  ok: true,
+  result: {
+    remaining: 42.17,
+    settled: 50,
+    pending: 7.83,
+    unit: "USD",
+    stale: false,
+    as_of: "2026-07-06T00:00:00.000Z",
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+mock.module("../../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params: Record<string, unknown>) => {
+    mockCalls.push([method, params]);
+    return mockResponse;
+  },
+  exitFromIpcResult: (_r: unknown, _cmd: unknown) => {
+    throw new Error("exitFromIpcResult called");
+  },
+}));
+
+const { registerPlatformCommand } = await import("../index.js");
+
+function buildProgram(): Command {
+  const program = new Command();
+  program.exitOverride();
+  registerPlatformCommand(program);
+  return program;
+}
+
+function captureStdout(fn: () => Promise<void>): Promise<string[]> {
+  const chunks: string[] = [];
+  const origWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = ((chunk: unknown) => {
+    chunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+  return fn()
+    .then(() => chunks)
+    .finally(() => {
+      process.stdout.write = origWrite;
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("assistant platform credits", () => {
+  beforeEach(() => {
+    mockCalls = [];
+    mockResponse = {
+      ok: true,
+      result: {
+        remaining: 42.17,
+        settled: 50,
+        pending: 7.83,
+        unit: "USD",
+        stale: false,
+        as_of: "2026-07-06T00:00:00.000Z",
+      },
+    };
+    process.exitCode = 0;
+  });
+
+  test("calls platform_credits and emits balance JSON with --json", async () => {
+    const out = await captureStdout(async () => {
+      const program = buildProgram();
+      await program.parseAsync([
+        "node",
+        "assistant",
+        "platform",
+        "credits",
+        "--json",
+      ]);
+    });
+
+    expect(mockCalls[0][0]).toBe("platform_credits");
+
+    const parsed = JSON.parse(out.join(""));
+    expect(parsed.remaining).toBe(42.17);
+    expect(parsed.settled).toBe(50);
+    expect(parsed.pending).toBe(7.83);
+    expect(parsed.unit).toBe("USD");
+    expect(parsed.stale).toBe(false);
+  });
+
+  test("plain text mode does not emit JSON to stdout", async () => {
+    const out = await captureStdout(async () => {
+      const program = buildProgram();
+      await program.parseAsync(["node", "assistant", "platform", "credits"]);
+    });
+
+    // Plain-text mode logs via log.info — verify writeOutput (JSON) was NOT called
+    expect(() => JSON.parse(out.join("").trim())).toThrow();
+  });
+});

package/src/cli/commands/platform/index.ts

@@ -25,6 +25,15 @@ interface PlatformStatusResult {
   velayTunnel: { connected: boolean; publicUrl: string | null } | null;
 }
 
+interface PlatformCreditsResult {
+  remaining: number;
+  settled: number;
+  pending: number;
+  unit: "USD";
+  stale: boolean;
+  as_of: string;
+}
+
 export function registerPlatformCommand(program: Command): void {
   registerCommand(program, {
     name: "platform",
@@ -47,6 +56,7 @@ assistants.
 
 Examples:
   $ assistant platform status --json
+  $ assistant platform credits --json
   $ assistant platform connect
   $ assistant platform disconnect
   $ assistant platform callback-routes register --path webhooks/telegram --type telegram --json`,
@@ -95,7 +105,11 @@ Examples:
             "platform_status",
             {},
           );
-          if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
+          if (!r.ok)
+            return exitFromIpcResult(
+              { ok: false, error: r.error, statusCode: r.statusCode },
+              cmd,
+            );
 
           const result = r.result!;
 
@@ -114,7 +128,9 @@ Examples:
             log.info(
               `Callback registration available: ${result.available ? "yes" : "no"}`,
             );
-            log.info(`Organization ID: ${result.organizationId || "(not set)"}`);
+            log.info(
+              `Organization ID: ${result.organizationId || "(not set)"}`,
+            );
             log.info(`User ID: ${result.userId || "(not set)"}`);
             if (result.velayTunnel !== null) {
               const tunnelState = result.velayTunnel.connected
@@ -127,6 +143,64 @@ Examples:
           }
         });
 
+      // -----------------------------------------------------------------------
+      // credits
+      // -----------------------------------------------------------------------
+
+      platform
+        .command("credits")
+        .description("Show the organization's remaining credit balance")
+        .addHelpText(
+          "after",
+          `
+Fetches the org's credit balance from the platform billing summary.
+
+Fields:
+  remaining   Effective balance (settled minus pending charges) in USD
+  settled     On-ledger balance in USD
+  pending     Estimated pending compute charges not yet settled, in USD
+  unit        Balance currency (USD)
+  stale       True when pending-charge data may be stale or unavailable
+  as_of       When this balance was read (response receipt time)
+
+Combine with 'assistant usage daily' to compute runway (remaining divided
+by rolling daily average) and warn before credits run out.
+
+Requires platform credentials (run 'assistant platform connect' first or
+ensure VELLUM_PLATFORM_URL is set and credentials are stored).
+
+Examples:
+  $ assistant platform credits
+  $ assistant platform credits --json`,
+        )
+        .action(async (_opts: Record<string, unknown>, cmd: Command) => {
+          const r = await cliIpcCall<PlatformCreditsResult>(
+            "platform_credits",
+            {},
+          );
+          if (!r.ok)
+            return exitFromIpcResult(
+              { ok: false, error: r.error, statusCode: r.statusCode },
+              cmd,
+            );
+
+          const result = r.result!;
+
+          if (shouldOutputJson(cmd)) {
+            writeOutput(cmd, result);
+          } else {
+            const staleNote = result.stale
+              ? " (pending data may be stale)"
+              : "";
+            log.info(
+              `Remaining: $${result.remaining.toFixed(2)} ${result.unit} (as of ${result.as_of})${staleNote}`,
+            );
+            log.info(
+              `Settled:   $${result.settled.toFixed(2)}   Pending: $${result.pending.toFixed(2)}`,
+            );
+          }
+        });
+
       // -----------------------------------------------------------------------
       // disconnect
       // -----------------------------------------------------------------------
@@ -209,7 +283,11 @@ Examples:
           }>("platform_callback_routes_register", {
             body: { path: opts.path, type: opts.type },
           });
-          if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
+          if (!r.ok)
+            return exitFromIpcResult(
+              { ok: false, error: r.error, statusCode: r.statusCode },
+              cmd,
+            );
 
           writeOutput(cmd, { ok: true, ...r.result });
 
@@ -248,7 +326,11 @@ Examples:
               callback_url: string;
             }>;
           }>("platform_callback_routes_list", {});
-          if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
+          if (!r.ok)
+            return exitFromIpcResult(
+              { ok: false, error: r.error, statusCode: r.statusCode },
+              cmd,
+            );
 
           const routes = r.result!.routes;
 

package/src/cli/lib/__tests__/confirm-prompt.test.ts

@@ -23,7 +23,7 @@ function buildStreams(): Captured {
 }
 
 describe("confirmPrompt", () => {
-  test("returns \"non-interactive\" without reading when isTTY=false", async () => {
+  test('returns "non-interactive" without reading when isTTY=false', async () => {
     const { stdin, stdout, stderr, outChunks, errChunks } = buildStreams();
     const result = await confirmPrompt({
       question: "Delete? [y/N] ",
@@ -38,7 +38,7 @@ describe("confirmPrompt", () => {
     expect(outChunks.join("")).toBe("");
   });
 
-  test("returns \"confirmed\" for \"y\\n\"", async () => {
+  test('returns "confirmed" for "y\\n"', async () => {
     const { stdin, stdout, stderr } = buildStreams();
     const pending = confirmPrompt({
       question: "Delete? [y/N] ",
@@ -52,7 +52,7 @@ describe("confirmPrompt", () => {
     expect(await pending).toBe("confirmed");
   });
 
-  test("returns \"confirmed\" for \"yes\\n\" (case-insensitive, whitespace-tolerant)", async () => {
+  test('returns "confirmed" for "yes\\n" (case-insensitive, whitespace-tolerant)', async () => {
     const { stdin, stdout, stderr } = buildStreams();
     const pending = confirmPrompt({
       question: "Delete? [y/N] ",
@@ -66,7 +66,7 @@ describe("confirmPrompt", () => {
     expect(await pending).toBe("confirmed");
   });
 
-  test("returns \"denied\" for \"n\\n\"", async () => {
+  test('returns "denied" for "n\\n"', async () => {
     const { stdin, stdout, stderr } = buildStreams();
     const pending = confirmPrompt({
       question: "Delete? [y/N] ",
@@ -80,7 +80,7 @@ describe("confirmPrompt", () => {
     expect(await pending).toBe("denied");
   });
 
-  test("returns \"denied\" for empty input (just Enter)", async () => {
+  test('returns "denied" for empty input (just Enter)', async () => {
     const { stdin, stdout, stderr } = buildStreams();
     const pending = confirmPrompt({
       question: "Delete? [y/N] ",
@@ -94,7 +94,7 @@ describe("confirmPrompt", () => {
     expect(await pending).toBe("denied");
   });
 
-  test("returns \"denied\" on EOF without any data (regression: would have hung)", async () => {
+  test('returns "denied" on EOF without any data (regression: would have hung)', async () => {
     const { stdin, stdout, stderr } = buildStreams();
     const pending = confirmPrompt({
       question: "Delete? [y/N] ",
@@ -108,7 +108,7 @@ describe("confirmPrompt", () => {
     expect(await pending).toBe("denied");
   });
 
-  test("returns \"denied\" on EOF after a partial line with no newline", async () => {
+  test('returns "denied" on EOF after a partial line with no newline', async () => {
     const { stdin, stdout, stderr } = buildStreams();
     const pending = confirmPrompt({
       question: "Delete? [y/N] ",
@@ -131,7 +131,7 @@ describe("confirmPrompt", () => {
   test("writes the question to stdout when interactive", async () => {
     const { stdin, stdout, stderr, outChunks } = buildStreams();
     const pending = confirmPrompt({
-      question: "Delete plugin \"foo\"? [y/N] ",
+      question: 'Delete plugin "foo"? [y/N] ',
       isTTY: true,
       refuseNonInteractiveMessage: "n/a",
       stdin,
@@ -140,7 +140,7 @@ describe("confirmPrompt", () => {
     });
     stdin.write("n\n");
     await pending;
-    expect(outChunks.join("")).toContain("Delete plugin \"foo\"? [y/N] ");
+    expect(outChunks.join("")).toContain('Delete plugin "foo"? [y/N] ');
   });
 
   test("treats stray garbage as denial, never confirmation", async () => {

package/src/cli/lib/diff-plugin.ts

@@ -38,6 +38,7 @@ import { join } from "node:path";
 
 import { createTwoFilesPatch } from "diff";
 
+import { PRESERVED_ENTRIES } from "../../plugins/plugin-tree-walk.js";
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 import {
   DEFAULT_PLUGIN_REF,
@@ -55,7 +56,6 @@ import {
   compareFingerprint,
   computeFingerprint,
   type Fingerprint,
-  PRESERVED_ENTRIES,
 } from "./plugin-fingerprint.js";
 import { PluginNotInstalledError } from "./uninstall-plugin.js";
 
@@ -141,7 +141,9 @@ export interface DiffPluginDeps {
 function isBinary(buf: Buffer): boolean {
   const len = Math.min(buf.length, 8000);
   for (let i = 0; i < len; i++) {
-    if (buf[i] === 0) return true;
+    if (buf[i] === 0) {
+      return true;
+    }
   }
   return false;
 }
@@ -214,7 +216,9 @@ function baselineContent(
   recorded: Fingerprint,
   materialized: Fingerprint,
 ): FileContent | null {
-  if (materialized.files[path] !== recorded.files[path]) return null;
+  if (materialized.files[path] !== recorded.files[path]) {
+    return null;
+  }
   return readContent(join(baselineRoot, path));
 }
 

package/src/cli/lib/inspect-plugin.ts

@@ -16,6 +16,7 @@
  * is a thin wrapper that supplies production deps and formats the result.
  */
 
+import { PRESERVED_ENTRIES } from "../../plugins/plugin-tree-walk.js";
 import {
   DEFAULT_PLUGIN_REF,
   type FetchLike,
@@ -30,7 +31,6 @@ import {
 import {
   compareFingerprint,
   type FingerprintComparison,
-  PRESERVED_ENTRIES,
 } from "./plugin-fingerprint.js";
 import {
   fetchMarketplaceEntries,
@@ -238,15 +238,25 @@ async function fetchCommitDate(
         "User-Agent": "vellum-assistant-cli",
       },
     });
-    if (!res.ok) return null;
+    if (!res.ok) {
+      return null;
+    }
     const json: unknown = JSON.parse(await res.text());
-    if (typeof json !== "object" || json === null) return null;
+    if (typeof json !== "object" || json === null) {
+      return null;
+    }
     const commit = (json as Record<string, unknown>).commit;
-    if (typeof commit !== "object" || commit === null) return null;
+    if (typeof commit !== "object" || commit === null) {
+      return null;
+    }
     const committer = (commit as Record<string, unknown>).committer;
-    if (typeof committer !== "object" || committer === null) return null;
+    if (typeof committer !== "object" || committer === null) {
+      return null;
+    }
     const date = (committer as Record<string, unknown>).date;
-    if (typeof date !== "string") return null;
+    if (typeof date !== "string") {
+      return null;
+    }
     const ms = Date.parse(date);
     return Number.isFinite(ms) ? new Date(ms).toISOString() : null;
   } catch {
@@ -312,10 +322,18 @@ function classify(
   remote: PluginRemoteInfo | null,
   remoteError: string | null,
 ): PluginUpdateStatus {
-  if (!installed) return "not-installed";
-  if (remoteError && !remote) return "remote-unavailable";
-  if (!remote) return "not-in-marketplace";
-  if (!local?.commit) return "unknown-provenance";
+  if (!installed) {
+    return "not-installed";
+  }
+  if (remoteError && !remote) {
+    return "remote-unavailable";
+  }
+  if (!remote) {
+    return "not-in-marketplace";
+  }
+  if (!local?.commit) {
+    return "unknown-provenance";
+  }
   return local.commit.toLowerCase() === remote.commit.toLowerCase()
     ? "up-to-date"
     : "update-available";