@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/i18n/locales.ts

@@ -1,93 +0,0 @@
-/**
- * Locales the daemon can resolve user-facing copy into.
- *
- * Keep this set aligned with `clients/web/src/i18n/supported-locales.ts`.
- * A locale that exists only here cannot be requested by the web app; a
- * locale that exists only there cannot be resolved for CLI or HTTP
- * consumers that go through this module.
- */
-
-export const DEFAULT_LOCALE = "en";
-
-export const SUPPORTED_LOCALES = ["en", "es", "ru", "zh", "zh-TW"] as const;
-
-export type SupportedLocale = (typeof SUPPORTED_LOCALES)[number];
-
-export function isSupportedLocale(value: unknown): value is SupportedLocale {
-  return (
-    typeof value === "string" &&
-    (SUPPORTED_LOCALES as readonly string[]).includes(value)
-  );
-}
-
-/**
- * Pick the best shipped locale for an ordered list of preferred BCP 47 tags.
- *
- * Full tag first, then the primary language subtag, so `es-MX` resolves to
- * `es`. `zh-Hant` / `zh-HK` / `zh-MO` map to `zh-TW`.
- */
-export function negotiateLocale(preferred: readonly string[]): SupportedLocale {
-  for (const tag of preferred) {
-    const normalized = tag.trim();
-    if (normalized === "") {
-      continue;
-    }
-    const exact = SUPPORTED_LOCALES.find(
-      (locale) => locale.toLowerCase() === normalized.toLowerCase(),
-    );
-    if (exact) {
-      return exact;
-    }
-    const lower = normalized.toLowerCase();
-    if (
-      lower === "zh-hant" ||
-      lower.startsWith("zh-hant-") ||
-      lower === "zh-hk" ||
-      lower === "zh-mo"
-    ) {
-      return "zh-TW";
-    }
-    const base = normalized.split("-")[0]?.toLowerCase();
-    const baseMatched = SUPPORTED_LOCALES.find(
-      (locale) => locale.toLowerCase() === base,
-    );
-    if (baseMatched) {
-      return baseMatched;
-    }
-  }
-  return DEFAULT_LOCALE;
-}
-
-/**
- * Parse an `Accept-Language` header into preference order and negotiate.
- *
- * Quality values are honored; the header is a hint, not a required input.
- * Missing or empty headers resolve to {@link DEFAULT_LOCALE}.
- */
-export function localeFromAcceptLanguage(
-  header: string | null | undefined,
-): SupportedLocale {
-  if (header == null || header.trim() === "") {
-    return DEFAULT_LOCALE;
-  }
-  const tags = header
-    .split(",")
-    .map((part) => {
-      const [tag, ...params] = part.trim().split(";");
-      let quality = 1;
-      for (const param of params) {
-        const [name, value] = param.trim().split("=");
-        if (name === "q" && value !== undefined) {
-          const parsed = Number.parseFloat(value);
-          if (Number.isFinite(parsed)) {
-            quality = parsed;
-          }
-        }
-      }
-      return { tag: tag?.trim() ?? "", quality };
-    })
-    .filter((entry) => entry.tag.length > 0)
-    .sort((a, b) => b.quality - a.quality)
-    .map((entry) => entry.tag);
-  return negotiateLocale(tags);
-}

package/src/i18n/messages.ts

