@vellumai/assistant 0.4.54 → 0.4.56

package/src/daemon/{session-queue-manager.ts → conversation-queue-manager.ts}

@@ -1,7 +1,7 @@
 /**
- * Queue types and data structure extracted from Session.
+ * Queue types and data structure extracted from Conversation.
  *
- * Session uses MessageQueue to manage the message backlog while an
+ * Conversation uses MessageQueue to manage the message backlog while an
  * agent loop is in flight.
  */
 
@@ -15,7 +15,7 @@ import type {
   UserMessageAttachment,
 } from "./message-protocol.js";
 
-const log = getLogger("session-queue");
+const log = getLogger("conversation-queue");
 
 export interface QueuedMessage {
   content: string;
@@ -34,9 +34,9 @@ export interface QueuedMessage {
 }
 
 /**
- * Maximum total estimated bytes across all queued messages per session.
+ * Maximum total estimated bytes across all queued messages per conversation.
  * Limits memory consumption when a sender floods messages while the
- * session is busy.  50 MB is well above any legitimate usage.
+ * conversation is busy.  50 MB is well above any legitimate usage.
  */
 export const DEFAULT_MAX_QUEUE_BYTES = 50 * 1024 * 1024; // 50 MB
 
@@ -59,8 +59,8 @@ export interface QueuePolicy {
 /**
  * Typed wrapper around the queued-message array.
  *
- * Session owns one instance; the wrapper handles iteration
- * so the rest of Session doesn't touch the raw array.
+ * Conversation owns one instance; the wrapper handles iteration
+ * so the rest of Conversation doesn't touch the raw array.
  *
  * A byte budget caps total memory held by queued messages so a
  * high-rate sender cannot exhaust the process.
@@ -80,7 +80,10 @@ export class MessageQueue {
    */
   push(item: QueuedMessage): boolean {
     const itemBytes = estimateItemBytes(item);
-    if (this.currentBytes + itemBytes > this.maxBytes && this.items.length > 0) {
+    if (
+      this.currentBytes + itemBytes > this.maxBytes &&
+      this.items.length > 0
+    ) {
       log.warn(
         {
           requestId: item.requestId,

package/src/daemon/{session-runtime-assembly.ts → conversation-runtime-assembly.ts}

@@ -1,5 +1,5 @@
 /**
- * Runtime message-injection helpers extracted from Session.
+ * Runtime message-injection helpers extracted from Conversation.
  *
  * These functions modify the user-message tail of the conversation
  * before it is sent to the provider.  They are pure (no side effects).
@@ -42,11 +42,11 @@ export interface ChannelCapabilities {
 }
 
 /**
- * Runtime trust context for an inbound actor session.
+ * Runtime trust context for an inbound actor conversation.
  *
  * Carries the resolved trust classification, guardian binding metadata, and
- * requester identity for the current session. This is the canonical trust
- * shape used by sessions, tool execution, memory gating, and channel routing.
+ * requester identity for the current conversation. This is the canonical trust
+ * shape used by conversations, tool execution, memory gating, and channel routing.
  *
  * Produced by {@link resolveActorTrust} -> {@link toTrustContext}, or by
  * the convenience wrapper {@link resolveTrustContext}.
@@ -376,14 +376,20 @@ export function resolveChannelCapabilities(
 /**
  * Returns true when the chat type indicates a group/multi-party conversation
  * (Telegram group/supergroup, Slack channel/group/mpim, etc.).
+ *
+ * Slack "channel" is intentionally classified as group chat: channels are
+ * inherently multi-party spaces where group etiquette (e.g. only respond when
+ * addressed) applies — even for low-traffic or announcement-style channels.
+ * The etiquette helps the assistant avoid responding to every message in a
+ * channel where it is a passive participant.
  */
 export function isGroupChatType(chatType?: string): boolean {
   if (!chatType) return false;
   switch (chatType) {
-    case "group":
-    case "supergroup":
-    case "channel":
-    case "mpim":
+    case "group": // Telegram group
+    case "supergroup": // Telegram supergroup
+    case "channel": // Slack channel — multi-party by definition
+    case "mpim": // Slack multi-party direct message
       return true;
     default:
       return false;
@@ -576,7 +582,7 @@ export function injectActiveSurfaceContext(
 /**
  * Append voice call-control protocol instructions to the last user
  * message so the model knows how to emit control markers during voice
- * turns routed through the session pipeline.
+ * turns routed through the conversation pipeline.
  */
 export function injectVoiceCallControlContext(
   message: Message,
@@ -1132,7 +1138,7 @@ export function applyRuntimeInjections(
   const mode = options.mode ?? "full";
   let result = runMessages;
 
-  // For non-interactive sessions (scheduled jobs, work items), instruct the
+  // For non-interactive conversations (scheduled jobs, work items), instruct the
   // model to never ask for clarification — there is no human present to answer.
   if (options.isNonInteractive) {
     const userTail = result[result.length - 1];
@@ -1266,7 +1272,7 @@ const ATTACHMENT_CONTENT_TYPES = new Set(["image", "file"]);
  * Scan conversation messages for user-uploaded attachment content blocks
  * (image or file). Returns true as soon as any attachment is found.
  *
- * Used to set the one-way `hasAttachments` flag on Session so that asset
+ * Used to set the one-way `hasAttachments` flag on Conversation so that asset
  * tools (asset_search, asset_materialize) are included in tool definitions
  * only when the conversation contains attachments.
  */

package/src/daemon/{session-skill-tools.ts → conversation-skill-tools.ts}

@@ -1,8 +1,8 @@
 /**
- * Session-time projection of active skill tools.
+ * Conversation-time projection of active skill tools.
  *
  * On each agent turn the conversation history (and any pre-activated IDs from
- * config or slash commands) determine which skills are "active".  This module
+ * config or programmatic injection) determine which skills are "active".  This module
  * computes the union, loads tool manifests, registers new skill tools, tears
  * down tools for skills that are no longer active, and returns the projected
  * tool definitions so the agent loop can include them in the next request.
@@ -29,7 +29,7 @@ import {
 import { createSkillToolsFromManifest } from "../tools/skills/skill-tool-factory.js";
 import { getLogger } from "../util/logger.js";
 
-const log = getLogger("session-skill-tools");
+const log = getLogger("conversation-skill-tools");
 
 // ---------------------------------------------------------------------------
 // Public types
@@ -43,10 +43,10 @@ export interface SkillToolProjection {
 }
 
 /**
- * Session-scoped cache for skill projection. Avoids re-scanning the entire
+ * Conversation-scoped cache for skill projection. Avoids re-scanning the entire
  * conversation history and re-reading the filesystem on every agent turn.
  *
- * Each session should own its own cache instance to prevent cross-session
+ * Each conversation should own its own cache instance to prevent cross-conversation
  * state bleed.
  */
 export interface SkillProjectionCache {
@@ -63,7 +63,7 @@ export interface SkillProjectionCache {
     /** The accumulated active skill entries. */
     entries: ActiveSkillEntry[];
   };
-  /** Cached skill catalog. Invalidated when the session is marked stale
+  /** Cached skill catalog. Invalidated when the conversation is marked stale
    *  (e.g. skill directories changed on disk while a run is in progress). */
   catalog?: SkillSummary[];
 }
@@ -72,15 +72,15 @@ export interface ProjectSkillToolsOptions {
   /** Skill IDs that should be treated as active regardless of history markers. */
   preactivatedSkillIds?: string[];
   /**
-   * Session-scoped tracking map of previously active skill IDs to their
-   * version hashes. Each session should own its own map to prevent
-   * cross-session state bleed when the daemon serves multiple concurrent
-   * sessions. When a skill's hash changes between turns, its tools are
+   * Conversation-scoped tracking map of previously active skill IDs to their
+   * version hashes. Each conversation should own its own map to prevent
+   * cross-conversation state bleed when the daemon serves multiple concurrent
+   * conversations. When a skill's hash changes between turns, its tools are
    * unregistered and re-registered with the updated definitions.
    */
   previouslyActiveSkillIds?: Map<string, string>;
   /**
-   * Session-scoped projection cache. When provided, projectSkillTools will
+   * Conversation-scoped projection cache. When provided, projectSkillTools will
    * avoid redundant deriveActiveSkills scans and loadSkillCatalog filesystem
    * reads across agent turns.
    */
@@ -122,7 +122,7 @@ function loadManifestForSkill(skill: SkillSummary): SkillToolManifest | null {
 /**
  * Return active skill entries, using the projection cache when available.
  *
- * History is append-only within a session (messages are only added, never
+ * History is append-only within a conversation (messages are only added, never
  * mutated in place). If history.length hasn't changed since the last scan,
  * the cached result is returned immediately. If new messages were appended,
  * only the delta is scanned and merged. If history shrank (e.g. compression
@@ -192,8 +192,8 @@ function getCachedActiveSkills(
 /**
  * Return the skill catalog, caching it across agent turns.
  *
- * The cache is invalidated when the session is marked stale (e.g. skill
- * directories changed on disk while the session is still processing).
+ * The cache is invalidated when the conversation is marked stale (e.g. skill
+ * directories changed on disk while the conversation is still processing).
  */
 function getCachedCatalog(cache?: SkillProjectionCache): SkillSummary[] {
   if (!cache) return loadSkillCatalog();
@@ -209,7 +209,7 @@ function getCachedCatalog(cache?: SkillProjectionCache): SkillSummary[] {
 // ---------------------------------------------------------------------------
 
 /**
- * Compute the set of active skill tools for the current session turn.
+ * Compute the set of active skill tools for the current conversation turn.
  *
  * 1. Derives active skill IDs from conversation history markers.
  * 2. Merges with any preactivated IDs (union).
@@ -240,7 +240,7 @@ export function projectSkillTools(
   const contextIds = contextEntries.map((e) => e.id);
   const allCandidateIds = new Set<string>([...contextIds, ...preactivated]);
 
-  // Load the catalog (cached for session lifetime) and index by ID
+  // Load the catalog (cached for conversation lifetime) and index by ID
   const catalog = getCachedCatalog(options?.cache);
   const catalogById = new Map<string, SkillSummary>();
   for (const skill of catalog) {
@@ -398,7 +398,7 @@ export function projectSkillTools(
     }
   }
 
-  // Update the session-scoped tracking map in-place — only include skills
+  // Update the conversation-scoped tracking map in-place — only include skills
   // that were successfully processed so failed skills can be retried next turn.
   prevActive.clear();
   for (const [id, hash] of successfulEntries) {
@@ -413,7 +413,7 @@ export function projectSkillTools(
 
 /**
  * Reset the projection state and unregister all skill tools tracked in the
- * given map. Used for session teardown and tests.
+ * given map. Used for conversation teardown and tests.
  */
 export function resetSkillToolProjection(
   trackedIds?: Map<string, string>,

package/src/daemon/{session-slash.ts → conversation-slash.ts}

@@ -5,29 +5,21 @@ import { join } from "node:path";
 import QRCode from "qrcode";
 
 import { getGatewayPort, getIngressPublicBaseUrl } from "../config/env.js";
+import { getConfig, loadRawConfig, saveRawConfig } from "../config/loader.js";
+import { setServiceField } from "../config/raw-config-utils.js";
 import {
-  API_KEY_PROVIDERS,
-  getConfig,
-  loadRawConfig,
-  saveRawConfig,
-} from "../config/loader.js";
-import { resolveSkillStates } from "../config/skill-state.js";
-import { loadSkillCatalog } from "../config/skills.js";
+  getConfiguredProviders,
+  isProviderAvailable,
+} from "../providers/provider-availability.js";
 import { initializeProviders } from "../providers/registry.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
-import {
-  buildInvocableSlashCatalog,
-  resolveSlashSkillCommand,
-  rewriteKnownSlashCommandPrompt,
-} from "../skills/slash-commands.js";
 import { getLocalIPv4 } from "../util/network-info.js";
 import { getWorkspaceDir } from "../util/platform.js";
+import { silentlyWithLog } from "../util/silently.js";
 import { getAssistantName } from "./identity-helpers.js";
 import type { PairingStore } from "./pairing-store.js";
 
 export type SlashResolution =
   | { kind: "passthrough"; content: string }
-  | { kind: "rewritten"; content: string; skillId: string }
   | { kind: "unknown"; message: string; qrFilename?: string };
 
 // ── /pair command — module-level pairing context ────────────────────
@@ -163,8 +155,8 @@ async function resolveProviderModelCommand(
   const config = getConfig();
   const name = getAssistantName();
 
-  // Check if API key exists for this provider (Ollama doesn't require an API key)
-  if (provider !== "ollama" && !(await getSecureKeyAsync(provider))) {
+  // Check if provider is available (secure key, env var, managed proxy, or no key needed)
+  if (!(await isProviderAvailable(provider))) {
     return {
       kind: "unknown",
       message: `Cannot switch to ${displayName}. No API key configured for ${provider}.\n\nSet it with: \`keys set ${provider} <your-key>\``,
@@ -172,7 +164,10 @@ async function resolveProviderModelCommand(
   }
 
   // Check if already using this provider+model
-  if (config.provider === provider && config.model === model) {
+  if (
+    config.services.inference.provider === provider &&
+    config.services.inference.model === model
+  ) {
     const alreadyMsg = name
       ? `${name} is already running on **${displayName}**.`
       : `Already using **${displayName}**.`;
@@ -184,8 +179,8 @@ async function resolveProviderModelCommand(
 
   // Update config with both provider and model
   const raw = loadRawConfig();
-  raw.provider = provider;
-  raw.model = model;
+  setServiceField(raw, "inference", "provider", provider);
+  setServiceField(raw, "inference", "model", model);
   saveRawConfig(raw);
 
   // Re-initialize providers with new config
@@ -205,13 +200,8 @@ async function resolveProviderModelCommand(
 async function resolveModelList(): Promise<SlashResolution> {
   const config = getConfig();
 
-  // Build a set of providers that have a configured API key.
-  const configuredProviders = new Set<string>(["ollama"]);
-  for (const p of API_KEY_PROVIDERS) {
-    if (await getSecureKeyAsync(p)) {
-      configuredProviders.add(p);
-    }
-  }
+  // Build a set of providers that are usable (secure key, env var, or managed proxy).
+  const configuredProviders = new Set<string>(await getConfiguredProviders());
 
   const lines = ["Available models:\n"];
 
@@ -219,7 +209,9 @@ async function resolveModelList(): Promise<SlashResolution> {
     PROVIDER_MODEL_SHORTCUTS,
   )) {
     const hasKey = configuredProviders.has(provider);
-    const isCurrent = config.provider === provider && config.model === model;
+    const isCurrent =
+      config.services.inference.provider === provider &&
+      config.services.inference.model === model;
     const status = hasKey ? "✓" : "✗";
     const current = isCurrent ? " **[current]**" : "";
     lines.push(`- **${displayName}** (/${cmd}) ${status}${current}`);
@@ -253,11 +245,13 @@ async function resolveModelCommand(
   if (!args) {
     // Show current model
     const config = getConfig();
-    const displayName = MODEL_DISPLAY_NAMES[config.model] ?? config.model;
+    const displayName =
+      MODEL_DISPLAY_NAMES[config.services.inference.model] ??
+      config.services.inference.model;
     const prefix = name ? `${name} is running on` : `Currently using`;
     return {
       kind: "unknown",
-      message: `${prefix} **${displayName}** (\`${config.model}\`).`,
+      message: `${prefix} **${displayName}** (\`${config.services.inference.model}\`).`,
     };
   }
 
@@ -280,7 +274,7 @@ async function resolveModelCommand(
 
   // Check if already using this model
   const currentConfig = getConfig();
-  if (currentConfig.model === matched) {
+  if (currentConfig.services.inference.model === matched) {
     const displayName = MODEL_DISPLAY_NAMES[matched] ?? matched;
     const alreadyMsg = name
       ? `${name} is already running on **${displayName}**.`
@@ -291,8 +285,8 @@ async function resolveModelCommand(
     };
   }
 
-  // Validate that Anthropic provider is available
-  if (!(await getSecureKeyAsync("anthropic"))) {
+  // Validate that Anthropic provider is available (secure key, env var, or managed proxy)
+  if (!(await isProviderAvailable("anthropic"))) {
     const displayName = MODEL_DISPLAY_NAMES[matched] ?? matched;
     return {
       kind: "unknown",
@@ -302,8 +296,8 @@ async function resolveModelCommand(
 
   // Change model: save config and re-initialize providers
   const raw = loadRawConfig();
-  raw.provider = "anthropic"; // Ensure provider is set for Anthropic models
-  raw.model = matched;
+  setServiceField(raw, "inference", "provider", "anthropic"); // Ensure provider is set for Anthropic models
+  setServiceField(raw, "inference", "model", matched);
   saveRawConfig(raw);
   const config = getConfig();
   await initializeProviders(config);
@@ -338,7 +332,7 @@ function resolveStatusCommand(context: SlashContext): SlashResolution {
   const displayName = MODEL_DISPLAY_NAMES[model] ?? model;
 
   const lines = [
-    "Session Status\n",
+    "Conversation Status\n",
     `Context:  ${bar}  ${pct}%  (${fmt(inputTokens)} / ${fmt(
       maxInputTokens,
     )} tokens)`,
@@ -352,7 +346,7 @@ function resolveStatusCommand(context: SlashContext): SlashResolution {
 }
 
 /**
- * Resolve slash commands against the current skill catalog.
+ * Resolve built-in slash commands (/model, /status, /commands, /pair, provider shortcuts).
  * Returns `unknown` with a deterministic message, or the (possibly rewritten) content.
  */
 export async function resolveSlash(
@@ -391,7 +385,7 @@ export async function resolveSlash(
       "/pair — Generate pairing info for connecting a mobile device",
     ];
     if (context) {
-      lines.push("/status — Show session status and context usage");
+      lines.push("/status — Show conversation status and context usage");
     }
     return {
       kind: "unknown",
@@ -399,30 +393,6 @@ export async function resolveSlash(
     };
   }
 
-  const config = getConfig();
-  const catalog = loadSkillCatalog();
-  const resolved = resolveSkillStates(catalog, config);
-  const invocable = buildInvocableSlashCatalog(catalog, resolved);
-  const resolution = resolveSlashSkillCommand(content, invocable);
-
-  if (resolution.kind === "known") {
-    const skill = invocable.get(resolution.skillId.toLowerCase());
-    return {
-      kind: "rewritten",
-      content: rewriteKnownSlashCommandPrompt({
-        rawInput: content,
-        skillId: resolution.skillId,
-        skillName: skill?.name ?? resolution.skillId,
-        trailingArgs: resolution.trailingArgs,
-      }),
-      skillId: resolution.skillId,
-    };
-  }
-
-  if (resolution.kind === "unknown") {
-    return { kind: "unknown", message: resolution.message };
-  }
-
   return { kind: "passthrough", content };
 }
 
@@ -514,7 +484,10 @@ function resolvePairCommand(content: string): SlashResolution | null {
   // so the synchronous slash resolution is not blocked).
   const payloadJson = JSON.stringify(payload);
   const qrFilename = buildPairingQRCodeFilename();
-  savePairingQRCodePng(payloadJson, qrFilename).catch(() => {});
+  silentlyWithLog(
+    savePairingQRCodePng(payloadJson, qrFilename),
+    "save pairing QR code PNG",
+  );
 
   const lines = [
     "Pairing Ready\n",