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

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

@@ -0,0 +1,371 @@
+/**
+ * `assistant inference profiles` CLI namespace.
+ *
+ *   profiles list                 — effective profile catalog (managed + user)
+ *   profiles get <name>           — a single effective profile
+ *   profiles create <name> ...    — create a validated custom profile
+ *   profiles update <name> ...    — partial update of a custom profile
+ *   profiles delete <name>        — delete a custom profile (managed protected)
+ *   profiles active [name]        — read or set the active (chat) profile
+ *
+ * All subcommands delegate to the daemon via IPC. Provider/model/connection
+ * validation is enforced by the daemon (`inference_profiles_*` routes); the
+ * CLI only shape-parses flags.
+ */
+
+import type { Command } from "commander";
+
+import { cliIpcCall } from "../../ipc/cli-client.js";
+import { renderTable, writeCliError, writeLine } from "../lib/cli-output.js";
+
+interface ProfileSummary {
+  name: string;
+  label: string | null;
+  provider: string | null;
+  model: string | null;
+  status: "active" | "disabled";
+  source: "managed" | "user";
+  provider_connection?: string;
+  availability: { status: string; message?: string } | null;
+}
+
+interface ProfileWriteResult {
+  ok: true;
+  name: string;
+  entry: Record<string, unknown>;
+  warnings: string[];
+}
+
+type WriteFlags = {
+  provider?: string;
+  model?: string;
+  connection?: string;
+  label?: string;
+  effort?: string;
+  maxTokens?: string;
+  temperature?: string;
+  thinking?: string;
+  description?: string;
+  allowUnlisted?: boolean;
+  json?: boolean;
+};
+
+/**
+ * Parse the shared write flags into an IPC body. Returns an error string when
+ * a numeric/enum flag is malformed. Only keys the user supplied are included.
+ */
+function buildWriteBody(
+  opts: WriteFlags,
+): { ok: true; body: Record<string, unknown> } | { ok: false; error: string } {
+  const body: Record<string, unknown> = {};
+  if (opts.provider !== undefined) {
+    body.provider = opts.provider;
+  }
+  if (opts.model !== undefined) {
+    body.model = opts.model;
+  }
+  if (opts.connection !== undefined) {
+    body.connection = opts.connection;
+  }
+  if (opts.label !== undefined) {
+    body.label = opts.label;
+  }
+  if (opts.effort !== undefined) {
+    body.effort = opts.effort;
+  }
+  if (opts.description !== undefined) {
+    body.description = opts.description;
+  }
+  if (opts.allowUnlisted) {
+    body.allowUnlisted = true;
+  }
+
+  if (opts.maxTokens !== undefined) {
+    if (!/^\d+$/.test(opts.maxTokens.trim())) {
+      return { ok: false, error: "--max-tokens must be a positive integer." };
+    }
+    body.maxTokens = Number(opts.maxTokens.trim());
+  }
+  if (opts.temperature !== undefined) {
+    const value = Number(opts.temperature.trim());
+    if (!Number.isFinite(value)) {
+      return { ok: false, error: "--temperature must be a number." };
+    }
+    body.temperature = value;
+  }
+  if (opts.thinking !== undefined) {
+    const normalized = opts.thinking.trim().toLowerCase();
+    if (normalized !== "on" && normalized !== "off") {
+      return { ok: false, error: "--thinking must be 'on' or 'off'." };
+    }
+    body.thinking = normalized === "on";
+  }
+
+  return { ok: true, body };
+}
+
+function printWriteResult(
+  verb: string,
+  result: ProfileWriteResult,
+  json?: boolean,
+): void {
+  if (json) {
+    process.stdout.write(JSON.stringify(result) + "\n");
+    return;
+  }
+  for (const warning of result.warnings) {
+    writeLine(`warning: ${warning}`);
+  }
+  writeLine(`profile ${result.name} ${verb}`);
+  writeLine(
+    `Verify it works: assistant inference send --profile ${result.name} "Reply with OK"`,
+  );
+}
+
+function addWriteFlags(cmd: Command): Command {
+  return cmd
+    .option("--provider <p>", "LLM provider (e.g. anthropic, openai)")
+    .option("--model <id>", "Model id (see 'assistant inference models list')")
+    .option("--connection <name>", "Provider connection name to use")
+    .option("--label <text>", "Human-readable label")
+    .option(
+      "--effort <tier>",
+      "Reasoning effort (none|low|medium|high|xhigh|max)",
+    )
+    .option("--max-tokens <n>", "Max response tokens")
+    .option("--temperature <x>", "Sampling temperature")
+    .option("--thinking <on|off>", "Enable or disable thinking")
+    .option("--description <text>", "Profile description")
+    .option("--allow-unlisted", "Allow a model not in the catalog (warns)")
+    .option("--json", "Output as machine-readable JSON");
+}
+
+export function attachProfilesSubcommand(inference: Command): void {
+  const profiles = inference
+    .command("profiles")
+    .description("Manage inference profiles (named model configurations)");
+
+  profiles.addHelpText(
+    "after",
+    `
+Profiles are named model configurations. Managed defaults (balanced,
+quality-optimized, cost-optimized) are read-only; create your own to
+customize provider, model, and tuning.
+
+Examples:
+  $ assistant inference profiles list
+  $ assistant inference profiles create my-fast --provider anthropic \\
+      --model claude-haiku-4-5 --connection anthropic-personal --effort low
+  $ assistant inference profiles update my-fast --effort high
+  $ assistant inference profiles active my-fast
+  $ assistant inference profiles delete my-fast`,
+  );
+
+  // ── list ────────────────────────────────────────────────────────────
+  profiles
+    .command("list")
+    .description("List the effective profile catalog")
+    .option("--json", "Output as machine-readable JSON")
+    .action(async (opts: { json?: boolean }) => {
+      const ipcResult = await cliIpcCall<{ profiles: ProfileSummary[] }>(
+        "inference_profiles_list",
+        {},
+      );
+      if (!ipcResult.ok) {
+        writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+        return;
+      }
+      const rows = ipcResult.result!.profiles;
+      if (opts.json) {
+        process.stdout.write(
+          JSON.stringify({ ok: true, profiles: rows }) + "\n",
+        );
+        return;
+      }
+      if (rows.length === 0) {
+        writeLine("No profiles found.");
+        return;
+      }
+      renderTable(
+        ["NAME", "LABEL", "PROVIDER", "MODEL", "STATUS", "SOURCE", "AVAIL"],
+        rows.map((p) => [
+          p.name,
+          p.label ?? "-",
+          p.provider ?? "-",
+          p.model ?? "-",
+          p.status,
+          p.source,
+          p.availability ? p.availability.status : "-",
+        ]),
+      );
+    });
+
+  // ── get ─────────────────────────────────────────────────────────────
+  profiles
+    .command("get <name>")
+    .description("Show a single effective profile")
+    .option("--json", "Output as machine-readable JSON")
+    .action(async (name: string, opts: { json?: boolean }) => {
+      const ipcResult = await cliIpcCall<{
+        name: string;
+        entry: Record<string, unknown>;
+        availability: { status: string; message?: string } | null;
+      }>("inference_profiles_get", { pathParams: { name } });
+      if (!ipcResult.ok) {
+        writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+        return;
+      }
+      const result = ipcResult.result!;
+      if (opts.json) {
+        process.stdout.write(JSON.stringify({ ok: true, ...result }) + "\n");
+        return;
+      }
+      writeLine(`profile: ${result.name}`);
+      for (const [key, value] of Object.entries(result.entry)) {
+        writeLine(`  ${key}: ${JSON.stringify(value)}`);
+      }
+      if (result.availability) {
+        writeLine(`  availability: ${result.availability.status}`);
+        if (result.availability.message) {
+          writeLine(`    ${result.availability.message}`);
+        }
+      }
+    });
+
+  // ── create ──────────────────────────────────────────────────────────
+  addWriteFlags(
+    profiles
+      .command("create <name>")
+      .description("Create a validated custom profile"),
+  ).action(async (name: string, opts: WriteFlags) => {
+    if (!opts.provider) {
+      writeCliError("--provider is required.", opts.json);
+      return;
+    }
+    if (!opts.model) {
+      writeCliError("--model is required.", opts.json);
+      return;
+    }
+    const built = buildWriteBody(opts);
+    if (!built.ok) {
+      writeCliError(built.error, opts.json);
+      return;
+    }
+    const ipcResult = await cliIpcCall<ProfileWriteResult>(
+      "inference_profiles_create",
+      { body: { ...built.body, name } },
+    );
+    if (!ipcResult.ok) {
+      writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+      return;
+    }
+    printWriteResult("created", ipcResult.result!, opts.json);
+  });
+
+  // ── update ──────────────────────────────────────────────────────────
+  addWriteFlags(
+    profiles
+      .command("update <name>")
+      .description("Partially update a custom profile"),
+  ).action(async (name: string, opts: WriteFlags) => {
+    const built = buildWriteBody(opts);
+    if (!built.ok) {
+      writeCliError(built.error, opts.json);
+      return;
+    }
+    if (Object.keys(built.body).length === 0) {
+      writeCliError(
+        "Nothing to update — pass at least one field flag.",
+        opts.json,
+      );
+      return;
+    }
+    const ipcResult = await cliIpcCall<ProfileWriteResult>(
+      "inference_profiles_update",
+      { pathParams: { name }, body: built.body },
+    );
+    if (!ipcResult.ok) {
+      writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+      return;
+    }
+    printWriteResult("updated", ipcResult.result!, opts.json);
+  });
+
+  // ── delete ──────────────────────────────────────────────────────────
+  profiles
+    .command("delete <name>")
+    .description("Delete a custom profile")
+    .option("--json", "Output as machine-readable JSON")
+    .action(async (name: string, opts: { json?: boolean }) => {
+      const ipcResult = await cliIpcCall<{ ok: true; name: string }>(
+        "inference_profiles_delete",
+        { pathParams: { name } },
+      );
+      if (!ipcResult.ok) {
+        writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+        return;
+      }
+      if (opts.json) {
+        process.stdout.write(
+          JSON.stringify({ ok: true, name: ipcResult.result!.name }) + "\n",
+        );
+        return;
+      }
+      writeLine(`profile ${name} deleted`);
+    });
+
+  // ── active ──────────────────────────────────────────────────────────
+  profiles
+    .command("active [name]")
+    .description("Read or set the active (chat) profile")
+    .option("--json", "Output as machine-readable JSON")
+    .addHelpText(
+      "after",
+      `
+With no argument, prints the active profile. With a name, sets it — the
+same deep-merge write the model picker performs.
+
+Examples:
+  $ assistant inference profiles active
+  $ assistant inference profiles active balanced`,
+    )
+    .action(async (name: string | undefined, opts: { json?: boolean }) => {
+      if (name === undefined) {
+        const ipcResult = await cliIpcCall<{
+          llm?: { activeProfile?: string };
+        }>("config_get");
+        if (!ipcResult.ok) {
+          writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+          return;
+        }
+        const active = ipcResult.result!.llm?.activeProfile ?? null;
+        if (opts.json) {
+          process.stdout.write(
+            JSON.stringify({ ok: true, activeProfile: active }) + "\n",
+          );
+          return;
+        }
+        writeLine(
+          active ? `active profile: ${active}` : "no active profile set",
+        );
+        return;
+      }
+
+      const ipcResult = await cliIpcCall<{ ok: true; activeProfile: string }>(
+        "inference_profiles_set_active",
+        { body: { name } },
+      );
+      if (!ipcResult.ok) {
+        writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+        return;
+      }
+      const activeProfile = ipcResult.result!.activeProfile;
+      if (opts.json) {
+        process.stdout.write(
+          JSON.stringify({ ok: true, activeProfile }) + "\n",
+        );
+        return;
+      }
+      writeLine(`active profile set to ${activeProfile}`);
+    });
+}