@@ -1,61 +0,0 @@
-/**
- * Daemon message catalog.
- *
- * Keys are the stable identity of a hardcoded constant. English is the
- * source language. Add a key here, then add the same key to every locale
- * catalog. A key present in a translated catalog but missing from English
- * is a test failure.
- *
- * Persist the key when a column holds a system constant. Never persist a
- * translated string, and never treat a stored display string as a key:
- * a user title may be in any language.
- */
-
-import {
-  DEFAULT_LOCALE,
-  type SupportedLocale,
-} from "./locales.js";
-
-export const MESSAGE_KEYS = {
-  CONVERSATION_TITLE_GENERATING: "conversation.title.generating",
-  CONVERSATION_TITLE_UNTITLED: "conversation.title.untitled",
-} as const;
-
-export type MessageKey = (typeof MESSAGE_KEYS)[keyof typeof MESSAGE_KEYS];
-
-export const MESSAGE_CATALOGS: Record<
-  SupportedLocale,
-  Record<MessageKey, string>
-> = {
-  en: {
-    "conversation.title.generating": "Generating title...",
-    "conversation.title.untitled": "Untitled Conversation",
-  },
-  es: {
-    "conversation.title.generating": "Generando título...",
-    "conversation.title.untitled": "Sin título",
-  },
-  ru: {
-    "conversation.title.generating": "Создание названия...",
-    "conversation.title.untitled": "Без названия",
-  },
-  zh: {
-    "conversation.title.generating": "标题生成中...",
-    "conversation.title.untitled": "无标题",
-  },
-  "zh-TW": {
-    "conversation.title.generating": "標題產生中...",
-    "conversation.title.untitled": "未命名",
-  },
-};
-
-export function t(
-  key: MessageKey,
-  locale: SupportedLocale = DEFAULT_LOCALE,
-): string {
-  return MESSAGE_CATALOGS[locale][key] ?? MESSAGE_CATALOGS[DEFAULT_LOCALE][key];
-}
-
-export function isMessageKey(value: string): value is MessageKey {
-  return (Object.values(MESSAGE_KEYS) as string[]).includes(value);
-}

package/src/i18n/title.ts

@@ -1,25 +0,0 @@
-/**
- * Resolve a conversation title for a locale.
- *
- * A stored message key (or an empty title) is a hardcoded constant and
- * resolves through the catalog. Any other stored string is user or model
- * copy and passes through, including English placeholders written before
- * keys were persisted.
- */
-
-import { DEFAULT_LOCALE, type SupportedLocale } from "./locales.js";
-import { isMessageKey, MESSAGE_KEYS, t } from "./messages.js";
-
-export function resolveConversationTitle(
-  title: string | null | undefined,
-  locale: SupportedLocale = DEFAULT_LOCALE,
-): string {
-  const trimmed = title?.trim() ?? "";
-  if (trimmed === "") {
-    return t(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED, locale);
-  }
-  if (isMessageKey(trimmed)) {
-    return t(trimmed, locale);
-  }
-  return trimmed;
-}

package/src/mcp/__tests__/workspace-mcp-config.test.ts

