@vellumai/assistant 0.12.0 → 0.12.1-staging.1

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

@@ -22,6 +22,7 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../providers/provider-send-message.js";
+import { isMaxTokensStopReason } from "../../providers/stop-reasons.js";
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError } from "./errors.js";
@@ -176,9 +177,44 @@ function buildCommandPrompt(body: DictationBody, stylePrompt?: string): string {
   return sections.join("\n");
 }
 
-function computeMaxTokens(inputLength: number): number {
+export function computeMaxTokens(inputLength: number): number {
   const estimatedInputTokens = Math.ceil(inputLength / 3);
-  return Math.max(256, estimatedInputTokens + 128);
+  // The cleanup tool call carries the whole transcript back in its `text`
+  // argument, plus a `reasoning` string and the JSON scaffolding around both,
+  // so the budget has to cover well more than the input alone. `max_tokens` is
+  // a ceiling rather than a target: a call that stops short of it costs no
+  // extra latency.
+  return Math.max(512, estimatedInputTokens * 2 + 256);
+}
+
+export type CleanupRejection = "truncated";
+
+/**
+ * Decide whether the cleanup model's rewrite is safe to use as the payload.
+ *
+ * The rewrite replaces what the user actually said. A token-cap stop means the
+ * tool JSON was cut mid-argument, so however complete the `text` argument
+ * happens to look, it is a fragment; the raw transcript is the safer payload
+ * then. Unpolished beats wrong.
+ *
+ * Whether a shorter rewrite still preserved the meaning is the model's call
+ * (the prompt asks it to drop fillers and tighten phrasing), so there is no
+ * length check here: a deterministic ratio cannot tell a concise cleanup from
+ * a summary.
+ */
+export function resolveCleanedDictation(
+  raw: string,
+  cleaned: string,
+  stopReason: string | null | undefined,
+): { text: string; rejected: CleanupRejection | null } {
+  const trimmed = cleaned.trim();
+  if (!trimmed) {
+    return { text: raw, rejected: null };
+  }
+  if (isMaxTokensStopReason(stopReason)) {
+    return { text: raw, rejected: "truncated" };
+  }
+  return { text: trimmed, rejected: null };
 }
 
 interface DictationResult {
@@ -329,7 +365,23 @@ async function handleDictation(body: DictationBody): Promise<DictationResult> {
             ...profileMeta,
           };
         }
-        const cleanedText = input.text?.trim() || transcription;
+        const { text: cleanedText, rejected } = resolveCleanedDictation(
+          transcription,
+          input.text ?? "",
+          response.stopReason,
+        );
+        if (rejected) {
+          // Lengths only -- transcript content must never be logged.
+          log.warn(
+            {
+              rejected,
+              stopReason: response.stopReason,
+              rawChars: transcription.length,
+              cleanedChars: input.text?.trim().length ?? 0,
+            },
+            "Dictation cleanup rejected, using raw transcription",
+          );
+        }
         const normalizedText = applyDictionary(cleanedText, profile.dictionary);
         return {
           text: normalizedText,

package/src/runtime/routes/index.ts

@@ -39,6 +39,7 @@ import { ROUTES as CALL_ROUTES } from "./call-routes.js";
 import { ROUTES as CHANNEL_AVAILABILITY_ROUTES } from "./channel-availability-routes.js";
 import { ROUTES as CHANNEL_READINESS_ROUTES } from "./channel-readiness-routes.js";
 import { CHANNEL_ROUTES } from "./channel-route-definitions.js";
+import { ROUTES as CHANNEL_SEND_ROUTES } from "./channel-send-routes.js";
 import { ROUTES as CHANNEL_VERIFICATION_ROUTES } from "./channel-verification-routes.js";
 import { ROUTES as CHATGPT_SUBSCRIPTION_AUTH_ROUTES } from "./chatgpt-subscription-auth-routes.js";
 import { ROUTES as CLIENT_ROUTES } from "./client-routes.js";
@@ -62,6 +63,7 @@ import { ROUTES as DEBUG_BASH_ROUTES } from "./debug-bash-routes.js";
 import { ROUTES as DEBUG_ROUTES } from "./debug-routes.js";
 import { ROUTES as DEFAULT_PROVIDER_ROUTES } from "./default-provider-routes.js";
 import { ROUTES as DEFER_ROUTES } from "./defer-routes.js";
+import { ROUTES as DESKTOP_SETUP_ROUTES } from "./desktop-setup-routes.js";
 import { ROUTES as DIAGNOSTICS_ROUTES } from "./diagnostics-routes.js";
 import { ROUTES as DISK_PRESSURE_ROUTES } from "./disk-pressure-routes.js";
 import { ROUTES as DOCUMENT_COMMENT_ROUTES } from "./document-comments-routes.js";
@@ -191,6 +193,7 @@ export const ROUTES: RouteDefinition[] = [
   ...CHANNEL_VERIFICATION_ROUTES,
   ...CHANNEL_AVAILABILITY_ROUTES,
   ...CHANNEL_READINESS_ROUTES,
+  ...CHANNEL_SEND_ROUTES,
   ...BROWSER_ROUTES,
   ...BROWSER_TABS_ROUTES,
   ...BTW_ROUTES,
@@ -218,6 +221,7 @@ export const ROUTES: RouteDefinition[] = [
   ...DEBUG_BASH_ROUTES,
   ...DEBUG_ROUTES,
   ...DEFAULT_PROVIDER_ROUTES,
+  ...DESKTOP_SETUP_ROUTES,
   ...DIAGNOSTICS_ROUTES,
   ...DISK_PRESSURE_ROUTES,
   ...RESOURCE_PRESSURE_ROUTES,

package/src/runtime/routes/log-export-routes.ts

@@ -22,6 +22,7 @@ import { join } from "node:path";
 import { and, desc, eq, gte, lte } from "drizzle-orm";
 import { z } from "zod";
 
+import { overlayWorkspaceMcpForConfigRead } from "../../mcp/workspace-mcp-config.js";
 import { getDb, getLogsDb } from "../../persistence/db-connection.js";
 import {
   llmRequestLogs,
@@ -568,6 +569,7 @@ function readSanitizedConfig(): Record<string, unknown> | undefined {
       }
     }
 
+    overlayWorkspaceMcpForConfigRead(config);
     const mcpServers = asRecord(asRecord(config.mcp)?.servers);
     for (const server of Object.values(mcpServers ?? {})) {
       const transport = asRecord(asRecord(server)?.transport);

package/src/runtime/routes/mcp-auth-routes.ts

@@ -14,8 +14,7 @@
 
 import { z } from "zod";
 
-import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
-import type { McpConfig, McpServerConfig } from "../../config/schemas/mcp.js";
+import type { McpServerConfig } from "../../config/schemas/mcp.js";
 import { estimateToolDefinitionTokens } from "../../context/token-estimator.js";
 import { reloadMcpServers } from "../../daemon/mcp-reload-service.js";
 import { McpClient } from "../../mcp/client.js";
@@ -31,6 +30,10 @@ import {
   deleteMcpOAuthCredentials,
   hasMcpOAuthTokens,
 } from "../../mcp/mcp-oauth-provider.js";
+import {
+  loadWorkspaceMcpConfig,
+  saveWorkspaceMcpConfig,
+} from "../../mcp/workspace-mcp-config.js";
 import { readPluginMcpServers } from "../../plugins/mcp-servers.js";
 import { getMcpToolsByServer } from "../../tools/registry.js";
 import { getLogger } from "../../util/logger.js";
@@ -65,6 +68,18 @@ const McpAddParams = z.object({
 
 const McpRemoveParams = z.object({ name: z.string() });
 
+function persistWorkspaceMcpConfig(config: {
+  servers: Record<string, McpServerConfig>;
+}): void {
+  try {
+    saveWorkspaceMcpConfig(config);
+  } catch (err) {
+    throw new InternalError(
+      err instanceof Error ? err.message : String(err),
+    );
+  }
+}
+
 async function handleMcpAuthStart({
   body,
 }: {
@@ -76,8 +91,7 @@ async function handleMcpAuthStart({
 }> {
   const { serverId } = parseBody(McpServerIdParams, body);
 
-  const raw = loadRawConfig();
-  const servers = (raw.mcp as Partial<McpConfig> | undefined)?.servers ?? {};
+  const servers = loadWorkspaceMcpConfig().servers;
   const serverConfig = servers[serverId];
 
   if (!serverConfig) {
@@ -253,9 +267,7 @@ function detectAuthType(headers: Record<string, string>): "bearer" | "api-key" {
 async function handleMcpList(_args: {
   body?: Record<string, unknown>;
 }): Promise<{ servers: McpServerEntry[] }> {
-  const raw = loadRawConfig();
-  const mcpConfig = raw.mcp as Partial<McpConfig> | undefined;
-  const servers = mcpConfig?.servers ?? {};
+  const servers = loadWorkspaceMcpConfig().servers;
   const configEntries = (
     Object.entries(servers) as [string, McpServerConfig][]
   ).filter(([, config]) => config && typeof config === "object");
@@ -434,18 +446,13 @@ async function handleMcpUpdate({
 }): Promise<{ updated: true }> {
   const { name, headers } = parseBody(McpUpdateParams, body);
 
-  const raw = loadRawConfig();
-  const mcpConfig = raw.mcp as Record<string, unknown> | undefined;
-  const serverMap = mcpConfig?.servers as
-    | Record<string, Record<string, unknown>>
-    | undefined;
+  const servers = loadWorkspaceMcpConfig().servers;
+  const server = servers[name];
 
-  if (!serverMap || !serverMap[name]) {
+  if (!server) {
     throw new NotFoundError(`MCP server "${name}" not found.`);
   }
 
-  const server = serverMap[name];
-
   if (headers !== undefined) {
     const transport = server.transport as Record<string, unknown> | undefined;
     if (
@@ -474,7 +481,7 @@ async function handleMcpUpdate({
     }
   }
 
-  saveRawConfig(raw);
+  persistWorkspaceMcpConfig({ servers });
   triggerReload("internal_mcp_update");
 
   return { updated: true };
@@ -494,7 +501,7 @@ async function handleMcpAdd({
     body,
   );
 
-  let transport: Record<string, unknown>;
+  let transport: McpServerConfig["transport"];
   switch (transportType) {
     case "stdio":
       if (!command) {
@@ -517,27 +524,16 @@ async function handleMcpAdd({
       );
   }
 
-  const raw = loadRawConfig();
-  if (!raw.mcp) {
-    raw.mcp = { servers: {} };
-  }
-  const mcpConfig = raw.mcp as Record<string, unknown>;
-  if (!mcpConfig.servers) {
-    mcpConfig.servers = {};
-  }
-  const serverMap = mcpConfig.servers as Record<string, unknown>;
+  const servers = { ...loadWorkspaceMcpConfig().servers };
 
-  if (serverMap[name]) {
+  if (servers[name]) {
     throw new BadRequestError(
       `MCP server "${name}" already exists. Remove it first with: assistant mcp remove ${name}`,
     );
   }
 
-  serverMap[name] = {
-    transport,
-  };
+  servers[name] = { transport };
 
-  // Store auth headers in credential store, not config
   if (headers && Object.keys(headers).length > 0) {
     const ok = await setMcpHeaders(name, headers);
     if (!ok) {
@@ -547,7 +543,7 @@ async function handleMcpAdd({
     }
   }
 
-  saveRawConfig(raw);
+  persistWorkspaceMcpConfig({ servers });
   triggerReload("internal_mcp_add");
 
   return { added: true };
@@ -564,8 +560,7 @@ async function handleMcpAuthRevoke({
 }): Promise<{ revoked: true }> {
   const { serverId } = parseBody(McpServerIdParams, body);
 
-  const raw = loadRawConfig();
-  const servers = (raw.mcp as Partial<McpConfig> | undefined)?.servers ?? {};
+  const servers = loadWorkspaceMcpConfig().servers;
   const serverConfig = servers[serverId];
 
   if (!serverConfig) {
@@ -602,32 +597,29 @@ async function handleMcpRemove({
 }): Promise<{ removed: true }> {
   const { name } = parseBody(McpRemoveParams, body);
 
-  const raw = loadRawConfig();
-  const mcpConfig = raw.mcp as Record<string, unknown> | undefined;
-  const serverMap = mcpConfig?.servers as Record<string, unknown> | undefined;
+  const servers = { ...loadWorkspaceMcpConfig().servers };
+  const serverConfig = servers[name];
 
-  if (!serverMap || !serverMap[name]) {
+  if (!serverConfig) {
     throw new NotFoundError(`MCP server "${name}" not found.`);
   }
 
-  // Best-effort cleanup of credentials stored for this server
-  const serverConfig = serverMap[name] as Record<string, unknown>;
-  const transport = serverConfig?.transport as
-    | Record<string, unknown>
-    | undefined;
-  if (transport?.type === "sse" || transport?.type === "streamable-http") {
+  if (
+    serverConfig.transport.type === "sse" ||
+    serverConfig.transport.type === "streamable-http"
+  ) {
     try {
       await Promise.all([
         deleteMcpOAuthCredentials(name),
         deleteMcpHeaders(name),
       ]);
     } catch {
-      // Ignore — credentials may not exist
+      // Credentials may not exist.
     }
   }
 
-  delete serverMap[name];
-  saveRawConfig(raw);
+  delete servers[name];
+  persistWorkspaceMcpConfig({ servers });
   triggerReload("internal_mcp_remove");
 
   return { removed: true };

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

@@ -22,8 +22,8 @@ import { PassThrough, Readable } from "node:stream";
 
 import { z } from "zod";
 
-import { getPlatformAssistantId } from "../../config/env.js";
 import { invalidateConfigCache } from "../../config/loader.js";
+import { resolvePlatformAssistantId } from "../../config/platform-identity.js";
 import { getAssistantName } from "../../daemon/identity-helpers.js";
 import { runAsyncSqlite } from "../../persistence/db-async-query.js";
 import {
@@ -236,28 +236,15 @@ interface ExportManifestInputs {
 /**
  * Resolve the `assistant.id` for an export.
  *
- * Mirrors `platform/client.ts`'s precedence: in-memory override (set at
- * daemon startup or by secret-routes) → credential store → daemon-internal
- * fallback. The schema requires `id` to be non-empty, so we fall back to
- * `DAEMON_INTERNAL_ASSISTANT_ID` rather than the empty string.
+ * In-memory identity (validate rehydration or secret-routes) first, then
+ * the vault copy of `platform_assistant_id`. The schema requires `id` to be
+ * non-empty, so we fall back to `DAEMON_INTERNAL_ASSISTANT_ID` rather than
+ * the empty string.
  */
 async function resolveAssistantId(): Promise<string> {
-  const inMemory = getPlatformAssistantId();
-  if (inMemory) {
-    return inMemory;
-  }
-  try {
-    const stored = await getSecureKeyAsync(
-      credentialKey("vellum", "platform_assistant_id"),
-    );
-    if (stored) {
-      return stored;
-    }
-  } catch (err) {
-    log.warn(
-      { err },
-      "Failed to read platform_assistant_id from credential store; falling back to daemon-internal id",
-    );
+  const resolved = await resolvePlatformAssistantId();
+  if (resolved) {
+    return resolved;
   }
   return DAEMON_INTERNAL_ASSISTANT_ID;
 }

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

@@ -39,7 +39,17 @@ import {
 } from "@vellumai/service-contracts/platform-credential";
 import { z } from "zod";
 
+import {
+  setPlatformAssistantId,
+  setPlatformBaseUrl,
+  setPlatformOrganizationId,
+  setPlatformUserId,
+} from "../../config/env.js";
 import { isPlatformRemote } from "../../config/env-registry.js";
+import {
+  resolvePlatformOrganizationId,
+  resolvePlatformUserId,
+} from "../../config/platform-identity.js";
 import {
   registerCallbackRoute,
   resolvePlatformCallbackRegistrationContext,
@@ -289,24 +299,12 @@ async function handlePlatformStatus(
 ): Promise<PlatformStatusResponse> {
   const context = await resolvePlatformCallbackRegistrationContext();
 
-  const [orgIdRaw, userIdRaw, webhookSecretRaw] = await Promise.all([
-    getSecureKeyAsync(
-      credentialKey(
-        CREDENTIAL_KEYS.organizationId.service,
-        CREDENTIAL_KEYS.organizationId.field,
-      ),
-    ),
-    getSecureKeyAsync(
-      credentialKey(
-        CREDENTIAL_KEYS.userId.service,
-        CREDENTIAL_KEYS.userId.field,
-      ),
-    ),
+  const [organizationId, userId, webhookSecretRaw] = await Promise.all([
+    resolvePlatformOrganizationId(),
+    resolvePlatformUserId(),
     getSecureKeyAsync(credentialKey("vellum", "webhook_secret")),
   ]);
 
-  const organizationId = orgIdRaw?.trim() ?? "";
-  const userId = userIdRaw?.trim() ?? "";
   const hasWebhookSecret = !!webhookSecretRaw;
 
   return {
@@ -467,6 +465,11 @@ async function handlePlatformDisconnect(
     );
   }
 
+  setPlatformBaseUrl(undefined);
+  setPlatformAssistantId(undefined);
+  setPlatformOrganizationId(undefined);
+  setPlatformUserId(undefined);
+
   // Notify connected clients
   broadcastMessage({ type: "platform_disconnected" });
 

package/src/runtime/services/__tests__/conversation-serializer.test.ts

@@ -159,3 +159,31 @@ describe("serializeConversationSummary · enabledPlugins", () => {
     expect("enabledPlugins" in summary).toBe(false);
   });
 });
+
+describe("serializeConversationSummary · title keys", () => {
+  test("resolves a stored title key for the locale", () => {
+    const summary = serializeConversationSummary({
+      conversation: makeConversationRow({
+        title: "conversation.title.generating",
+      }),
+      displayMeta: { displayOrder: null, isPinned: false, groupId: null },
+      parentCache: new Map(),
+      isProcessing: false,
+      locale: "es",
+    });
+    expect(summary.title).toBe("Generando título...");
+    expect("titleState" in summary).toBe(false);
+  });
+
+  test("passes a stored display string through", () => {
+    const summary = serialize(
+      makeConversationRow({ title: "Untitled Conversation" }),
+    );
+    expect(summary.title).toBe("Untitled Conversation");
+  });
+
+  test("passes a custom title through", () => {
+    const summary = serialize(makeConversationRow({ title: "Weekly planning" }));
+    expect(summary.title).toBe("Weekly planning");
+  });
+});

package/src/runtime/services/conversation-serializer.ts

@@ -8,6 +8,10 @@
 
 import { parseChannelId } from "../../channels/types.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
+import {
+  resolveConversationTitle,
+  type SupportedLocale,
+} from "../../i18n/index.js";
 import { buildChannelBindingMetadata } from "../../messaging/channel-binding-metadata.js";
 import {
   type AttentionState,
@@ -78,6 +82,7 @@ interface ForkLineage {
 function buildForkLineage(
   conversation: ConversationRow,
   parentCache: Map<string, ConversationRow | null>,
+  locale?: SupportedLocale,
 ): ForkLineage {
   const parentConversationId = conversation.forkParentConversationId;
   const parentMessageId = conversation.forkParentMessageId;
@@ -101,7 +106,7 @@ function buildForkLineage(
     forkParent: {
       conversationId: parentConversationId,
       messageId: parentMessageId,
-      title: parentConversation.title ?? "Untitled",
+      title: resolveConversationTitle(parentConversation.title, locale),
     },
   };
 }
@@ -178,6 +183,11 @@ export function serializeConversationSummary(params: {
    * with no daemon-store coupling.
    */
   isProcessing: boolean;
+  /**
+   * Locale used to resolve stored title keys. Omitted locale is English
+   * inside {@link resolveConversationTitle}.
+   */
+  locale?: SupportedLocale;
 }) {
   const {
     conversation,
@@ -186,14 +196,15 @@ export function serializeConversationSummary(params: {
     displayMeta,
     parentCache,
     isProcessing,
+    locale,
   } = params;
   const originChannel = parseChannelId(conversation.originChannel);
   const assistantAttention = buildAssistantAttention(attentionState);
-  const forkLineage = buildForkLineage(conversation, parentCache);
+  const forkLineage = buildForkLineage(conversation, parentCache, locale);
 
   return {
     id: conversation.id,
-    title: conversation.title ?? "Untitled",
+    title: resolveConversationTitle(conversation.title, locale),
     createdAt: conversation.createdAt,
     updatedAt: conversation.updatedAt,
     lastMessageAt: conversation.lastMessageAt,
@@ -253,6 +264,7 @@ export function serializeConversationSummary(params: {
  */
 export function buildConversationDetailResponse(
   conversationId: string,
+  locale?: SupportedLocale,
 ): { conversation: ReturnType<typeof serializeConversationSummary> } | null {
   const conversation = getConversation(conversationId);
   if (!conversation || conversation.conversationType === "private") {
@@ -274,6 +286,7 @@ export function buildConversationDetailResponse(
       // Checks in-memory flag first (hot path), falls back to the
       // persisted `processing_started_at` column for cold conversations.
       isProcessing: isConversationProcessing(conversation.id),
+      locale,
     }),
   };
 }

package/src/runtime/sync/resource-sync-events.ts

@@ -4,6 +4,7 @@ import {
   conversationMetadataSyncTag,
   SYNC_TAGS,
 } from "../../daemon/message-types/sync.js";
+import { resolveConversationTitle } from "../../i18n/index.js";
 import { syncAvatarToPlatform } from "../../platform/sync-avatar.js";
 import { getAvatarImagePath } from "../../util/platform.js";
 import { broadcastMessage } from "../assistant-event-hub.js";
@@ -257,7 +258,7 @@ export function publishConversationTitleChanged(
     {
       type: "conversation_title_updated",
       conversationId,
-      title,
+      title: resolveConversationTitle(title),
     },
     conversationId,
   );

package/src/schedule/worker.ts

@@ -195,7 +195,7 @@ async function main(): Promise<void> {
   //
   // Bounded by MCP_STARTUP_GRACE_MS: unreachable servers must not hold the
   // schedules that do not use them. The connect runs on past the deadline.
-  const mcpStartup = startConfiguredMcpServers(getConfig().mcp);
+  const mcpStartup = startConfiguredMcpServers();
   await Promise.race([
     mcpStartup,
     // Unref'd so a connect that beats the deadline leaves nothing pending.