package/src/cli/commands/inference-providers-default.ts

@@ -0,0 +1,89 @@
+/**
+ * `assistant inference providers default [name]` — read or set the workspace
+ * default provider (`llm.defaultProvider`), wrapping the daemon's
+ * `llm_default_provider_get` / `llm_default_provider_put` routes. The read
+ * form prints the resolved connection and its availability status.
+ */
+
+import type { Command } from "commander";
+
+import { cliIpcCall } from "../../ipc/cli-client.js";
+import { writeCliError, writeLine } from "../lib/cli-output.js";
+
+interface DefaultProviderStatus {
+  provider: string | null;
+  connectionName?: string;
+  resolvedConnectionName: string | null;
+  availability: { status: string; message?: string };
+}
+
+function printStatus(status: DefaultProviderStatus, json?: boolean): void {
+  if (json) {
+    process.stdout.write(JSON.stringify({ ok: true, ...status }) + "\n");
+    return;
+  }
+  if (!status.provider) {
+    writeLine("no default provider configured");
+  } else {
+    writeLine(`default provider: ${status.provider}`);
+    if (status.resolvedConnectionName) {
+      writeLine(`  connection: ${status.resolvedConnectionName}`);
+    }
+  }
+  writeLine(`  availability: ${status.availability.status}`);
+  if (status.availability.message) {
+    writeLine(`    ${status.availability.message}`);
+  }
+}
+
+export function attachDefaultProviderSubcommand(providers: Command): void {
+  providers
+    .command("default [name]")
+    .description("Read or set the default provider (prints availability)")
+    .option("--connection <name>", "Pin a specific connection when setting")
+    .option("--json", "Output as machine-readable JSON")
+    .addHelpText(
+      "after",
+      `
+With no argument, prints the default provider and whether it is usable.
+With a provider name, sets it (optionally pinning a connection).
+
+Examples:
+  $ assistant inference providers default
+  $ assistant inference providers default anthropic
+  $ assistant inference providers default anthropic --connection anthropic-personal`,
+    )
+    .action(
+      async (
+        name: string | undefined,
+        opts: { connection?: string; json?: boolean },
+      ) => {
+        if (name === undefined) {
+          const ipcResult = await cliIpcCall<DefaultProviderStatus>(
+            "llm_default_provider_get",
+            {},
+          );
+          if (!ipcResult.ok) {
+            writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+            return;
+          }
+          printStatus(ipcResult.result!, opts.json);
+          return;
+        }
+
+        const body: Record<string, unknown> = { provider: name };
+        if (opts.connection !== undefined) {
+          body.connectionName = opts.connection;
+        }
+        const ipcResult = await cliIpcCall<DefaultProviderStatus>(
+          "llm_default_provider_put",
+          { body },
+        );
+        if (!ipcResult.ok) {
+          writeCliError(ipcResult.error ?? "Unknown error", opts.json);
+          return;
+        }
+        printStatus(ipcResult.result!, opts.json);
+      },
+    );
+}

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