@@ -1,135 +0,0 @@
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import { AGENT_PLUGINS_MCP_SCHEMA_URL } from "../spec-schema.js";
-import {
-  loadWorkspaceMcpConfig,
-  overlayWorkspaceMcpForConfigRead,
-  readWorkspaceMcpFile,
-  saveWorkspaceMcpConfig,
-} from "../workspace-mcp-config.js";
-
-function mcpPath(): string {
-  return join(process.env.VELLUM_WORKSPACE_DIR!, "mcp.json");
-}
-
-describe("workspace mcp.json", () => {
-  beforeEach(() => {
-    mkdirSync(process.env.VELLUM_WORKSPACE_DIR!, { recursive: true });
-    rmSync(mcpPath(), { force: true });
-  });
-
-  test("missing file is an empty server map", () => {
-    expect(loadWorkspaceMcpConfig()).toEqual({ servers: {} });
-    expect(readWorkspaceMcpFile().fileState).toBe("missing");
-  });
-
-  test("round-trips a spec document without wrapping transport", () => {
-    saveWorkspaceMcpConfig({
-      servers: {
-        remote: {
-          transport: {
-            type: "streamable-http",
-            url: "https://example.com/mcp",
-          },
-        },
-        local: {
-          transport: {
-            type: "stdio",
-            command: "npx",
-            args: ["-y", "srv"],
-          },
-        },
-      },
-    });
-
-    expect(JSON.parse(readFileSync(mcpPath(), "utf8"))).toEqual({
-      $schema: AGENT_PLUGINS_MCP_SCHEMA_URL,
-      mcpServers: {
-        remote: {
-          type: "streamable-http",
-          url: "https://example.com/mcp",
-        },
-        local: {
-          type: "stdio",
-          command: "npx",
-          args: ["-y", "srv"],
-        },
-      },
-    });
-    expect(loadWorkspaceMcpConfig()).toEqual({
-      servers: {
-        remote: {
-          transport: {
-            type: "streamable-http",
-            url: "https://example.com/mcp",
-          },
-        },
-        local: {
-          transport: {
-            type: "stdio",
-            command: "npx",
-            args: ["-y", "srv"],
-          },
-        },
-      },
-    });
-  });
-
-  test("does not persist transport headers", () => {
-    saveWorkspaceMcpConfig({
-      servers: {
-        remote: {
-          transport: {
-            type: "streamable-http",
-            url: "https://example.com/mcp",
-            headers: { Authorization: "Bearer secret" },
-          },
-        },
-      },
-    });
-
-    const onDisk = readFileSync(mcpPath(), "utf8");
-    expect(onDisk).not.toContain("secret");
-    expect(loadWorkspaceMcpConfig().servers.remote?.transport).toEqual({
-      type: "streamable-http",
-      url: "https://example.com/mcp",
-    });
-  });
-
-  test("invalid file does not throw on read and refuses a later write", () => {
-    mkdirSync(process.env.VELLUM_WORKSPACE_DIR!, { recursive: true });
-    writeFileSync(mcpPath(), "{ not json");
-
-    expect(loadWorkspaceMcpConfig()).toEqual({ servers: {} });
-    expect(readWorkspaceMcpFile().fileState).toBe("invalid");
-    expect(() => saveWorkspaceMcpConfig({ servers: {} })).toThrow(/invalid JSON/);
-  });
-
-  test("overlay projects transport-only servers for config reads", () => {
-    saveWorkspaceMcpConfig({
-      servers: {
-        remote: {
-          transport: {
-            type: "streamable-http",
-            url: "https://example.com/mcp",
-          },
-        },
-      },
-    });
-
-    const config: Record<string, unknown> = { llm: { activeProfile: "balanced" } };
-    overlayWorkspaceMcpForConfigRead(config);
-    expect(config.mcp).toEqual({
-      servers: {
-        remote: {
-          transport: {
-            type: "streamable-http",
-            url: "https://example.com/mcp",
-          },
-        },
-      },
-    });
-  });
-});

package/src/mcp/spec-schema.ts

