@vellumai/assistant 0.10.7-dev.202607101252.74ea83d → 0.10.7-dev.202607101343.e727d4c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.7-dev.202607101252.74ea83d",
+  "version": "0.10.7-dev.202607101343.e727d4c",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/cli/lib/__tests__/install-from-github.test.ts

@@ -78,14 +78,14 @@ function makeContentsFetch(opts: {
     const prefix = apiPath ? `${apiPath}/` : "";
     const direct = new Map<string, boolean>();
     for (const key of Object.keys(tree)) {
-      if (!key.startsWith(prefix)) continue;
+      if (!key.startsWith(prefix)) {continue;}
       const remainder = key.slice(prefix.length);
-      if (!remainder) continue;
+      if (!remainder) {continue;}
       const seg = remainder.split("/")[0]!;
       const isDir = remainder.includes("/") || tree[`${prefix}${seg}`] === null;
       direct.set(seg, (direct.get(seg) ?? false) || isDir);
     }
-    if (direct.size === 0) return null;
+    if (direct.size === 0) {return null;}
     return Array.from(direct.entries()).map(([name, isDir]) => {
       const path = `${prefix}${name}`;
       return isDir
@@ -157,7 +157,7 @@ function fakeGitRunner(opts: {
     opts.calls?.push([...args]);
     switch (args[0]) {
       case "fetch": {
-        if (opts.fetchError) throw opts.fetchError;
+        if (opts.fetchError) {throw opts.fetchError;}
         mkdirSync(join(cwd, ".git"), { recursive: true });
         writeFileSync(join(cwd, ".git", "config"), "[core]\n");
         for (const [rel, content] of Object.entries(opts.tree)) {
@@ -1097,6 +1097,38 @@ describe("installPlugin — direct (untrusted) install", () => {
     ).rejects.toBeInstanceOf(PluginSourceUnavailableError);
     expect(readdirSync(pluginsDir)).toEqual([]);
   });
+
+  test("synthesizes a minimal package.json when the upstream repo ships none", async () => {
+    // GIVEN a plugin tree with no package.json at all
+    const fetch = makeContentsFetch({ tree: {} });
+    const runGit = fakeGitRunner({
+      tree: { "hooks/init.ts": "//", "README.md": "# bare" },
+      commit: "f".repeat(40),
+    });
+
+    // WHEN we install directly
+    await installPlugin(
+      {
+        name: "bare-plugin",
+        directSource: {
+          owner: "owner",
+          repo: "bare",
+          rootPath: "",
+          ref: "HEAD",
+        },
+      },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    // THEN a minimal package.json is synthesized with the install name and
+    // the default plugin-api peer dependency range
+    const pkgPath = join(pluginsDir, "bare-plugin", "package.json");
+    expect(existsSync(pkgPath)).toBe(true);
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    expect(pkg.name).toBe("bare-plugin");
+    expect(pkg.version).toBe("0.0.0");
+    expect(pkg.peerDependencies["@vellumai/plugin-api"]).toBeDefined();
+  });
 });
 
 describe("sanitizePluginName", () => {

package/src/cli/lib/install-from-github.ts

@@ -714,10 +714,23 @@ export async function materializePluginTree(
   // An external clone is often a foreign-ecosystem plugin (e.g. a Claude Code
   // plugin) that the Vellum loader can't run as-is. When we curate an adapter
   // stub for it, overlay the stub and run its transform so the materialized
-  // tree is a valid Vellum plugin. Raw clones (no stub) are left untouched.
+  // tree is a valid Vellum plugin. Raw clones (no stub) are left untouched,
+  // except for a minimal package.json synthesis when the upstream repo shipped
+  // none — the Vellum loader hard-requires one and would silently skip the
+  // plugin without it. The synthesis runs only for direct installs
+  // (stubRef === null); the upgrade path re-materializes baselines through
+  // this function with a non-null stubRef, and synthesizing a package.json
+  // not present at install time would corrupt the fingerprint comparison.
   if (cloned.fileCount > 0 && opts.stubRef !== null) {
     await applyAdapterStub(opts.name, opts.stubRef, opts.destDir, deps);
   }
+  if (
+    cloned.fileCount > 0 &&
+    opts.stubRef === null &&
+    !existsSync(join(opts.destDir, "package.json"))
+  ) {
+    synthesizeMinimalPackageJson(opts.name, opts.destDir);
+  }
   return cloned;
 }
 
@@ -974,6 +987,34 @@ function normalizeInstalledManifest(
   writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
 }
 
+/**
+ * Write a minimal Vellum-compatible `package.json` into a staged plugin that
+ * shipped no manifest of its own. The Vellum external plugin loader
+ * (`buildPluginFromDir`) hard-requires a `package.json` validated against
+ * `PluginPackageJsonSchema` and silently skips the plugin when it's missing.
+ *
+ * The synthesized manifest carries the install name and the default
+ * `@vellumai/plugin-api` peer dependency range. No foreign-ecosystem manifest
+ * data is read — the install name is the only identity we trust for an
+ * untrusted direct install.
+ */
+function synthesizeMinimalPackageJson(
+  name: string,
+  stagingDir: string,
+): void {
+  const manifestPath = join(stagingDir, "package.json");
+
+  const manifest: PackageManifest = {
+    name,
+    version: "0.0.0",
+    peerDependencies: {
+      "@vellumai/plugin-api": PLUGIN_API_PEER_RANGE,
+    },
+  };
+
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+
 /**
  * Resolve the absolute path of the adapter script named by the (overlaid stub)
  * `package.json`'s `scripts.postinstall`, or `null` when there is no stub

package/src/plugin-api/index.ts

@@ -235,3 +235,12 @@ export {
   syncMessageToDisk,
   updateMessageMetadata,
 } from "../persistence/conversation-plugin-facade.js";
+// Synthesize text to speech through the assistant's globally configured TTS
+// provider (ElevenLabs, Fish Audio, etc.). Plugins that need voice output —
+// e.g. a meeting bot speaking into a live call — use this instead of managing
+// TTS credentials and provider config themselves. Returns a Buffer + MIME type.
+// Text is sanitized internally (markdown/URLs/emoji stripped) so callers can
+// pass raw model output directly.
+export type { SynthesizeTextOptions } from "../tts/synthesize-text.js";
+export { synthesizeText, TtsSynthesisError } from "../tts/synthesize-text.js";
+export type { TtsSynthesisResult } from "../tts/types.js";

package/src/tts/synthesize-text.ts

@@ -3,11 +3,13 @@
  *
  * Resolves the globally configured provider via {@link resolveTtsConfig},
  * looks up the provider adapter in the registry, and delegates synthesis.
- * Callers supply the pre-sanitized text and a use-case discriminator;
- * provider selection is always global — per-use-case policy only gates
+ * Callers can pass raw text (including markdown, URLs, emoji); it is sanitized
+ * internally via {@link sanitizeForTts} before being sent to the provider.
+ * Provider selection is always global — per-use-case policy only gates
  * capabilities (e.g. format checks), never overrides the chosen provider.
  */
 
+import { sanitizeForTts } from "../calls/tts-text-sanitizer.js";
 import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 import { getTtsProvider } from "./provider-catalog.js";
@@ -21,7 +23,7 @@ const log = getLogger("tts:synthesize");
 // ---------------------------------------------------------------------------
 
 export interface SynthesizeTextOptions {
-  /** Pre-sanitized text to speak. */
+  /** Text to speak. Sanitized internally — callers can pass raw model output. */
   text: string;
 
   /** Product surface requesting synthesis. */
@@ -72,6 +74,14 @@ export async function synthesizeText(
   const config = getConfig();
   const { provider: providerId } = resolveTtsConfig(config);
 
+  const sanitized = sanitizeForTts(options.text).trim();
+  if (!sanitized) {
+    throw new TtsSynthesisError(
+      "TTS_SYNTHESIS_FAILED",
+      "Text is empty after sanitization (markdown/URLs/emoji stripped).",
+    );
+  }
+
   let provider;
   try {
     provider = getTtsProvider(providerId);
@@ -93,14 +103,14 @@ export async function synthesizeText(
 
   try {
     return await provider.synthesize({
-      text: options.text,
+      text: sanitized,
       useCase: options.useCase,
       voiceId: options.voiceId,
       signal: options.signal,
     });
   } catch (err) {
     // Re-throw TtsSynthesisError as-is (e.g. from inner adapter errors).
-    if (err instanceof TtsSynthesisError) throw err;
+    if (err instanceof TtsSynthesisError) {throw err;}
 
     throw new TtsSynthesisError(
       "TTS_SYNTHESIS_FAILED",