@@ -18,7 +18,8 @@ import type { Command } from "commander";
 
 import { cliIpcCall } from "../../ipc/cli-client.js";
 import type { OAuth2Config } from "../../security/oauth2.js";
-import { log } from "../logger.js";
+import { writeCliError } from "../lib/cli-output.js";
+import { attachDefaultProviderSubcommand } from "./inference-providers-default.js";
 
 // ---------------------------------------------------------------------------
 // Response types
@@ -159,32 +160,55 @@ function buildAuthInput(
   credential?: string,
 ): Record<string, unknown> | string {
   if (authType === "api_key") {
-    if (!credential) return "--credential is required when --auth api_key";
+    if (!credential) {
+      return "--credential is required when --auth api_key";
+    }
     return { type: "api_key", credential };
   }
   if (authType === "platform") {
-    if (credential) return "--credential is not accepted with --auth platform";
+    if (credential) {
+      return "--credential is not accepted with --auth platform";
+    }
     return { type: "platform" };
   }
   if (authType === "none") {
-    if (credential) return "--credential is not accepted with --auth none";
+    if (credential) {
+      return "--credential is not accepted with --auth none";
+    }
     return { type: "none" };
   }
   if (authType === "oauth_subscription") {
-    if (!credential)
+    if (!credential) {
       return "--credential is required when --auth oauth_subscription";
+    }
     return { type: "oauth_subscription", credential };
   }
   return `Unknown auth type "${authType}". Use: api_key, platform, none, oauth_subscription`;
 }
 
