@vellumai/assistant 0.6.3 → 0.6.5

package/src/cli/commands/completions.ts

@@ -54,7 +54,6 @@ Examples:
         "contacts",
         "autonomy",
         "audit",
-        "doctor",
         "completions",
         "help",
       ];
@@ -137,7 +136,6 @@ _assistant() {
         'contacts:Manage the contact graph'
         'autonomy:View and configure autonomy tiers'
         'audit:Show recent tool invocations'
-        'doctor:Run diagnostic checks'
         'completions:Generate shell completion script'
         'help:Display help'
     )
@@ -178,7 +176,6 @@ function generateFishCompletion(
     contacts: "Manage the contact graph",
     autonomy: "View and configure autonomy tiers",
     audit: "Show recent tool invocations",
-    doctor: "Run diagnostic checks",
     completions: "Generate shell completion script",
     help: "Display help",
   };

package/src/cli/commands/config.ts

@@ -54,9 +54,9 @@ and "assistant keys set <provider> <key>" to view and manage API keys.
 
 Examples:
   $ assistant config list
-  $ assistant config get services.inference.provider
+  $ assistant config get llm.default.provider
   $ assistant config schema services
-  $ assistant config set services.inference.provider anthropic
+  $ assistant config set llm.default.provider anthropic
   $ assistant config set calls.enabled true`,
   );
 
@@ -69,7 +69,7 @@ Examples:
       "after",
       `
 Arguments:
-  key     Dotted path to the config key (e.g. services.inference.provider,
+  key     Dotted path to the config key (e.g. llm.default.provider,
           calls.enabled, twilio.accountSid). Intermediate objects are created
           automatically.
   value   The value to store. Parsed as JSON first (so "true" becomes boolean
@@ -81,7 +81,7 @@ After writing the value to config.json, the change takes effect immediately.
 To manage API keys, use "assistant keys set <provider> <key>" instead.
 
 Examples:
-  $ assistant config set services.inference.provider anthropic
+  $ assistant config set llm.default.provider anthropic
   $ assistant config set calls.enabled true`,
     )
     .action(
@@ -114,7 +114,7 @@ Examples:
       "after",
       `
 Arguments:
-  key   Dotted path to the config key (e.g. services.inference.provider,
+  key   Dotted path to the config key (e.g. llm.default.provider,
         calls.enabled)
 
 Prints the value at the given key path. If the key is not set, prints
@@ -123,7 +123,7 @@ Prints the value at the given key path. If the key is not set, prints
 To view API keys, use "assistant keys list" instead.
 
 Examples:
-  $ assistant config get services.inference.provider
+  $ assistant config get llm.default.provider
   $ assistant config get calls.enabled`,
     )
     .action((key: string) => {

package/src/cli/commands/conversations-import.ts

@@ -0,0 +1,347 @@
+import { existsSync, readFileSync } from "node:fs";
+
+import type { Command } from "commander";
+import { eq } from "drizzle-orm";
+
+import { getConfig } from "../../config/loader.js";
+import {
+  addMessage,
+  createConversation,
+} from "../../memory/conversation-crud.js";
+import {
+  getConversationByKey,
+  setConversationKey,
+} from "../../memory/conversation-key-store.js";
+import { getDb } from "../../memory/db.js";
+import { indexMessageNow } from "../../memory/indexer.js";
+import {
+  conversations as conversationsTable,
+  messages as messagesTable,
+} from "../../memory/schema.js";
+import { getLogger } from "../../util/logger.js";
+import { initializeDb } from "../db.js";
+import { log } from "../logger.js";
+
+const importLog = getLogger("conversations-import");
+
+// -- Import payload schema --
+
+interface ImportMessage {
+  role: string;
+  content: string | Array<{ type: string; text: string }>;
+  createdAt?: number;
+}
+
+interface ImportConversation {
+  sourceKey?: string;
+  title: string;
+  createdAt?: number;
+  updatedAt?: number;
+  messages: ImportMessage[];
+}
+
+interface ImportPayload {
+  conversations: ImportConversation[];
+}
+
+interface ImportResult {
+  ok: boolean;
+  imported: number;
+  skipped: number;
+  messages: number;
+  errors: Array<{
+    index: number;
+    sourceKey?: string;
+    error: string;
+  }>;
+}
+
+// -- Validation --
+
+function validatePayload(raw: unknown): ImportPayload {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("Input must be a JSON object with a 'conversations' array");
+  }
+  const obj = raw as Record<string, unknown>;
+  if (!Array.isArray(obj.conversations)) {
+    throw new Error("Input must have a 'conversations' array");
+  }
+  for (let i = 0; i < obj.conversations.length; i++) {
+    const conv = obj.conversations[i] as Record<string, unknown>;
+    if (!conv.title || typeof conv.title !== "string") {
+      throw new Error(
+        `conversations[${i}].title is required and must be a string`,
+      );
+    }
+    if (!Array.isArray(conv.messages) || conv.messages.length === 0) {
+      throw new Error(`conversations[${i}].messages must be a non-empty array`);
+    }
+    for (let j = 0; j < (conv.messages as unknown[]).length; j++) {
+      const msg = (conv.messages as Array<Record<string, unknown>>)[j];
+      if (!msg.role || typeof msg.role !== "string") {
+        throw new Error(`conversations[${i}].messages[${j}].role is required`);
+      }
+      if (msg.content === undefined || msg.content === null) {
+        throw new Error(
+          `conversations[${i}].messages[${j}].content is required`,
+        );
+      }
+    }
+  }
+  return obj as unknown as ImportPayload;
+}
+
+// -- Timestamp resolution --
+
+function resolveTimestamps(conv: ImportConversation): {
+  convCreatedAt: number;
+  convUpdatedAt: number;
+  messageTimestamps: number[];
+} {
+  const now = Date.now();
+  const convCreatedAt = conv.createdAt ?? now;
+  const convUpdatedAt = conv.updatedAt ?? conv.createdAt ?? now;
+
+  const messageTimestamps = conv.messages.map((msg, i) => {
+    if (msg.createdAt != null) return msg.createdAt;
+    return convCreatedAt + i;
+  });
+
+  return { convCreatedAt, convUpdatedAt, messageTimestamps };
+}
+
+// -- Core import logic --
+
+async function importConversations(
+  payload: ImportPayload,
+): Promise<ImportResult> {
+  const db = getDb();
+  const memoryConfig = getConfig().memory;
+
+  let imported = 0;
+  let skipped = 0;
+  let totalMessages = 0;
+  const errors: ImportResult["errors"] = [];
+
+  for (let idx = 0; idx < payload.conversations.length; idx++) {
+    const conv = payload.conversations[idx];
+
+    try {
+      // Dedup via sourceKey
+      if (conv.sourceKey) {
+        const existing = getConversationByKey(conv.sourceKey);
+        if (existing) {
+          skipped++;
+          continue;
+        }
+      }
+
+      const { convCreatedAt, convUpdatedAt, messageTimestamps } =
+        resolveTimestamps(conv);
+
+      // Create conversation
+      const conversation = createConversation(conv.title);
+
+      // Insert messages with skipIndexing (timestamps will be overridden)
+      for (const msg of conv.messages) {
+        const contentStr =
+          typeof msg.content === "string"
+            ? msg.content
+            : JSON.stringify(msg.content);
+
+        await addMessage(conversation.id, msg.role, contentStr, undefined, {
+          skipIndexing: true,
+        });
+      }
+
+      // Override conversation timestamps to match originals
+      db.update(conversationsTable)
+        .set({
+          createdAt: convCreatedAt,
+          updatedAt: convUpdatedAt,
+          lastMessageAt: messageTimestamps[messageTimestamps.length - 1],
+        })
+        .where(eq(conversationsTable.id, conversation.id))
+        .run();
+
+      // Override message timestamps to match originals
+      const dbMessages = db
+        .select({ id: messagesTable.id })
+        .from(messagesTable)
+        .where(eq(messagesTable.conversationId, conversation.id))
+        .orderBy(messagesTable.createdAt)
+        .all();
+
+      for (
+        let i = 0;
+        i < dbMessages.length && i < messageTimestamps.length;
+        i++
+      ) {
+        db.update(messagesTable)
+          .set({ createdAt: messageTimestamps[i] })
+          .where(eq(messagesTable.id, dbMessages[i].id))
+          .run();
+      }
+
+      // Index messages with original timestamps (non-fatal on failure)
+      for (let i = 0; i < dbMessages.length && i < conv.messages.length; i++) {
+        const msg = conv.messages[i];
+        const contentStr =
+          typeof msg.content === "string"
+            ? msg.content
+            : JSON.stringify(msg.content);
+
+        try {
+          await indexMessageNow(
+            {
+              messageId: dbMessages[i].id,
+              conversationId: conversation.id,
+              role: msg.role,
+              content: contentStr,
+              createdAt: messageTimestamps[i],
+            },
+            memoryConfig,
+          );
+        } catch (err) {
+          importLog.warn(
+            "Failed to index imported message %s in conversation %s: %s",
+            dbMessages[i].id,
+            conversation.id,
+            err instanceof Error ? err.message : String(err),
+          );
+        }
+      }
+
+      // Register sourceKey for dedup
+      if (conv.sourceKey) {
+        setConversationKey(conv.sourceKey, conversation.id);
+      }
+
+      imported++;
+      totalMessages += conv.messages.length;
+    } catch (err) {
+      errors.push({
+        index: idx,
+        sourceKey: conv.sourceKey,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    imported,
+    skipped,
+    messages: totalMessages,
+    errors,
+  };
+}
+
+// -- CLI registration --
+
+export function registerConversationsImportCommand(
+  conversations: Command,
+): void {
+  conversations
+    .command("import")
+    .description("Import conversations from a standard JSON format")
+    .option("--file <path>", "Read JSON from file instead of stdin")
+    .option("--json", "Output result as machine-readable JSON")
+    .addHelpText(
+      "after",
+      `
+Imports conversations into the assistant from a standard JSON format.
+Reads from stdin by default, or from a file with --file.
+
+The input JSON must have the shape:
+  { "conversations": [{ "title": "...", "messages": [...] }] }
+
+Each conversation may include:
+  sourceKey         External key for dedup (e.g. "chatgpt:abc123")
+  createdAt         Unix epoch milliseconds for the conversation
+  updatedAt         Unix epoch milliseconds for the conversation
+  messages[].role   "user" or "assistant"
+  messages[].content  String or array of {type, text} content blocks
+  messages[].createdAt  Unix epoch milliseconds for the message
+
+Messages are indexed for memory search after import. Re-importing with
+the same sourceKey will skip already-imported conversations.
+
+Examples:
+  $ bun run scripts/parse-export.ts --file export.zip | assistant conversations import --json
+  $ assistant conversations import --file import.json --json
+  $ cat data.json | assistant conversations import`,
+    )
+    .action(async (opts: { file?: string; json?: boolean }) => {
+      let raw: string;
+      try {
+        if (opts.file) {
+          if (!existsSync(opts.file)) {
+            throw new Error(`File not found: ${opts.file}`);
+          }
+          raw = readFileSync(opts.file, "utf-8");
+        } else {
+          if (process.stdin.isTTY) {
+            throw new Error(
+              "No input provided. Pipe JSON into stdin or use --file <path>.",
+            );
+          }
+          raw = readFileSync("/dev/stdin", "utf-8");
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (opts.json) {
+          log.info(JSON.stringify({ ok: false, error: msg }));
+        } else {
+          log.error(`Error: ${msg}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      let payload: ImportPayload;
+      try {
+        const parsed = JSON.parse(raw);
+        payload = validatePayload(parsed);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (opts.json) {
+          log.info(JSON.stringify({ ok: false, error: msg }));
+        } else {
+          log.error(`Error: ${msg}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      if (payload.conversations.length === 0) {
+        const result = { ok: true, imported: 0, skipped: 0, messages: 0 };
+        if (opts.json) {
+          log.info(JSON.stringify(result));
+        } else {
+          log.info("No conversations to import.");
+        }
+        return;
+      }
+
+      initializeDb();
+      const result = await importConversations(payload);
+
+      if (opts.json) {
+        log.info(JSON.stringify(result));
+      } else {
+        const lines = [
+          `Imported ${result.imported} conversation(s) with ${result.messages} message(s).`,
+        ];
+        if (result.skipped > 0) {
+          lines.push(
+            `Skipped ${result.skipped} already-imported conversation(s).`,
+          );
+        }
+        if (result.errors.length > 0) {
+          lines.push(`Failed: ${result.errors.length} conversation(s).`);
+        }
+        log.info(lines.join("\n"));
+      }
+    });
+}

package/src/cli/commands/conversations.ts

@@ -10,6 +10,7 @@ import { shouldAutoStartDaemon } from "../../daemon/connection-policy.js";
 import { healthCheckHost, isHttpHealthy } from "../../daemon/daemon-control.js";
 import { ensureDaemonRunning } from "../../daemon/lifecycle.js";
 import { formatJson, formatMarkdown } from "../../export/formatter.js";
+import { cliIpcCall } from "../../ipc/cli-client.js";
 import {
   clearAll as clearAllConversations,
   countConversationsByScheduleJobId,
@@ -34,12 +35,15 @@ import { deleteSchedule } from "../../schedule/schedule-store.js";
 import { timeAgo } from "../../util/time.js";
 import { initializeDb } from "../db.js";
 import { log } from "../logger.js";
+import { registerConversationsImportCommand } from "./conversations-import.js";
 
 export function registerConversationsCommand(program: Command): void {
   const conversations = program
     .command("conversations")
     .description("Manage conversations");
 
+  registerConversationsImportCommand(conversations);
+
   conversations.addHelpText(
     "after",
     `
@@ -388,4 +392,90 @@ Examples:
           `cancelled ${result.cancelledJobCount} jobs.`,
       );
     });
+
+  conversations
+    .command("wake <conversationId>")
+    .description(
+      "Wake the agent on an existing conversation with an internal hint",
+    )
+    .requiredOption(
+      "--hint <text>",
+      "Hint message visible to the LLM (not persisted to transcript)",
+    )
+    .option(
+      "--source <label>",
+      "Source label for logging (e.g. github-notification)",
+      "cli",
+    )
+    .option("--json", "Output result as JSON")
+    .addHelpText(
+      "after",
+      `
+Arguments:
+  conversationId   Conversation ID to wake.
+
+Wake the assistant's agent loop on an existing conversation without a user
+message. The hint is injected as a non-persisted internal message visible
+only to the LLM — it never appears in the transcript or SSE feed. If the
+agent produces output (text or tool calls), it is persisted and emitted to
+connected clients. Otherwise the wake is a silent no-op.
+
+Requires the assistant to be running. Communicates via IPC socket.
+
+Examples:
+  $ assistant conversations wake abc123 --hint "PR #25933 received a review requesting changes"
+  $ assistant conversations wake abc123 --hint "CI failed on commit abc" --source github-ci
+  $ assistant conversations wake abc123 --hint "New Slack DM from Vargas" --source slack --json`,
+    )
+    .action(
+      async (
+        conversationId: string,
+        opts: { hint: string; source: string; json?: boolean },
+      ) => {
+        const result = await cliIpcCall<{
+          invoked: boolean;
+          producedToolCalls: boolean;
+          reason?: "not_found" | "timeout" | "no_resolver";
+        }>("wake_conversation", {
+          conversationId,
+          hint: opts.hint,
+          source: opts.source,
+        });
+
+        if (!result.ok) {
+          if (opts.json) {
+            log.info(JSON.stringify({ ok: false, error: result.error }));
+          } else {
+            log.error(`Error: ${result.error}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const wake = result.result!;
+        if (opts.json) {
+          log.info(JSON.stringify({ ok: true, ...wake }));
+          return;
+        }
+        if (wake.invoked) {
+          log.info(
+            wake.producedToolCalls
+              ? `Wake produced output on conversation ${conversationId}`
+              : `Wake invoked on ${conversationId} (no output produced)`,
+          );
+        } else if (wake.reason === "timeout") {
+          // Conversation exists but stayed busy past the wait-until-idle
+          // window. This is a transient condition, not an error — the
+          // caller can retry later. Exit 0.
+          log.info(
+            `Conversation ${conversationId} is busy — wake skipped (retry later)`,
+          );
+        } else {
+          log.error(
+            `Could not wake conversation ${conversationId} — conversation not found`,
+          );
+          process.exitCode = 1;
+        }
+      },
+    );
 }

package/src/cli/commands/credentials.ts

@@ -248,7 +248,6 @@ storage convention used internally (credential/{service}/{field}):
   --service telegram --field bot_token        Telegram bot token
   --service slack_channel --field bot_token   Slack channel bot token
   --service github --field token              GitHub personal access token
-  --service agentmail --field api_key         AgentMail API key
 
 Secrets are stored in AES-256-GCM encrypted storage. Metadata (policy,
 timestamps, labels) is tracked separately and never contains secret values.