@vellumai/assistant 0.10.7-dev.202607100313.fffdfea → 0.10.7-dev.202607100720.fba456e

package/src/cli/commands/__tests__/schedules.test.ts

@@ -64,7 +64,9 @@ async function runCommand(
     registerSchedulesCommand(program);
     await program.parseAsync(["node", "assistant", ...args]);
   } catch {
-    if (process.exitCode === 0) process.exitCode = 1;
+    if (process.exitCode === 0) {
+      process.exitCode = 1;
+    }
   } finally {
     process.stdout.write = originalStdoutWrite;
   }
@@ -469,6 +471,136 @@ describe("schedules runs", () => {
     expect(logLines.join("\n")).toContain("conversation-1");
   });
 
+  test("renders a COST column with the shared variable-precision USD format", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        runs: [
+          {
+            id: "run-1",
+            jobId: "schedule-1",
+            status: "ok",
+            startedAt: 1_778_799_000_000,
+            finishedAt: 1_778_799_002_500,
+            durationMs: 2_500,
+            output: "done",
+            error: null,
+            conversationId: "conversation-1",
+            estimatedCostUsd: 0.0123,
+            createdAt: 1_778_799_000_000,
+          },
+          {
+            id: "run-subcent",
+            jobId: "schedule-1",
+            status: "ok",
+            startedAt: 1_778_799_000_000,
+            finishedAt: 1_778_799_002_500,
+            durationMs: 2_500,
+            output: "done",
+            error: null,
+            conversationId: "conversation-1",
+            estimatedCostUsd: 0.0042,
+            createdAt: 1_778_799_000_000,
+          },
+        ],
+      },
+    };
+
+    const { exitCode } = await runCommand(["schedules", "runs", "schedule-1"]);
+
+    expect(exitCode).toBe(0);
+    const output = logLines.join("\n");
+    expect(output).toContain("COST");
+    // Matches usage totals/daily/breakdown: 2dp at a cent or more, 6dp sub-cent.
+    expect(output).toContain("$0.01");
+    expect(output).toContain("$0.004200");
+  });
+
+  test("renders — for zero or unpriced run cost", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        runs: [
+          {
+            id: "run-zero",
+            jobId: "schedule-1",
+            status: "ok",
+            startedAt: 1_778_799_000_000,
+            finishedAt: 1_778_799_002_500,
+            durationMs: 2_500,
+            output: "done",
+            error: null,
+            conversationId: "conversation-1",
+            estimatedCostUsd: 0,
+            createdAt: 1_778_799_000_000,
+          },
+          {
+            id: "run-unpriced",
+            jobId: "schedule-1",
+            status: "ok",
+            startedAt: 1_778_799_000_000,
+            finishedAt: 1_778_799_002_500,
+            durationMs: 2_500,
+            output: "done",
+            error: null,
+            conversationId: "conversation-1",
+            createdAt: 1_778_799_000_000,
+          },
+        ],
+      },
+    };
+
+    const { exitCode } = await runCommand(["schedules", "runs", "schedule-1"]);
+
+    expect(exitCode).toBe(0);
+    const output = logLines.join("\n");
+    expect(output).toContain("COST");
+    expect(output).not.toContain("$");
+    const runZeroLine = logLines.find((line) => line.includes("run-zero"));
+    const runUnpricedLine = logLines.find((line) =>
+      line.includes("run-unpriced"),
+    );
+    expect(runZeroLine).toContain("—");
+    expect(runUnpricedLine).toContain("—");
+  });
+
+  test("includes estimatedCostUsd in --json output", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        runs: [
+          {
+            id: "run-1",
+            jobId: "schedule-1",
+            status: "ok",
+            startedAt: 1_778_799_000_000,
+            finishedAt: 1_778_799_002_500,
+            durationMs: 2_500,
+            output: "done",
+            error: null,
+            conversationId: "conversation-1",
+            estimatedCostUsd: 0.0123,
+            createdAt: 1_778_799_000_000,
+          },
+        ],
+      },
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "schedules",
+      "runs",
+      "schedule-1",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout)).toEqual({
+      runs: [
+        expect.objectContaining({ id: "run-1", estimatedCostUsd: 0.0123 }),
+      ],
+    });
+  });
+
   test("formats run durations into human-friendly units", async () => {
     const durations = [
       { ms: 450, expected: "450ms" },

package/src/cli/commands/__tests__/usage.test.ts

@@ -0,0 +1,131 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+let ipcCalls: Array<{ method: string; params?: Record<string, unknown> }> = [];
+let mockIpcResult: {
+  ok: boolean;
+  result?: unknown;
+  error?: string;
+} = { ok: true, result: {} };
+let exitFromIpcResultCalls: unknown[] = [];
+
+mock.module("../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    ipcCalls.push({ method, params });
+    return mockIpcResult;
+  },
+  exitFromIpcResult: (result: unknown) => {
+    exitFromIpcResultCalls.push(result);
+    process.exitCode = 10;
+    throw new Error("exitFromIpcResult called");
+  },
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+  getCliLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+}));
+
+const { registerUsageCommand } = await import("../usage.js");
+
+async function runCommand(args: string[]): Promise<{ exitCode: number }> {
+  process.exitCode = 0;
+  try {
+    const program = new Command();
+    program.exitOverride();
+    program.configureOutput({
+      writeErr: () => {},
+      writeOut: () => {},
+    });
+    registerUsageCommand(program);
+    await program.parseAsync(["node", "assistant", "usage", ...args]);
+  } catch {
+    if (process.exitCode === 0) {
+      process.exitCode = 1;
+    }
+  }
+  const exitCode = process.exitCode ?? 0;
+  process.exitCode = 0;
+  return { exitCode };
+}
+
+function lastQueryParams(): Record<string, unknown> {
+  const call = ipcCalls.at(-1);
+  return (call?.params?.queryParams ?? {}) as Record<string, unknown>;
+}
+
+describe("usage --schedule option", () => {
+  beforeEach(() => {
+    ipcCalls = [];
+    exitFromIpcResultCalls = [];
+    mockIpcResult = { ok: true, result: {} };
+  });
+
+  test("totals forwards --schedule as scheduleId", async () => {
+    mockIpcResult = { ok: true, result: { buckets: [] } };
+    await runCommand([
+      "totals",
+      "--range",
+      "all",
+      "--schedule",
+      "sched-abc123",
+    ]);
+    expect(ipcCalls.at(-1)?.method).toBe("usage_totals");
+    expect(lastQueryParams().scheduleId).toBe("sched-abc123");
+  });
+
+  test("totals omits scheduleId when --schedule absent", async () => {
+    await runCommand(["totals", "--range", "all"]);
+    expect(ipcCalls.at(-1)?.method).toBe("usage_totals");
+    expect(lastQueryParams()).not.toHaveProperty("scheduleId");
+  });
+
+  test("daily forwards --schedule as scheduleId", async () => {
+    mockIpcResult = { ok: true, result: { buckets: [] } };
+    await runCommand(["daily", "--range", "all", "--schedule", "sched-abc123"]);
+    expect(ipcCalls.at(-1)?.method).toBe("usage_daily");
+    expect(lastQueryParams().scheduleId).toBe("sched-abc123");
+  });
+
+  test("daily omits scheduleId when --schedule absent", async () => {
+    mockIpcResult = { ok: true, result: { buckets: [] } };
+    await runCommand(["daily", "--range", "all"]);
+    expect(ipcCalls.at(-1)?.method).toBe("usage_daily");
+    expect(lastQueryParams()).not.toHaveProperty("scheduleId");
+  });
+
+  test("breakdown forwards --schedule as scheduleId alongside groupBy", async () => {
+    mockIpcResult = { ok: true, result: { breakdown: [] } };
+    await runCommand([
+      "breakdown",
+      "--range",
+      "all",
+      "--group-by",
+      "provider",
+      "--schedule",
+      "sched-abc123",
+    ]);
+    expect(ipcCalls.at(-1)?.method).toBe("usage_breakdown");
+    const qp = lastQueryParams();
+    expect(qp.scheduleId).toBe("sched-abc123");
+    expect(qp.groupBy).toBe("provider");
+  });
+
+  test("breakdown omits scheduleId when --schedule absent", async () => {
+    mockIpcResult = { ok: true, result: { breakdown: [] } };
+    await runCommand(["breakdown", "--range", "all", "--group-by", "provider"]);
+    expect(ipcCalls.at(-1)?.method).toBe("usage_breakdown");
+    expect(lastQueryParams()).not.toHaveProperty("scheduleId");
+  });
+});