-function writeCliError(msg: string, json?: boolean): void {
-  if (json) {
-    process.stdout.write(JSON.stringify({ ok: false, error: msg }) + "\n");
-  } else {
-    log.error(msg);
+/** Commander collector for a repeatable option (e.g. `--model` multiple times). */
+function collectRepeatable(value: string, previous: string[]): string[] {
+  return [...previous, value];
+}
+
+/**
+ * Build the openai-compatible custom-provider fields (`base_url`, `models`)
+ * from CLI flags, forwarded to the connection route under its exact field
+ * names. The daemon stays authoritative on whether they are required/allowed;
+ * the CLI only shape-forwards what the user passed.
+ */
+function buildCustomProviderFields(opts: {
+  baseUrl?: string;
+  model?: string[];
+}): Record<string, unknown> {
+  const fields: Record<string, unknown> = {};
+  if (opts.baseUrl !== undefined) {
+    fields.base_url = opts.baseUrl;
+  }
+  if (opts.model !== undefined && opts.model.length > 0) {
+    fields.models = opts.model.map((id) => ({ id }));
   }
-  process.exitCode = 1;
+  return fields;
 }
 
 // ---------------------------------------------------------------------------
@@ -204,6 +228,16 @@ function attachCreateSubcommand(connections: Command): void {
       "--credential <vault-key>",
       "Vault credential name (required for --auth api_key)",
     )
+    .option(
+      "--base-url <url>",
+      "Endpoint base URL (required for --provider openai-compatible)",
+    )
+    .option(
+      "--model <id>",
+      "Model id offered by this connection (repeatable; required for openai-compatible)",
+      collectRepeatable,
+      [] as string[],
+    )
     .option("--json", "Output as JSON")
     .action(
       async (
@@ -212,6 +246,8 @@ function attachCreateSubcommand(connections: Command): void {
           provider: string;
           auth: string;
           credential?: string;
+          baseUrl?: string;
+          model?: string[];
           json?: boolean;
         },
       ) => {
@@ -221,6 +257,14 @@ function attachCreateSubcommand(connections: Command): void {
           return;
         }
 
+        if (opts.provider === "openai-compatible" && !opts.baseUrl) {
+          writeCliError(
+            "--base-url is required when --provider openai-compatible",
+            opts.json,
+          );
+          return;
+        }
+
         const ipcResult = await cliIpcCall<ProviderConnection>(
           "inference_provider_connections_create",
           {
@@ -228,6 +272,7 @@ function attachCreateSubcommand(connections: Command): void {
               name,
               provider: opts.provider,
               auth: authInput,
+              ...buildCustomProviderFields(opts),
             },
           },
         );
@@ -245,7 +290,8 @@ function attachCreateSubcommand(connections: Command): void {
           );
         } else {
           process.stdout.write(
-            `Created connection "${conn.name}" (provider=${conn.provider}, auth=${formatAuth(conn.auth)})\n`,
+            `Created connection "${conn.name}" (provider=${conn.provider}, auth=${formatAuth(conn.auth)})\n` +
+              `Verify it works: point a profile's provider_connection at "${conn.name}", then run: assistant inference send --profile <profile> "Reply with OK"\n`,
           );
         }
       },
@@ -265,11 +311,27 @@ function attachUpdateSubcommand(connections: Command): void {
       "--credential <vault-key>",
       "Vault credential name (required for --auth api_key)",
     )
+    .option(
+      "--base-url <url>",
+      "Endpoint base URL (openai-compatible connections)",
+    )
+    .option(
+      "--model <id>",
+      "Model id offered by this connection (repeatable; openai-compatible)",
+      collectRepeatable,
+      [] as string[],
+    )
     .option("--json", "Output as JSON")
     .action(
       async (
         name: string,
-        opts: { auth: string; credential?: string; json?: boolean },
+        opts: {
+          auth: string;
+          credential?: string;
+          baseUrl?: string;
+          model?: string[];
+          json?: boolean;
+        },
       ) => {
         const authInput = buildAuthInput(opts.auth, opts.credential);
         if (typeof authInput === "string") {
@@ -281,7 +343,7 @@ function attachUpdateSubcommand(connections: Command): void {
           "inference_provider_connections_update",
           {
             pathParams: { name },
-            body: { auth: authInput },
+            body: { auth: authInput, ...buildCustomProviderFields(opts) },
           },
         );
 
@@ -298,7 +360,8 @@ function attachUpdateSubcommand(connections: Command): void {
           );
         } else {
           process.stdout.write(
-            `Updated connection "${name}" auth to ${formatAuth(conn.auth)}\n`,
+            `Updated connection "${name}" auth to ${formatAuth(conn.auth)}\n` +
+              `Verify it works: assistant inference send --profile <profile-using-this-connection> "Reply with OK"\n`,
           );
         }
       },
@@ -498,8 +561,15 @@ Examples:
   $ assistant inference providers connections get anthropic-managed
   $ assistant inference providers connections create anthropic-personal \\
       --provider anthropic --auth api_key --credential credential/anthropic/api_key
+  $ assistant inference providers connections create local-llm \\
+      --provider openai-compatible --auth none \\
+      --base-url http://localhost:1234/v1 --model my-model
   $ assistant inference providers connections update anthropic-personal --auth platform
-  $ assistant inference providers connections delete anthropic-personal`,
+  $ assistant inference providers connections delete anthropic-personal
+
+After creating or updating a connection, validate it with a live call through
+a profile that uses it:
+  $ assistant inference send --profile <profile> "Reply with OK"`,
   );
 
   attachListSubcommand(connections);
@@ -509,4 +579,5 @@ Examples:
   attachDeleteSubcommand(connections);
 
   attachLoginChatgptSubcommand(providers);
+  attachDefaultProviderSubcommand(providers);
 }

package/src/cli/commands/inference.ts

@@ -15,6 +15,9 @@ import { cliIpcCall } from "../../ipc/cli-client.js";
 import { readStdinSync } from "../../util/read-stdin.js";
 import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
+import { attachCallsitesSubcommand } from "./inference-callsites.js";
+import { attachModelsSubcommand } from "./inference-models.js";
+import { attachProfilesSubcommand } from "./inference-profiles.js";
 import { attachProvidersSubcommand } from "./inference-providers.js";
 import { attachSessionSubcommand } from "./inference-session.js";
 
@@ -248,6 +251,9 @@ Examples:
       attachSendSubcommand(inference);
       attachSessionSubcommand(inference);
       attachProvidersSubcommand(inference);
+      attachModelsSubcommand(inference);
+      attachProfilesSubcommand(inference);
+      attachCallsitesSubcommand(inference);
     },
   });