@@ -1,111 +0,0 @@
-/**
- * Agent Plugins 1.0.0 `mcp.json` wire schema and projections onto the
- * assistant's in-memory `McpTransport` union.
- *
- * Workspace `/workspace/mcp.json` and each plugin's root `mcp.json` share
- * this document shape. Origin (`workspace` vs `plugin`) is resolved from
- * which file was read, never from a field in the file.
- */
-
-import { z } from "zod";
-
-import type { McpTransport } from "../config/schemas/mcp.js";
-
-/** Canonical `$schema` value for an Agent Plugins 1.0.0 MCP document. */
-export const AGENT_PLUGINS_MCP_SCHEMA_URL =
-  "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
-
-const SpecStdioServerSchema = z.object({
-  type: z.literal("stdio"),
-  command: z.string().min(1),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  cwd: z.string().optional(),
-});
-
-/**
- * Remote MCP entry. Agent Plugins 1.0.0 requires `type` and names no
- * default. MCP's current remote transport is Streamable HTTP, so this
- * host fills omitted `type` and the Claude-style `http` alias as
- * `streamable-http`. `sse` stays explicit.
- */
-const SpecHttpServerSchema = z.object({
-  type: z
-    .union([
-      z.literal("streamable-http"),
-      z.literal("sse"),
-      z.literal("http").transform(() => "streamable-http" as const),
-    ])
-    .default("streamable-http"),
-  url: z.string().min(1),
-  headers: z.record(z.string(), z.string()).optional(),
-});
-
-export const SpecMcpServerSchema = z.union([
-  SpecStdioServerSchema,
-  SpecHttpServerSchema,
-]);
-
-export const SpecMcpDocumentSchema = z.object({
-  $schema: z.string().optional(),
-  mcpServers: z.record(z.string(), z.unknown()),
-});
-
-export type SpecMcpServer = z.infer<typeof SpecMcpServerSchema>;
-export type SpecMcpDocument = z.infer<typeof SpecMcpDocumentSchema>;
-
-/**
- * Project one spec-shaped entry onto the assistant's transport union. The
- * two vocabularies already agree on type names and required fields, so this
- * is a field copy plus an optional expander for plugin path variables.
- */
-export function projectSpecServerToTransport(
-  entry: SpecMcpServer,
-  expand?: (value: string) => string,
-): McpTransport {
-  if (entry.type === "stdio") {
-    const map = expand ?? ((value: string) => value);
-    return {
-      type: "stdio",
-      command: entry.command,
-      args: (entry.args ?? []).map(map),
-      ...(entry.env && {
-        env: Object.fromEntries(
-          Object.entries(entry.env).map(([key, value]) => [key, map(value)]),
-        ),
-      }),
-    };
-  }
-  return {
-    type: entry.type,
-    url: entry.url,
-    ...(entry.headers && { headers: entry.headers }),
-  };
-}
-
-/**
- * Project an in-memory transport onto a spec server entry. Headers are
- * omitted: workspace secrets live in the credential store, and a write
- * must not copy them into `mcp.json`.
- */
-export function projectTransportToSpecServer(
-  transport: McpTransport,
-): Record<string, unknown> {
-  if (transport.type === "stdio") {
-    const entry: Record<string, unknown> = {
-      type: "stdio",
-      command: transport.command,
-    };
-    if (transport.args && transport.args.length > 0) {
-      entry.args = transport.args;
-    }
-    if (transport.env) {
-      entry.env = transport.env;
-    }
-    return entry;
-  }
-  return {
-    type: transport.type,
-    url: transport.url,
-  };
-}

package/src/mcp/workspace-mcp-config.ts