package/src/cli/commands/inference-callsites.ts

@@ -0,0 +1,158 @@
+/**
+ * `assistant inference callsites` CLI namespace.
+ *
+ *   callsites list          — effective resolution for every call site
+ *   callsites get <site>    — resolution detail + chain for one call site
+ *
+ * Read-only. Delegates to the daemon (`inference_callsites_*`), which computes
+ * resolution via the shared `resolveCallSiteConfig` / `selectWinningProfile`
+ * machinery. Output is deliberately compact and aligned — it is mostly read by
+ * the assistant itself.
+ */
+
+import type { Command } from "commander";
+
+import { cliIpcCall } from "../../ipc/cli-client.js";
+import { renderTable, writeCliError, writeLine } from "../lib/cli-output.js";
+
+type Source = "override" | "active" | "call_site" | "default";
+
+interface CallSiteSummary {
+  callSite: string;
+  profile: string | null;
+  label: string | null;
+  source: Source;
+  provider: string;
+  model: string;
+  effort: string;
+  maxTokens: number;
+  maxInputTokens?: number;
+}
+
+interface CallSiteDetail {
+  callSite: string;
+  winner: { profile: string | null; label: string | null; source: Source };
+  resolved: {
+    provider: string;
+    model: string;
+    maxTokens: number;
+    effort: string;
+    temperature: number | null;
+    maxInputTokens?: number;
+  };
+  resolutionChain: { requested: string; reason: string }[];
+  shippedDefault: Record<string, unknown>;
+  userPin: Record<string, unknown> | null;
+  resolutionError?: { reason: string; message: string };
+}
+
+const SOURCE_LABEL: Record<Source, string> = {
+  override: "override",
+  active: "active",
+  call_site: "pin",
+  default: "default",
+};
+
+function formatCtxIn(tokens: number | undefined): string {
+  if (tokens == null) {
+    return "-";
+  }
+  if (tokens >= 1_000_000 && tokens % 1_000_000 === 0) {
+    return `${tokens / 1_000_000}M`;
+  }
+  return tokens.toLocaleString();
+}
+
+export function attachCallsitesSubcommand(inference: Command): void {
+  const callsites = inference
+    .command("callsites")
+    .description("Inspect how each LLM call site resolves to a profile");
+
+  callsites
+    .command("list")
+    .description("List the effective resolution for every call site")
+    .option("--json", "Output as machine-readable JSON")
+    .action(async (opts: { json?: boolean }) => {
+      const ipcResult = await cliIpcCall<{ callSites: CallSiteSummary[] }>(
+        "inference_callsites_list",
+        {},
+      );
+      if (!ipcResult.ok) {
+        writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+        return;
+      }
+      const rows = ipcResult.result!.callSites;
+      if (opts.json) {
+        process.stdout.write(
+          JSON.stringify({ ok: true, callSites: rows }) + "\n",
+        );
+        return;
+      }
+      renderTable(
+        [
+          "CALL SITE",
+          "PROFILE",
+          "SRC",
+          "PROVIDER",
+          "MODEL",
+          "EFFORT",
+          "CTX-IN",
+        ],
+        rows.map((r) => [
+          r.callSite,
+          r.profile ?? "(anchor)",
+          SOURCE_LABEL[r.source],
+          r.provider,
+          r.model,
+          r.effort,
+          formatCtxIn(r.maxInputTokens),
+        ]),
+      );
+    });
+
+  callsites
+    .command("get <site>")
+    .description("Show the resolution detail and chain for one call site")
+    .option("--json", "Output as machine-readable JSON")
+    .action(async (site: string, opts: { json?: boolean }) => {
+      const ipcResult = await cliIpcCall<CallSiteDetail>(
+        "inference_callsites_get",
+        { pathParams: { site } },
+      );
+      if (!ipcResult.ok) {
+        writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+        return;
+      }
+      const d = ipcResult.result!;
+      if (opts.json) {
+        process.stdout.write(JSON.stringify({ ok: true, ...d }) + "\n");
+        return;
+      }
+      writeLine(`call site: ${d.callSite}`);
+      writeLine(
+        `  winner: ${d.winner.profile ?? "(anchor)"} [${SOURCE_LABEL[d.winner.source]}]` +
+          (d.winner.label ? ` "${d.winner.label}"` : ""),
+      );
+      writeLine(
+        `  resolved: ${d.resolved.provider}/${d.resolved.model} effort=${d.resolved.effort} maxTokens=${d.resolved.maxTokens}` +
+          (d.resolved.maxInputTokens != null
+            ? ` ctxIn=${formatCtxIn(d.resolved.maxInputTokens)}`
+            : ""),
+      );
+      if (d.resolutionChain.length > 0) {
+        writeLine("  resolution chain (skipped rungs):");
+        for (const step of d.resolutionChain) {
+          writeLine(`    - ${step.requested}: ${step.reason}`);
+        }
+      }
+      writeLine(`  shipped default: ${JSON.stringify(d.shippedDefault)}`);
+      writeLine(
+        `  user pin: ${d.userPin ? JSON.stringify(d.userPin) : "(none)"}`,
+      );
+      if (d.resolutionError) {
+        writeLine(
+          `  resolution error [${d.resolutionError.reason}]: ${d.resolutionError.message}`,
+        );
+      }
+    });
+}

