@vellumai/assistant 0.8.0 → 0.8.1

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

@@ -0,0 +1,415 @@
+/**
+ * `assistant inference session` CLI namespace.
+ *
+ * Subcommands:
+ *   - `assistant inference session open <profileName>`  — Open a profile session
+ *   - `assistant inference session close`               — Close the active profile session
+ *   - `assistant inference session list`                — List active profile sessions
+ *
+ * All commands delegate to the daemon via IPC.
+ */
+
+import type { Command } from "commander";
+
+import { cliIpcCall } from "../../ipc/cli-client.js";
+import { log } from "../logger.js";
+import { resolveConversationId } from "../utils/conversation-id.js";
+import { parseDuration } from "../utils/parse-duration.js";
+
+const CONV_ID_HELP =
+  "No conversation ID available.\n" +
+  "Provide --conversation-id explicitly, or run from a skill or bash tool context.";
+
+/**
+ * Default session TTL in seconds when --ttl is not specified.
+ * Matches the documented default of 30 minutes.
+ */
+const DEFAULT_TTL_SECONDS = 1800;
+
+// ── Type aliases ─────────────────────────────────────────────────────
+
+type OpenResult = {
+  conversationId: string;
+  profile: string | null;
+  sessionId: string | null;
+  expiresAt: number | null;
+  ttlSeconds: number | null;
+  replaced: {
+    profile: string | null;
+    sessionId: string | null;
+    expiresAt: number | null;
+  } | null;
+};
+
+type CloseResult = {
+  conversationId: string;
+  closed: { profile: string | null; sessionId: string | null } | null;
+  noop: boolean;
+};
+
+type ListSession = {
+  conversationId: string;
+  conversationTitle: string | null;
+  profile: string;
+  sessionId: string;
+  expiresAt: number;
+  remainingSeconds: number;
+};
+
+type ListResult = { sessions: ListSession[] };
+
+// ── Helpers ───────────────────────────────────────────────────────────
+
+function formatDuration(seconds: number): string {
+  if (seconds >= 3600 && seconds % 3600 === 0) return `${seconds / 3600}h`;
+  if (seconds >= 3600) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    return m > 0 ? `${h}h${m}m` : `${h}h`;
+  }
+  if (seconds >= 60 && seconds % 60 === 0) return `${seconds / 60}m`;
+  if (seconds >= 60) {
+    const m = Math.floor(seconds / 60);
+    const s = seconds % 60;
+    return s > 0 ? `${m}m${s}s` : `${m}m`;
+  }
+  return `${seconds}s`;
+}
+
+function formatLocalTime(epochMs: number): string {
+  return new Date(epochMs).toLocaleTimeString(undefined, {
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZoneName: "short",
+  });
+}
+
+function writeLine(msg: string): void {
+  process.stdout.write(msg + "\n");
+}
+
+// ── Registration ─────────────────────────────────────────────────────
+
+export function attachSessionSubcommand(parent: Command): void {
+  const session = parent
+    .command("session")
+    .description("Manage conversation-scoped inference profile sessions");
+
+  session.addHelpText(
+    "after",
+    `
+Inference profile sessions pin a named model profile to a specific
+conversation for the duration of the session.
+
+Examples:
+  $ assistant inference session open balanced --ttl 30m
+  $ assistant inference session open fast --ttl never
+  $ assistant inference session close
+  $ assistant inference session list`,
+  );
+
+  // ── profile open ──────────────────────────────────────────────────
+
+  session
+    .command("open <profileName>")
+    .description("Open a profile session for the current conversation")
+    .option(
+      "--ttl <duration>",
+      'Session TTL (e.g. 30m, 1h, "never" for sticky; default: 30m)',
+    )
+    .option(
+      "--conversation-id <id>",
+      "Conversation ID (auto-resolved from context if omitted)",
+    )
+    .option("--json", "Output result as machine-readable JSON")
+    .addHelpText(
+      "after",
+      `
+Opens a profile session that pins the given profile to the current
+conversation. The session expires after --ttl, or is sticky (no
+expiry) if --ttl never is specified. If --ttl is omitted, the session
+defaults to 30m.
+
+Examples:
+  $ assistant inference session open balanced --ttl 30m
+  $ assistant inference session open fast --ttl never
+  $ assistant inference session open balanced            # uses default 30m TTL
+  $ assistant inference session open balanced --json`,
+    )
+    .action(
+      async (
+        profileName: string,
+        opts: {
+          ttl?: string;
+          conversationId?: string;
+          json?: boolean;
+        },
+      ) => {
+        let conversationId: string;
+        try {
+          conversationId = resolveConversationId({
+            explicit: opts.conversationId,
+            failureHelp: CONV_ID_HELP,
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (opts.json) {
+            process.stdout.write(JSON.stringify({ ok: false, error: msg }) + "\n");
+          } else {
+            log.error(`Error: ${msg}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        // Parse TTL
+        let ttlSeconds: number | null | undefined; // undefined = omit from body
+        let requestedTtlSeconds: number | undefined;
+
+        if (opts.ttl !== undefined) {
+          if (opts.ttl === "never") {
+            ttlSeconds = null;
+          } else {
+            try {
+              ttlSeconds = parseDuration(opts.ttl);
+              requestedTtlSeconds = ttlSeconds;
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              if (opts.json) {
+                process.stdout.write(JSON.stringify({ ok: false, error: msg }) + "\n");
+              } else {
+                log.error(`Error: ${msg}`);
+              }
+              process.exitCode = 1;
+              return;
+            }
+          }
+        }
+
+        const effectiveTtlSeconds =
+          ttlSeconds !== undefined ? ttlSeconds : DEFAULT_TTL_SECONDS;
+        const body: Record<string, unknown> = {
+          conversationId,
+          profile: profileName,
+          ttlSeconds: effectiveTtlSeconds,
+        };
+
+        const ipcResult = await cliIpcCall<OpenResult>(
+          "inference_profile_open",
+          { body },
+        );
+
+        if (!ipcResult.ok) {
+          if (opts.json) {
+            process.stdout.write(JSON.stringify({ ok: false, error: ipcResult.error }) + "\n");
+          } else {
+            log.error(`Error: ${ipcResult.error}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const result = ipcResult.result!;
+        const { sessionId, expiresAt, replaced } = result;
+        const resultTtlSeconds = result.ttlSeconds;
+
+        if (opts.json) {
+          process.stdout.write(
+            JSON.stringify({
+              ok: true,
+              conversationId: result.conversationId,
+              profile: profileName,
+              sessionId,
+              expiresAt: expiresAt ? new Date(expiresAt).toISOString() : null,
+              ttlSeconds: resultTtlSeconds,
+              replaced: replaced
+                ? {
+                    ...replaced,
+                    expiresAt: replaced.expiresAt
+                      ? new Date(replaced.expiresAt).toISOString()
+                      : null,
+                  }
+                : null,
+            }) + "\n",
+          );
+        } else {
+          // Warn if TTL was clamped by the server (human-readable mode only)
+          if (
+            typeof requestedTtlSeconds === "number" &&
+            typeof resultTtlSeconds === "number" &&
+            requestedTtlSeconds !== resultTtlSeconds
+          ) {
+            writeLine(`note: ttl clamped to ${formatDuration(resultTtlSeconds)} (config maxTtlSeconds)`);
+          }
+
+          // Human-readable output
+          if (resultTtlSeconds == null) {
+            writeLine(`profile ${profileName} active (sticky, no expiry)`);
+          } else {
+            const expireStr = expiresAt != null ? formatLocalTime(expiresAt) : "?";
+            writeLine(
+              `profile ${profileName} active for ${formatDuration(resultTtlSeconds)} (until ${expireStr})`,
+            );
+          }
+
+          if (replaced) {
+            const replacedExpiry = replaced.expiresAt
+              ? formatLocalTime(replaced.expiresAt)
+              : "?";
+            writeLine(
+              `replaced: ${replaced.profile} (was active until ${replacedExpiry})`,
+            );
+          }
+        }
+      },
+    );
+
+  // ── profile close ─────────────────────────────────────────────────
+
+  session
+    .command("close")
+    .description("Close the active profile session for the current conversation")
+    .option(
+      "--conversation-id <id>",
+      "Conversation ID (auto-resolved from context if omitted)",
+    )
+    .option("--json", "Output result as machine-readable JSON")
+    .addHelpText(
+      "after",
+      `
+Closes the active profile session for the conversation. This is
+idempotent — if no session is active the command succeeds with
+a "no active profile session" message.
+
+Examples:
+  $ assistant inference session close
+  $ assistant inference session close --json`,
+    )
+    .action(
+      async (opts: { conversationId?: string; json?: boolean }) => {
+        let conversationId: string;
+        try {
+          conversationId = resolveConversationId({
+            explicit: opts.conversationId,
+            failureHelp: CONV_ID_HELP,
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (opts.json) {
+            process.stdout.write(JSON.stringify({ ok: false, error: msg }) + "\n");
+          } else {
+            log.error(`Error: ${msg}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const ipcResult = await cliIpcCall<CloseResult>(
+          "inference_profile_close",
+          { body: { conversationId } },
+        );
+
+        if (!ipcResult.ok) {
+          if (opts.json) {
+            process.stdout.write(JSON.stringify({ ok: false, error: ipcResult.error }) + "\n");
+          } else {
+            log.error(`Error: ${ipcResult.error}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const result = ipcResult.result!;
+
+        if (opts.json) {
+          process.stdout.write(
+            JSON.stringify({
+              ok: true,
+              conversationId: result.conversationId,
+              closed: result.closed,
+              noop: result.noop,
+            }) + "\n",
+          );
+        } else {
+          if (result.noop || !result.closed) {
+            writeLine("no active profile session");
+          } else {
+            writeLine(`closed profile ${result.closed.profile}`);
+          }
+        }
+      },
+    );
+
+  // ── profile list ──────────────────────────────────────────────────
+
+  session
+    .command("list")
+    .description("List active profile sessions")
+    .option(
+      "--conversation-id <id>",
+      "Filter to a specific conversation ID",
+    )
+    .option("--json", "Output result as machine-readable JSON")
+    .addHelpText(
+      "after",
+      `
+Lists all active inference profile sessions. Optionally filter by
+conversation ID.
+
+Examples:
+  $ assistant inference session list
+  $ assistant inference session list --conversation-id conv-abc123
+  $ assistant inference session list --json`,
+    )
+    .action(async (opts: { conversationId?: string; json?: boolean }) => {
+      const ipcResult = await cliIpcCall<ListResult>(
+        "inference_profile_list",
+        {
+          queryParams: opts.conversationId
+            ? { conversationId: opts.conversationId }
+            : {},
+        },
+      );
+
+      if (!ipcResult.ok) {
+        if (opts.json) {
+          process.stdout.write(JSON.stringify({ ok: false, error: ipcResult.error }) + "\n");
+        } else {
+          log.error(`Error: ${ipcResult.error}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      const { sessions } = ipcResult.result!;
+
+      if (opts.json) {
+        process.stdout.write(
+          JSON.stringify({
+            ok: true,
+            sessions: sessions.map((s) => ({
+              ...s,
+              expiresAt: s.expiresAt != null ? new Date(s.expiresAt).toISOString() : null,
+            })),
+          }) + "\n",
+        );
+        return;
+      }
+
+      if (sessions.length === 0) {
+        writeLine("no active profile sessions");
+        return;
+      }
+
+      writeLine(`${sessions.length} active session(s):`);
+      for (const s of sessions) {
+        const convId = s.conversationId.padEnd(14);
+        const profile = s.profile.padEnd(16);
+        const remaining = `${formatDuration(s.remainingSeconds)} left`.padEnd(12);
+        const rawTitle = s.conversationTitle ?? "...";
+        const title =
+          rawTitle.length > 30 ? rawTitle.slice(0, 30) + "..." : rawTitle;
+        writeLine(`  ${convId}  ${profile}  ${remaining}  "${title}"`);
+      }
+    });
+}

package/src/cli/commands/inference.ts

@@ -1,13 +1,36 @@
+/**
+ * `assistant inference` and `assistant llm` CLI namespace.
+ *
+ * Subcommands:
+ *   - `send`       — Send a message to the configured LLM (via `inference_send` IPC)
+ *   - `session`    — Manage conversation-scoped inference profile sessions
+ *   - `providers`  — Inference provider admin commands
+ *
+ * The `llm` alias exposes only `send`.
+ */
+
 import { readFileSync } from "node:fs";
 
 import type { Command } from "commander";
 
-import {
-  extractAllText,
-  getConfiguredProvider,
-  userMessage,
-} from "../../providers/provider-send-message.js";
+import { cliIpcCall } from "../../ipc/cli-client.js";
+import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
+import { attachProvidersSubcommand } from "./inference-providers.js";
+import { attachSessionSubcommand } from "./inference-session.js";
+
+// ── Types ────────────────────────────────────────────────────────────
+
+interface InferenceSendResult {
+  response: string;
+  model: string;
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+}
+
+// ── Send subcommand ──────────────────────────────────────────────────
 
 /**
  * Attach the `send` subcommand to the given command group (`inference` or
@@ -19,6 +42,10 @@ function attachSendSubcommand(group: Command): void {
     .description("Send a message to the configured LLM and print the response")
     .option("--system-prompt <text>", "System prompt for the model")
     .option("--model <model-id>", "Model override")
+    .option(
+      "--profile <name>",
+      "Apply a named inference profile from llm.profiles for this single call",
+    )
     .option("--max-tokens <n>", "Max response tokens", undefined)
     .option("--json", "Output structured JSON")
     .argument("[message...]", "User message (joined with spaces)")
@@ -28,13 +55,18 @@ function attachSendSubcommand(group: Command): void {
 Behavioral notes:
   - If no message argument is provided, reads from stdin.
   - If --model is omitted, uses the configured default model.
+  - --profile applies a named profile from llm.profiles for this single call
+    only. It does NOT open a session — to pin a profile to a conversation,
+    use 'assistant inference profile open <name>'.
+  - --profile layers below --model: --model still wins on the model field.
   - Requires a configured LLM provider (see 'assistant config set').
 
 Examples:
   $ assistant inference send "What is 2+2?"
   $ echo "Summarize this" | assistant inference send
   $ assistant llm send --system-prompt "You are a poet" "Write a haiku"
-  $ assistant inference send --model claude-sonnet-4-20250514 --json "Hello"`,
+  $ assistant inference send --model claude-sonnet-4-20250514 --json "Hello"
+  $ assistant inference send --profile balanced "Explain RFC 1149"`,
     )
     .action(
       async (
@@ -42,11 +74,12 @@ Examples:
         opts: {
           systemPrompt?: string;
           model?: string;
+          profile?: string;
           maxTokens?: string;
           json?: boolean;
         },
       ) => {
-        const { systemPrompt, model, json: jsonOutput } = opts;
+        const { systemPrompt, model, profile, json: jsonOutput } = opts;
         const maxTokens = opts.maxTokens
           ? parseInt(opts.maxTokens, 10)
           : undefined;
@@ -92,78 +125,60 @@ Examples:
           return;
         }
 
-        // Resolve provider.
-        const provider = await getConfiguredProvider("inference");
-        if (!provider) {
-          const msg =
-            "No LLM provider is configured. Run 'assistant config set llm.default.provider <provider>' to set one up.";
+        // Build IPC body
+        const body: Record<string, unknown> = { message: messageText };
+        if (systemPrompt) body.systemPrompt = systemPrompt;
+        if (model) body.model = model;
+        if (profile) body.profile = profile;
+        if (maxTokens) body.maxTokens = maxTokens;
+
+        const ipcResult = await cliIpcCall<InferenceSendResult>(
+          "inference_send",
+          { body },
+        );
+
+        if (!ipcResult.ok) {
           if (jsonOutput) {
             process.stdout.write(
-              JSON.stringify({ ok: false, error: msg }) + "\n",
+              JSON.stringify({ ok: false, error: ipcResult.error }) + "\n",
             );
           } else {
-            log.error(msg);
+            log.error(ipcResult.error ?? "Unknown error occurred");
           }
           process.exitCode = 1;
           return;
         }
 
-        try {
-          const response = await provider.sendMessage(
-            [userMessage(messageText)],
-            undefined,
-            systemPrompt,
-            {
-              config: {
-                callSite: "inference",
-                max_tokens: maxTokens,
-                model,
-              },
-            },
-          );
+        const result = ipcResult.result!;
 
-          const text = extractAllText(response);
-
-          if (jsonOutput) {
-            process.stdout.write(
-              JSON.stringify({
-                ok: true,
-                response: text,
-                model: response.model,
-                usage: {
-                  inputTokens: response.usage.inputTokens,
-                  outputTokens: response.usage.outputTokens,
-                },
-              }) + "\n",
-            );
-          } else {
-            process.stdout.write(text + "\n");
-          }
-        } catch (err) {
-          const msg =
-            err instanceof Error ? err.message : "Unknown error occurred";
-          if (jsonOutput) {
-            process.stdout.write(
-              JSON.stringify({ ok: false, error: msg }) + "\n",
-            );
-          } else {
-            log.error(msg);
-          }
-          process.exitCode = 1;
+        if (jsonOutput) {
+          process.stdout.write(
+            JSON.stringify({
+              ok: true,
+              response: result.response,
+              model: result.model,
+              usage: result.usage,
+            }) + "\n",
+          );
+        } else {
+          process.stdout.write(result.response + "\n");
         }
       },
     );
 }
 
+// ── Registration ─────────────────────────────────────────────────────
+
 /**
  * Register `inference` and `llm` command groups on the top-level program.
- * Both expose the same subcommands — `llm` is an alias for `inference`.
+ * Both expose `send`. Profile management is only available under `inference`.
  */
 export function registerInferenceCommand(program: Command): void {
-  const inference = program
-    .command("inference")
-    .description("LLM inference operations");
-
+  registerCommand(program, {
+    name: "inference",
+    transport: "ipc",
+    description: "LLM inference operations",
+    build: (inference) => {
   inference.addHelpText(
     "after",
     `
@@ -174,26 +189,33 @@ Examples:
   $ assistant inference send "What is the capital of France?"
   $ echo "Explain quantum computing" | assistant inference send
   $ assistant llm send --system-prompt "Be concise" "What is TCP?"
-  $ assistant inference send --model claude-sonnet-4-20250514 --json "Hello"`,
+  $ assistant inference send --model claude-sonnet-4-20250514 --json "Hello"
+  $ assistant inference send --profile balanced "Explain RFC 1149"`,
   );
 
   attachSendSubcommand(inference);
+  attachSessionSubcommand(inference);
+  attachProvidersSubcommand(inference);
+    },
+  });
 
   const llm = program
     .command("llm")
-    .description("LLM inference operations (alias for 'inference')");
+    .description("LLM inference operations (alias for 'inference send')");
 
   llm.addHelpText(
     "after",
     `
-The llm command group is an alias for 'inference'. It sends requests to your
-configured LLM provider, resolved from your assistant config (llm.default.provider).
+The llm command group is a shorthand for 'assistant inference send'. It sends
+requests to your configured LLM provider, resolved from your assistant config
+(llm.default.provider). For profile session management, use 'assistant inference session'.
 
 Examples:
   $ assistant llm send "What is the capital of France?"
   $ echo "Explain quantum computing" | assistant llm send
   $ assistant llm send --system-prompt "Be concise" "What is TCP?"
-  $ assistant llm send --model claude-sonnet-4-20250514 --json "Hello"`,
+  $ assistant llm send --model claude-sonnet-4-20250514 --json "Hello"
+  $ assistant llm send --profile balanced "Explain RFC 1149"`,
   );
 
   attachSendSubcommand(llm);

package/src/cli/commands/keys.ts

@@ -7,6 +7,7 @@ import {
   deleteSecureKeyViaDaemon,
   setSecureKeyViaDaemon,
 } from "../lib/daemon-credential-client.js";
+import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 
 // ---------------------------------------------------------------------------
@@ -28,9 +29,11 @@ const UNTRUSTED_SHELL_ERROR =
   "API key management is restricted when running under CES shell lockdown.";
 
 export function registerKeysCommand(program: Command): void {
-  const keys = program
-    .command("keys")
-    .description("Manage API keys in secure storage");
+  registerCommand(program, {
+    name: "keys",
+    transport: "local",
+    description: "Manage API keys in secure storage",
+    build: (keys) => {
 
   keys.addHelpText(
     "after",
@@ -147,4 +150,6 @@ Examples:
         process.exit(1);
       }
     });
+    },
+  });
 }