@@ -1,188 +0,0 @@
-/**
- * User-owned MCP servers in `$VELLUM_WORKSPACE_DIR/mcp.json`.
- *
- * The file is an Agent Plugins 1.0.0 document (`$schema` + `mcpServers`).
- * This module is the only reader and writer of that file. Presence of a
- * server starts it. Headers are never persisted here.
- */
-
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname } from "node:path";
-
-import type { McpConfig, McpServerConfig } from "../config/schemas/mcp.js";
-import { McpConfigSchema } from "../config/schemas/mcp.js";
-import { getLogger } from "../util/logger.js";
-import { getWorkspaceMcpConfigPath } from "../util/platform.js";
-import {
-  AGENT_PLUGINS_MCP_SCHEMA_URL,
-  projectSpecServerToTransport,
-  projectTransportToSpecServer,
-  SpecMcpDocumentSchema,
-  SpecMcpServerSchema,
-} from "./spec-schema.js";
-
-const log = getLogger("workspace-mcp-config");
-
-export type WorkspaceMcpFileState = "missing" | "ok" | "invalid";
-
-export interface WorkspaceMcpLoadResult {
-  readonly config: McpConfig;
-  readonly issues: readonly string[];
-  readonly fileState: WorkspaceMcpFileState;
-}
-
-/**
- * Read `/workspace/mcp.json` and project it onto the in-memory MCP config.
- *
- * A missing file is an empty server map. An invalid file disables the
- * workspace half only (plugin servers still load) and is reported so a
- * write can refuse to overwrite it.
- */
-export function readWorkspaceMcpFile(
-  path: string = getWorkspaceMcpConfigPath(),
-): WorkspaceMcpLoadResult {
-  if (!existsSync(path)) {
-    return {
-      config: McpConfigSchema.parse({}),
-      issues: [],
-      fileState: "missing",
-    };
-  }
-
-  let raw: string;
-  try {
-    raw = readFileSync(path, "utf8");
-  } catch (err) {
-    const message = `mcp.json unreadable: ${err instanceof Error ? err.message : String(err)}`;
-    return {
-      config: McpConfigSchema.parse({}),
-      issues: [message],
-      fileState: "invalid",
-    };
-  }
-
-  let json: unknown;
-  try {
-    json = JSON.parse(raw);
-  } catch (err) {
-    const message = `mcp.json invalid JSON: ${err instanceof Error ? err.message : String(err)}`;
-    return {
-      config: McpConfigSchema.parse({}),
-      issues: [message],
-      fileState: "invalid",
-    };
-  }
-
-  const document = SpecMcpDocumentSchema.safeParse(json);
-  if (!document.success) {
-    return {
-      config: McpConfigSchema.parse({}),
-      issues: ['mcp.json is missing a valid "mcpServers" object'],
-      fileState: "invalid",
-    };
-  }
-
-  const servers: Record<string, McpServerConfig> = {};
-  const issues: string[] = [];
-
-  for (const [serverKey, rawEntry] of Object.entries(document.data.mcpServers)) {
-    if (serverKey.trim().length === 0) {
-      issues.push("server key must be a non-empty string; skipping");
-      continue;
-    }
-
-    const entry = SpecMcpServerSchema.safeParse(rawEntry);
-    if (!entry.success) {
-      issues.push(
-        `invalid server entry "${serverKey}": ${entry.error.issues
-          .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
-          .join("; ")}`,
-      );
-      continue;
-    }
-
-    if (entry.data.type === "stdio" && entry.data.cwd) {
-      issues.push(
-        `"${serverKey}": "cwd" is not supported by this host and was ignored; the server runs in the assistant's working directory`,
-      );
-    }
-
-    servers[serverKey] = {
-      transport: projectSpecServerToTransport(entry.data),
-    };
-  }
-
-  return {
-    config: { servers },
-    issues,
-    fileState: "ok",
-  };
-}
-
-/** Load the workspace MCP config, logging any declaration problems. */
-export function loadWorkspaceMcpConfig(): McpConfig {
-  const result = readWorkspaceMcpFile();
-  for (const issue of result.issues) {
-    log.warn(issue);
-  }
-  return result.config;
-}
-
-/**
- * Refuse a write when `mcp.json` exists but is not a usable document, so a
- * later add/remove cannot clobber a hand-edit the user still means to fix.
- */
-export function assertWorkspaceMcpWritable(): void {
-  const result = readWorkspaceMcpFile();
-  if (result.fileState === "invalid") {
-    throw new Error(result.issues[0] ?? "mcp.json is not a valid document");
-  }
-}
-
-/** Persist the in-memory workspace MCP config as a spec-pure document. */
-export function saveWorkspaceMcpConfig(config: McpConfig): void {
-  assertWorkspaceMcpWritable();
-  const path = getWorkspaceMcpConfigPath();
-  const mcpServers: Record<string, unknown> = {};
-  for (const [id, server] of Object.entries(config.servers)) {
-    mcpServers[id] = projectTransportToSpecServer(server.transport);
-  }
-
-  const document = {
-    $schema: AGENT_PLUGINS_MCP_SCHEMA_URL,
-    mcpServers,
-  };
-
-  mkdirSync(dirname(path), { recursive: true });
-  const tmpPath = `${path}.tmp`;
-  writeFileSync(tmpPath, JSON.stringify(document, null, 2) + "\n");
-  renameSync(tmpPath, path);
-}
-
-/**
- * Replace `config.mcp` on a settings/export payload with the projected
- * workspace servers (transport only, headers stripped). Old clients that
- * still read `mcp.servers` from `/v1/config` keep seeing the same shape.
- */
-export function overlayWorkspaceMcpForConfigRead(config: unknown): void {
-  if (config === null || typeof config !== "object" || Array.isArray(config)) {
-    return;
-  }
-  const root = config as Record<string, unknown>;
-  const { servers } = loadWorkspaceMcpConfig();
-  const projected: Record<string, unknown> = {};
-  for (const [id, server] of Object.entries(servers)) {
-    const { headers: _headers, ...safeTransport } = server.transport as Record<
-      string,
-      unknown
-    >;
-    projected[id] = { transport: safeTransport };
-  }
-  root.mcp = { servers: projected };
-}