package/src/cli/commands/inference-models.ts

@@ -0,0 +1,84 @@
+/**
+ * `assistant inference models` CLI namespace.
+ *
+ *   `assistant inference models list [--provider <p>] [--json]`
+ *
+ * Lists the code-owned model catalog so the assistant can discover valid
+ * model ids instead of guessing. Delegates to the daemon via IPC
+ * (`inference_models_list`).
+ */
+
+import type { Command } from "commander";
+
+import { cliIpcCall } from "../../ipc/cli-client.js";
+import { renderTable, writeCliError, writeLine } from "../lib/cli-output.js";
+
+interface CatalogModel {
+  provider: string;
+  id: string;
+  displayName: string;
+  contextWindowTokens?: number;
+  maxOutputTokens?: number;
+  supportsThinking?: boolean;
+  supportsVision?: boolean;
+  supportsToolUse?: boolean;
+  featureFlag?: string;
+}
+
+export function attachModelsSubcommand(inference: Command): void {
+  const models = inference
+    .command("models")
+    .description("Inspect the inference model catalog");
+
+  models
+    .command("list")
+    .description("List catalog models (optionally filtered by provider)")
+    .option("--provider <p>", "Filter by provider id")
+    .option("--json", "Output as machine-readable JSON")
+    .addHelpText(
+      "after",
+      `
+Lists every model in the code-owned provider catalog. Use the ids here
+when creating an inference profile:
+
+Examples:
+  $ assistant inference models list
+  $ assistant inference models list --provider anthropic
+  $ assistant inference models list --json`,
+    )
+    .action(async (opts: { provider?: string; json?: boolean }) => {
+      const ipcResult = await cliIpcCall<{ models: CatalogModel[] }>(
+        "inference_models_list",
+        { queryParams: opts.provider ? { provider: opts.provider } : {} },
+      );
+
+      if (!ipcResult.ok) {
+        writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+        return;
+      }
+
+      const rows = ipcResult.result!.models;
+
+      if (opts.json) {
+        process.stdout.write(JSON.stringify({ ok: true, models: rows }) + "\n");
+        return;
+      }
+
+      if (rows.length === 0) {
+        writeLine("No models found.");
+        return;
+      }
+
+      renderTable(
+        ["PROVIDER", "MODEL ID", "DISPLAY NAME", "CONTEXT"],
+        rows.map((m) => [
+          m.provider,
+          m.id,
+          m.displayName,
+          m.contextWindowTokens != null
+            ? m.contextWindowTokens.toLocaleString()
+            : "-",
+        ]),
+      );
+    });
+}