@vellumai/assistant 0.8.0 → 0.8.1

package/src/runtime/routes/contact-routes.ts

@@ -18,12 +18,8 @@ import {
   mergeContacts,
   searchContacts,
   updateChannelStatus,
-  upsertAssistantContactMetadata,
-  upsertContact,
-  validateSpeciesMetadata,
 } from "../../contacts/contact-store.js";
 import type {
-  AssistantSpecies,
   ChannelPolicy,
   ChannelStatus,
   ContactRole,
@@ -58,10 +54,6 @@ function withGuardianNameOverride<
 }
 
 const VALID_CONTACT_TYPES: readonly ContactType[] = ["human", "assistant"];
-const VALID_ASSISTANT_SPECIES: readonly AssistantSpecies[] = [
-  "vellum",
-  "openclaw",
-];
 
 const VALID_CHANNEL_STATUSES: readonly ChannelStatus[] = [
   "active",
@@ -80,10 +72,6 @@ function isContactType(value: string): value is ContactType {
   return (VALID_CONTACT_TYPES as readonly string[]).includes(value);
 }
 
-function isAssistantSpecies(value: string): value is AssistantSpecies {
-  return (VALID_ASSISTANT_SPECIES as readonly string[]).includes(value);
-}
-
 function isChannelStatus(value: string): value is ChannelStatus {
   return (VALID_CHANNEL_STATUSES as readonly string[]).includes(value);
 }
@@ -489,34 +477,6 @@ export const ROUTES: RouteDefinition[] = [
     handler: ({ pathParams }: RouteHandlerArgs) =>
       handleGetContact(pathParams!.id),
   },
-  {
-    operationId: "upsert_contact",
-    endpoint: "contacts",
-    method: "POST",
-    summary: "Create or update a contact",
-    description:
-      "Create a new contact or update an existing one. Supports upsert by contactId or channel handle.",
-    tags: ["contacts"],
-    requestBody: z.object({
-      contactId: z.string().describe("Existing contact ID (for update)"),
-      displayName: z.string().describe("Display name"),
-      channels: z
-        .array(z.unknown())
-        .describe("Channel objects with channelId, handle, displayName"),
-      assistantMetadata: z
-        .object({})
-        .passthrough()
-        .describe("Assistant-side metadata"),
-    }),
-    responseBody: z.object({
-      ok: z.boolean(),
-      contact: z
-        .object({})
-        .passthrough()
-        .describe("Created or updated contact"),
-    }),
-    handler: (args: RouteHandlerArgs) => handleUpsertContactRoute(args),
-  },
   {
     operationId: "merge_contacts",
     endpoint: "contacts/merge",
@@ -582,126 +542,6 @@ function handleMergeContactsRoute(args: RouteHandlerArgs) {
   }
 }
 
-function handleUpsertContactRoute(args: RouteHandlerArgs) {
-  const body = (args.body ?? {}) as {
-    id?: string;
-    displayName?: string;
-    notes?: string;
-    role?: string;
-    contactType?: string;
-    assistantMetadata?: {
-      species: string;
-      metadata?: Record<string, unknown>;
-    };
-    channels?: Array<{
-      type: string;
-      address: string;
-      isPrimary?: boolean;
-      status?: string;
-      policy?: string;
-      externalUserId?: string;
-      externalChatId?: string;
-    }>;
-  };
-
-  if (
-    !body.displayName ||
-    typeof body.displayName !== "string" ||
-    body.displayName.trim().length === 0
-  ) {
-    throw new BadRequestError(
-      "displayName is required and must be a non-empty string",
-    );
-  }
-
-  if (body.contactType !== undefined && !isContactType(body.contactType)) {
-    throw new BadRequestError(
-      `Invalid contactType "${body.contactType}". Must be one of: ${VALID_CONTACT_TYPES.join(", ")}`,
-    );
-  }
-
-  if (body.contactType === "assistant") {
-    if (!body.assistantMetadata) {
-      throw new BadRequestError(
-        'assistantMetadata is required when contactType is "assistant"',
-      );
-    }
-    if (!isAssistantSpecies(body.assistantMetadata.species)) {
-      throw new BadRequestError(
-        `Invalid species "${body.assistantMetadata.species}". Must be one of: ${VALID_ASSISTANT_SPECIES.join(", ")}`,
-      );
-    }
-    try {
-      validateSpeciesMetadata(
-        body.assistantMetadata.species as AssistantSpecies,
-        body.assistantMetadata.metadata ?? null,
-      );
-    } catch (err) {
-      throw new BadRequestError(
-        err instanceof Error ? err.message : String(err),
-      );
-    }
-  }
-
-  if (body.contactType === "human" && body.assistantMetadata) {
-    throw new BadRequestError(
-      'assistantMetadata must not be provided when contactType is "human"',
-    );
-  }
-
-  if (body.assistantMetadata && !body.contactType) {
-    throw new BadRequestError(
-      'contactType must be "assistant" when assistantMetadata is provided',
-    );
-  }
-
-  if (body.channels) {
-    if (!Array.isArray(body.channels)) {
-      throw new BadRequestError("channels must be an array");
-    }
-    for (const ch of body.channels) {
-      if (ch.status !== undefined && !isChannelStatus(ch.status)) {
-        throw new BadRequestError(
-          `Invalid channel status "${ch.status}". Must be one of: ${VALID_CHANNEL_STATUSES.join(", ")}`,
-        );
-      }
-      if (ch.policy !== undefined && !isChannelPolicy(ch.policy)) {
-        throw new BadRequestError(
-          `Invalid channel policy "${ch.policy}". Must be one of: ${VALID_CHANNEL_POLICIES.join(", ")}`,
-        );
-      }
-    }
-  }
-
-  try {
-    const contact = upsertContact({
-      id: body.id,
-      displayName: body.displayName.trim(),
-      notes: body.notes,
-      role: body.role as ContactRole | undefined,
-      contactType: body.contactType as ContactType | undefined,
-      channels: body.channels?.map((ch) => ({
-        ...ch,
-        status: ch.status as ChannelStatus | undefined,
-        policy: ch.policy as ChannelPolicy | undefined,
-      })),
-    });
-
-    if (body.assistantMetadata) {
-      upsertAssistantContactMetadata({
-        contactId: contact.id,
-        species: body.assistantMetadata.species as AssistantSpecies,
-        metadata: body.assistantMetadata.metadata ?? null,
-      });
-    }
-
-    return { ok: true, contact: withGuardianNameOverride(contact) };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new BadRequestError(message);
-  }
-}
-
 function handleUpdateContactChannelRoute(args: RouteHandlerArgs) {
   const channelId = args.pathParams!.contactChannelId;
   const body = (args.body ?? {}) as {

package/src/runtime/routes/conversation-cli-routes.ts

@@ -0,0 +1,192 @@
+/**
+ * CLI-specific route handlers for conversation operations.
+ *
+ * These routes serve the thin CLI wrappers — they return simple shapes
+ * optimised for terminal output rather than the richer serialisations
+ * used by the macOS / web clients.
+ */
+
+import { z } from "zod";
+
+import { clearAllConversations as clearAllActive } from "../../daemon/handlers/conversations.js";
+import { formatJson, formatMarkdown } from "../../export/formatter.js";
+import {
+  createConversation,
+  getConversation,
+  getMessages,
+} from "../../memory/conversation-crud.js";
+import { listConversations } from "../../memory/conversation-queries.js";
+import { getLogger } from "../../util/logger.js";
+import { BadRequestError, NotFoundError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const log = getLogger("conversation-cli-routes");
+
+// ---------------------------------------------------------------------------
+// list (CLI)
+// ---------------------------------------------------------------------------
+
+function handleListCli({ body = {} }: RouteHandlerArgs) {
+  const limit =
+    body.limit != null ? Number(body.limit) : Number.MAX_SAFE_INTEGER;
+  const includeArchived = (body.includeArchived as boolean) ?? false;
+
+  const rows = listConversations(limit, false, 0, includeArchived);
+  return {
+    conversations: rows.map((c) => ({
+      id: c.id,
+      title: c.title,
+      updatedAt: c.updatedAt,
+    })),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// create (CLI)
+// ---------------------------------------------------------------------------
+
+function handleCreateCli({ body = {} }: RouteHandlerArgs) {
+  const title = body.title as string | undefined;
+  const conversation = createConversation(title);
+  return {
+    id: conversation.id,
+    title: conversation.title ?? "New Conversation",
+  };
+}
+
+// ---------------------------------------------------------------------------
+// export (CLI)
+// ---------------------------------------------------------------------------
+
+function handleExportCli({ body = {} }: RouteHandlerArgs) {
+  const format = (body.format as string) ?? "md";
+  if (format !== "md" && format !== "json") {
+    throw new BadRequestError('format must be "md" or "json"');
+  }
+
+  let conversationId = body.conversationId as string | undefined;
+
+  if (!conversationId) {
+    const all = listConversations(1);
+    if (all.length === 0) {
+      throw new NotFoundError("No conversations found");
+    }
+    conversationId = all[0].id;
+  }
+
+  // Support prefix matching
+  let conversation = getConversation(conversationId);
+  if (!conversation) {
+    const all = listConversations(Number.MAX_SAFE_INTEGER);
+    const match = all.find((c) => c.id.startsWith(conversationId!));
+    if (match) {
+      conversation = match;
+    } else {
+      throw new NotFoundError(`Conversation not found: ${conversationId}`);
+    }
+  }
+
+  const msgs = getMessages(conversation.id);
+  const exportData = {
+    ...conversation,
+    messages: msgs.map((m) => ({
+      role: m.role,
+      content: JSON.parse(m.content),
+      createdAt: m.createdAt,
+    })),
+  };
+
+  const output =
+    format === "json" ? formatJson(exportData) : formatMarkdown(exportData);
+
+  return { output, conversationId: conversation.id };
+}
+
+// ---------------------------------------------------------------------------
+// clear (CLI)
+// ---------------------------------------------------------------------------
+
+async function handleClearCli(_args: RouteHandlerArgs) {
+  // Tear down in-memory conversation state before DB clear.
+  const cleared = clearAllActive();
+  log.info({ cleared }, "CLI conversations clear: active conversations torn down");
+  return { cleared };
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "conversation_list_cli",
+    endpoint: "conversations/cli/list",
+    method: "POST",
+    summary: "List conversations (CLI)",
+    description:
+      "Simplified conversation list for CLI output — returns id, title, updatedAt.",
+    tags: ["conversations"],
+    requestBody: z.object({
+      limit: z.number().int().positive().optional(),
+      includeArchived: z.boolean().optional(),
+    }),
+    responseBody: z.object({
+      conversations: z.array(
+        z.object({
+          id: z.string(),
+          title: z.string().nullable(),
+          updatedAt: z.number(),
+        }),
+      ),
+    }),
+    handler: handleListCli,
+  },
+  {
+    operationId: "conversation_create_cli",
+    endpoint: "conversations/cli/create",
+    method: "POST",
+    summary: "Create a conversation (CLI)",
+    description: "Create a new conversation with an optional title.",
+    tags: ["conversations"],
+    requestBody: z.object({
+      title: z.string().optional(),
+    }),
+    responseBody: z.object({
+      id: z.string(),
+      title: z.string(),
+    }),
+    handler: handleCreateCli,
+  },
+  {
+    operationId: "conversation_export_cli",
+    endpoint: "conversations/cli/export",
+    method: "POST",
+    summary: "Export a conversation (CLI)",
+    description:
+      "Export a conversation as markdown or JSON. Returns the formatted output string.",
+    tags: ["conversations"],
+    requestBody: z.object({
+      conversationId: z.string().optional(),
+      format: z.enum(["md", "json"]).default("md"),
+    }),
+    responseBody: z.object({
+      output: z.string(),
+      conversationId: z.string(),
+    }),
+    handler: handleExportCli,
+  },
+  {
+    operationId: "conversations_clear_cli",
+    endpoint: "conversations/cli/clear",
+    method: "POST",
+    summary: "Clear all conversations (CLI)",
+    description:
+      "Tear down all active conversations and clear the database. " +
+      "The confirmation prompt is handled client-side by the CLI.",
+    tags: ["conversations"],
+    responseBody: z.object({
+      cleared: z.number().int(),
+    }),
+    handler: handleClearCli,
+  },
+];

package/src/runtime/routes/conversation-management-routes.ts

@@ -19,7 +19,6 @@
 
 import { z } from "zod";
 
-import { loadConfig } from "../../config/loader.js";
 import { destroyActiveConversation } from "../../daemon/conversation-store.js";
 import {
   cancelGeneration,
@@ -37,7 +36,6 @@ import {
   deleteConversation,
   forkConversation as forkConversationInStore,
   getConversation,
-  setConversationInferenceProfile,
   unarchiveConversation,
   updateConversationTitle,
   wipeConversation,
@@ -55,6 +53,7 @@ import { buildAssistantEvent } from "../assistant-event.js";
 import { assistantEventHub } from "../assistant-event-hub.js";
 import { buildConversationDetailResponse } from "../services/conversation-serializer.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
+import { setInferenceProfileSession } from "./inference-profile-session-handler.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("conversation-management-routes");
@@ -183,16 +182,10 @@ async function handleSwitchConversation({ body = {} }: RouteHandlerArgs) {
   };
 }
 
-function handleSetInferenceProfile({
+async function handleSetInferenceProfile({
   pathParams = {},
   body = {},
 }: RouteHandlerArgs) {
-  const resolvedId = resolveConversationId(pathParams.id!) ?? pathParams.id!;
-  const conversation = getConversation(resolvedId);
-  if (!conversation) {
-    throw new NotFoundError(`Conversation ${pathParams.id} not found`);
-  }
-
   if (
     body.profile !== null &&
     (typeof body.profile !== "string" || (body.profile as string).length === 0)
@@ -200,38 +193,14 @@ function handleSetInferenceProfile({
     throw new BadRequestError("profile must be a non-empty string or null");
   }
 
-  const profile = body.profile as string | null;
-  if (profile !== null) {
-    const profiles = loadConfig().llm?.profiles ?? {};
-    if (!Object.prototype.hasOwnProperty.call(profiles, profile)) {
-      throw new BadRequestError(
-        `Profile "${profile}" is not defined in llm.profiles`,
-      );
-    }
-  }
-
-  if (conversation.inferenceProfile !== profile) {
-    setConversationInferenceProfile(resolvedId, profile);
-    assistantEventHub
-      .publish(
-        buildAssistantEvent(
-          {
-            type: "conversation_inference_profile_updated",
-            conversationId: resolvedId,
-            profile,
-          },
-          resolvedId,
-        ),
-      )
-      .catch((err) => {
-        log.warn(
-          { err, conversationId: resolvedId },
-          "Failed to publish conversation_inference_profile_updated event",
-        );
-      });
-  }
+  const result = await setInferenceProfileSession({
+    conversationId: pathParams.id!,
+    profile: body.profile as string | null,
+    ttlSeconds: body.ttlSeconds as number | null | undefined,
+    sessionId: body.sessionId as string | undefined,
+  });
 
-  return { conversationId: resolvedId, profile };
+  return result;
 }
 
 function handleRenameConversation({
@@ -364,8 +333,8 @@ function handleUnarchiveConversation({ pathParams = {} }: RouteHandlerArgs) {
 
 function handleCancelGeneration({ pathParams = {} }: RouteHandlerArgs) {
   const resolvedId = resolveConversationId(pathParams.id!) ?? pathParams.id!;
-  cancelGeneration(resolvedId);
-  return undefined;
+  const cancelled = cancelGeneration(resolvedId);
+  return { ok: true, cancelled, conversationId: resolvedId };
 }
 
 async function handleUndoLastMessage({ pathParams = {} }: RouteHandlerArgs) {
@@ -500,15 +469,28 @@ export const ROUTES: RouteDefinition[] = [
     policyKey: "conversations/inference-profile",
     summary: "Set conversation inference profile",
     description:
-      "Override the LLM inference profile for a single conversation.",
+      "Override the LLM inference profile for a single conversation. " +
+      "Optionally supply ttlSeconds to create a session-backed (expiring) override.",
     tags: ["conversations"],
     pathParams: [{ name: "id", type: "uuid" }],
     requestBody: z.object({
       profile: z.string().nullable(),
+      ttlSeconds: z.number().positive().nullable().optional(),
+      sessionId: z.string().uuid().optional(),
     }),
     responseBody: z.object({
       conversationId: z.string(),
       profile: z.string().nullable(),
+      sessionId: z.string().nullable(),
+      expiresAt: z.number().nullable(),
+      ttlSeconds: z.number().nullable().optional(),
+      replaced: z
+        .object({
+          profile: z.string().nullable(),
+          sessionId: z.string().nullable(),
+          expiresAt: z.number().nullable(),
+        })
+        .nullable(),
     }),
     handler: handleSetInferenceProfile,
   },
@@ -600,6 +582,11 @@ export const ROUTES: RouteDefinition[] = [
     tags: ["conversations"],
     pathParams: [{ name: "id" }],
     responseStatus: "202",
+    responseBody: z.object({
+      ok: z.boolean(),
+      cancelled: z.boolean(),
+      conversationId: z.string(),
+    }),
     handler: handleCancelGeneration,
   },
   {