@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/runtime/routes/__tests__/inference-provider-connection-routes.test.ts

@@ -6,7 +6,7 @@
  *   GET    /v1/inference/provider-connections/:name    — single, 404
  *   POST   /v1/inference/provider-connections          — create happy paths + 409 + 400 cases
  *   PATCH  /v1/inference/provider-connections/:name    — update auth, 404
- *   DELETE /v1/inference/provider-connections/:name    — happy path, 409 with profile ref, 409 with call-site ref
+ *   DELETE /v1/inference/provider-connections/:name    — happy path, 409 with profile ref, llm.defaultProvider guard
  *   Auth   — 401 (missing key) and 403 (insufficient scope) via route-policy assertions
  */
 
@@ -32,13 +32,17 @@ await initializeDb();
 
 function findHandler(operationId: string): RouteDefinition["handler"] {
   const route = ROUTES.find((r) => r.operationId === operationId);
-  if (!route) throw new Error(`Route ${operationId} not found`);
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
   return route.handler;
 }
 
 function findRoute(operationId: string): RouteDefinition {
   const route = ROUTES.find((r) => r.operationId === operationId);
-  if (!route) throw new Error(`Route ${operationId} not found`);
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
   return route;
 }
 
@@ -225,6 +229,97 @@ describe("POST inference/provider-connections (create)", () => {
     expect(result.auth).toEqual({ type: "none" });
   });
 
+  test("derives api_key auth from provider + credential when auth is omitted", async () => {
+    const result = (await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "derived-anthropic",
+          provider: "anthropic",
+          credential: "vault/anthropic/key",
+        },
+      },
+    )) as { auth: object };
+    expect(result.auth).toEqual({
+      type: "api_key",
+      credential: "vault/anthropic/key",
+    });
+  });
+
+  test("derives none auth for keyless providers when auth is omitted", async () => {
+    const result = (await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: { name: "derived-ollama", provider: "ollama" },
+      },
+    )) as { auth: object };
+    expect(result.auth).toEqual({ type: "none" });
+  });
+
+  test("derives platform auth for the vellum provider when auth is omitted", async () => {
+    const result = (await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: { name: "derived-vellum", provider: "vellum" },
+      },
+    )) as { auth: object };
+    expect(result.auth).toEqual({ type: "platform" });
+  });
+
+  test("derives none auth for openai-compatible without a credential", async () => {
+    const result = (await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "derived-local-llm",
+          provider: "openai-compatible",
+          base_url: "http://localhost:1234/v1",
+          models: [{ id: "my-model" }],
+        },
+      },
+    )) as { auth: object };
+    expect(result.auth).toEqual({ type: "none" });
+  });
+
+  test("derives api_key auth for openai-compatible with a credential", async () => {
+    const result = (await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "derived-hosted-llm",
+          provider: "openai-compatible",
+          credential: "credential/hosted/key",
+          base_url: "https://api.example.com/v1",
+          models: [{ id: "my-model" }],
+        },
+      },
+    )) as { auth: object };
+    expect(result.auth).toEqual({
+      type: "api_key",
+      credential: "credential/hosted/key",
+    });
+  });
+
+  test("throws 400 when auth is omitted and a keyed provider has no credential", async () => {
+    await expect(
+      call(findHandler("inference_provider_connections_create"), {
+        body: { name: "derived-no-cred", provider: "anthropic" },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
+  test("throws 400 when the derived credential is not a non-empty string", async () => {
+    await expect(
+      call(findHandler("inference_provider_connections_create"), {
+        body: {
+          name: "derived-bad-cred",
+          provider: "anthropic",
+          credential: "",
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
   test("throws 409 when connection name already exists", async () => {
     seedConnection({
       name: "dup-name",
@@ -332,6 +427,59 @@ describe("PATCH inference/provider-connections/:name (update)", () => {
       }),
     ).rejects.toBeInstanceOf(BadRequestError);
   });
+
+  test("keeps stored auth when both auth and credential are omitted", async () => {
+    seedConnection({
+      name: "label-only",
+      provider: "openai",
+      auth: { type: "oauth_subscription", credential: "vault/chatgpt/token" },
+    });
+
+    const result = (await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "label-only" },
+        body: { label: "Renamed" },
+      },
+    )) as { auth: object; label: string | null };
+    expect(result.auth).toEqual({
+      type: "oauth_subscription",
+      credential: "vault/chatgpt/token",
+    });
+    expect(result.label).toBe("Renamed");
+  });
+
+  test("throws 400 on credential-only PATCH of an oauth_subscription connection", async () => {
+    seedConnection({
+      name: "chatgpt-subscription",
+      provider: "openai",
+      auth: { type: "oauth_subscription", credential: "vault/chatgpt/token" },
+    });
+
+    await expect(
+      call(findHandler("inference_provider_connections_update"), {
+        pathParams: { name: "chatgpt-subscription" },
+        body: { credential: "vault/other" },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
+  test("rotates to derived api_key auth when only credential is passed", async () => {
+    seedConnection({
+      name: "rotate-cred",
+      provider: "anthropic",
+      auth: { type: "api_key", credential: "vault/old" },
+    });
+
+    const result = (await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "rotate-cred" },
+        body: { credential: "vault/new" },
+      },
+    )) as { auth: object };
+    expect(result.auth).toEqual({ type: "api_key", credential: "vault/new" });
+  });
 });
 
 // ── DELETE ────────────────────────────────────────────────────────────────────
@@ -390,31 +538,12 @@ describe("DELETE inference/provider-connections/:name (delete)", () => {
     expect((err as ConflictError).message).toContain("my-profile");
   });
 
-  test("throws 409 when llm.default references the connection", async () => {
-    seedConnection({
-      name: "default-conn",
-      provider: "anthropic",
-      auth: { type: "platform" },
-    });
-    setConfig("llm", {
-      default: { provider_connection: "default-conn" },
-    });
-
-    const err = await call(
-      findHandler("inference_provider_connections_delete"),
-      { pathParams: { name: "default-conn" } },
-    ).catch((e: unknown) => e);
-    expect(err).toBeInstanceOf(ConflictError);
-    expect((err as ConflictError).message).toContain("default-conn");
-    expect((err as ConflictError).message).toContain("llm.default");
-  });
-
-  test("throws 404 (not 409) when llm.default references a missing connection", async () => {
-    // Stale ref in config: llm.default points at a connection that was
+  test("throws 404 (not 409) when a profile references a missing connection", async () => {
+    // Stale ref in config: a profile points at a connection that was
     // already deleted. Delete on the dangling name must return 404 so
     // callers can distinguish stale config from active conflicts.
     setConfig("llm", {
-      default: { provider_connection: "ghost-conn" },
+      profiles: { "ghost-prof": { provider_connection: "ghost-conn" } },
     });
 
     await expect(
@@ -424,24 +553,26 @@ describe("DELETE inference/provider-connections/:name (delete)", () => {
     ).rejects.toBeInstanceOf(NotFoundError);
   });
 
-  test("throws 409 when both llm.default and a profile reference the connection", async () => {
+  test("throws 409 naming every referencing profile", async () => {
     seedConnection({
       name: "shared-conn",
       provider: "anthropic",
       auth: { type: "none" },
     });
     setConfig("llm", {
-      default: { provider_connection: "shared-conn" },
-      profiles: { "prof-a": { provider_connection: "shared-conn" } },
+      profiles: {
+        "prof-a": { provider_connection: "shared-conn" },
+        "prof-b": { provider_connection: "shared-conn" },
+      },
     });
 
-    // llm.default check fires first (before profiles check).
     const err = await call(
       findHandler("inference_provider_connections_delete"),
       { pathParams: { name: "shared-conn" } },
     ).catch((e: unknown) => e);
     expect(err).toBeInstanceOf(ConflictError);
-    expect((err as ConflictError).message).toContain("llm.default");
+    expect((err as ConflictError).message).toContain("prof-a");
+    expect((err as ConflictError).message).toContain("prof-b");
   });
 });
 

package/src/runtime/routes/__tests__/migration-vellum-metadata-reconcile.test.ts

@@ -28,6 +28,7 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { credentialKey } from "../../../security/credential-key.js";
+import * as actualMetadataStore from "../../../tools/credentials/metadata-store.js";
 
 type MetadataRecord = {
   credentialId: string;
@@ -80,7 +81,13 @@ mock.module("../../../security/secure-keys.js", () => ({
   _resetBackend: () => {},
 }));
 
+// Spread the real module so every export the reconcile handler's transitive
+// graph links (e.g. getCredentialMetadataById, listCredentialMetadata pulled in
+// via the plugin-api hub) stays present; only the two functions under test are
+// overridden. A partial mock replaces the whole namespace and fails to link the
+// unlisted exports.
 mock.module("../../../tools/credentials/metadata-store.js", () => ({
+  ...actualMetadataStore,
   getCredentialMetadata: (service: string, field: string) =>
     metadataStore.get(`${service}:${field}`),
   upsertCredentialMetadata: (

package/src/runtime/routes/__tests__/schedule-worker-routes.test.ts

@@ -20,6 +20,7 @@ let stopImpl: () => { status: "running" | "not_running"; pid?: number };
 let workerProbe: { status: "running" | "not_running"; pid?: number } = {
   status: "not_running",
 };
+const adminStoppedCalls: boolean[] = [];
 
 mock.module("../../../schedule/worker-control.js", () => ({
   ScheduleWorkerSpawnError: FakeSpawnError,
@@ -32,6 +33,9 @@ mock.module("../../../schedule/worker-control.js", () => ({
   },
   stopScheduleWorkerProcess: () => stopImpl(),
   probeScheduleWorker: () => workerProbe,
+  setScheduleWorkerAdministrativelyStopped: (value: boolean) => {
+    adminStoppedCalls.push(value);
+  },
 }));
 
 const { ROUTES } = await import("../schedule-worker-routes.js");
@@ -49,6 +53,7 @@ beforeEach(() => {
   spawnImpl = async () => ({ pid: 4242, alreadyRunning: false });
   stopImpl = () => ({ status: "not_running" });
   workerProbe = { status: "not_running" };
+  adminStoppedCalls.length = 0;
 });
 
 describe("schedules_worker_start", () => {
@@ -82,6 +87,11 @@ describe("schedules_worker_start", () => {
       "worker exited during startup",
     );
   });
+
+  test("clears the administratively-stopped flag so the watchdog resumes", async () => {
+    await handler("schedules_worker_start")();
+    expect(adminStoppedCalls).toContain(false);
+  });
 });
 
 describe("schedules_worker_stop", () => {
@@ -100,6 +110,11 @@ describe("schedules_worker_stop", () => {
 
     expect(res).toEqual({ workerWasRunning: false });
   });
+
+  test("sets the administratively-stopped flag so the watchdog does not respawn", async () => {
+    await handler("schedules_worker_stop")();
+    expect(adminStoppedCalls).toContain(true);
+  });
 });
 
 describe("schedules_worker_status", () => {

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

@@ -6,8 +6,10 @@ import { randomBytes } from "node:crypto";
 import {
   existsSync,
   mkdirSync,
+  mkdtempSync,
   readdirSync,
   readFileSync,
+  rmSync,
   statSync,
   writeFileSync,
 } from "node:fs";
@@ -19,6 +21,7 @@ import { z } from "zod";
 
 import {
   type AppDefinition,
+  type AppOrigin,
   createApp,
   createAppRecord,
   deleteApp,
@@ -38,7 +41,7 @@ import {
 } from "../../apps/app-store.js";
 import { createSharedAppLink } from "../../apps/shared-app-links-store.js";
 import { packageApp } from "../../bundler/app-bundler.js";
-import { compileApp } from "../../bundler/app-compiler.js";
+import { compileApp, runCompile } from "../../bundler/app-compiler.js";
 import { scanBundle } from "../../bundler/bundle-scanner.js";
 import type { SignatureJson } from "../../bundler/bundle-signer.js";
 import { verifyBundleSignature } from "../../bundler/signature-verifier.js";
@@ -278,6 +281,29 @@ function forkSharedApp(
     return { success: false, error: "Shared app HTML not found" };
   }
 
+  // The unpacked bundle keeps its manifest.json; only multi-file (format 2)
+  // shared apps may be forked, else the fork would resurrect the retired
+  // single-file format through the dist/ materialization below.
+  let sharedFormatVersion: unknown;
+  const manifestPath = join(dir, appUuid, "manifest.json");
+  if (existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(readFileSync(manifestPath, "utf-8")) as {
+        format_version?: unknown;
+      };
+      sharedFormatVersion = manifest.format_version;
+    } catch {
+      // Malformed manifest — treated as unsupported below.
+    }
+  }
+  if (Number(sharedFormatVersion) !== 2) {
+    return {
+      success: false,
+      error:
+        "This shared app uses the legacy single-file format, which is no longer supported",
+    };
+  }
+
   const htmlContent = readFileSync(htmlPath, "utf-8");
 
   const newApp = createApp({
@@ -287,6 +313,18 @@ function forkSharedApp(
     htmlDefinition: htmlContent,
   });
 
+  // Materialize the shared app's compiled output as the fork's dist/ so the
+  // fork opens without a source compile (mirrors bundle import).
+  const distDir = join(getAppDirPath(newApp.id), "dist");
+  mkdirSync(distDir, { recursive: true });
+  writeFileSync(join(distDir, "index.html"), htmlContent, "utf-8");
+  for (const asset of ["main.js", "main.css"]) {
+    const assetPath = join(dir, appUuid, asset);
+    if (existsSync(assetPath)) {
+      writeFileSync(join(distDir, asset), readFileSync(assetPath, "utf-8"));
+    }
+  }
+
   return { success: true, appId: newApp.id, name: newApp.name };
 }
 
@@ -450,10 +488,15 @@ async function importBundle(
       manifest = JSON.parse(manifestText);
     }
 
+    if (Number(manifest.format_version) !== 2) {
+      throw new BadRequestError(
+        "This app bundle uses the legacy single-file format, which is no longer supported. Re-export the app from a current version and try again.",
+      );
+    }
+
     const appName = manifest.name ?? "Imported App";
     const appDescription = manifest.description;
     const entry = manifest.entry ?? "index.html";
-    const isMultiFile = manifest.format_version === 2;
 
     // Extract entry HTML
     const entryFile = zip.file(entry);
@@ -476,32 +519,29 @@ async function importBundle(
       schemaJson: JSON.stringify({ type: "object", properties: {} }),
       htmlDefinition,
       icon,
-      formatVersion: isMultiFile ? 2 : undefined,
     });
 
-    // For multi-file apps, extract compiled dist assets (main.js, main.css)
-    // into the app's dist/ directory so the app can run correctly.
-    if (isMultiFile) {
-      const appDir = getAppDirPath(newApp.id);
-      const distDir = join(appDir, "dist");
-      mkdirSync(distDir, { recursive: true });
-
-      // Write dist/index.html
-      writeFileSync(join(distDir, "index.html"), htmlDefinition, "utf-8");
-
-      // Write dist/main.js if present in the bundle
-      const mainJsFile = zip.file("main.js");
-      if (mainJsFile) {
-        const mainJs = await mainJsFile.async("text");
-        writeFileSync(join(distDir, "main.js"), mainJs, "utf-8");
-      }
+    // Extract compiled dist assets (main.js, main.css) into the app's dist/
+    // directory so the app can run correctly.
+    const appDir = getAppDirPath(newApp.id);
+    const distDir = join(appDir, "dist");
+    mkdirSync(distDir, { recursive: true });
 
-      // Write dist/main.css if present in the bundle
-      const mainCssFile = zip.file("main.css");
-      if (mainCssFile) {
-        const mainCss = await mainCssFile.async("text");
-        writeFileSync(join(distDir, "main.css"), mainCss, "utf-8");
-      }
+    // Write dist/index.html
+    writeFileSync(join(distDir, "index.html"), htmlDefinition, "utf-8");
+
+    // Write dist/main.js if present in the bundle
+    const mainJsFile = zip.file("main.js");
+    if (mainJsFile) {
+      const mainJs = await mainJsFile.async("text");
+      writeFileSync(join(distDir, "main.js"), mainJs, "utf-8");
+    }
+
+    // Write dist/main.css if present in the bundle
+    const mainCssFile = zip.file("main.css");
+    if (mainCssFile) {
+      const mainCss = await mainCssFile.async("text");
+      writeFileSync(join(distDir, "main.css"), mainCss, "utf-8");
     }
 
     return {
@@ -651,6 +691,65 @@ function handleMutateAppData({ pathParams, body }: RouteHandlerArgs) {
   return { success: true, result };
 }
 
+/**
+ * Wire-format provenance tag for an app, matching what `apps_list` reports:
+ * `"workspace"` for user-created apps, `"plugin:<name>"` for plugin-bundled
+ * ones. Clients read it to hide the mutation actions (delete, share, deploy)
+ * the daemon rejects for plugin apps.
+ */
+function appOriginWire(origin: AppOrigin): string {
+  return origin.kind === "plugin" ? `plugin:${origin.pluginName}` : "workspace";
+}
+
+/**
+ * Compile a multi-file plugin app on open, without touching its `dist/`.
+ *
+ * A plugin app's real `dist/` is owned by the monitor process
+ * (`plugin-source-watch`), which builds it on install and on every source
+ * change. But a just-installed app can be opened before the monitor's first
+ * pass lands, which would otherwise render the "not compiled yet" fallback.
+ * Building in place here would both write into the read-only plugin tree and
+ * race the monitor's `rm -rf dist` + write. Instead we compile into a private
+ * temp dir and return the self-contained HTML from there, leaving `dist/`
+ * ownership solely with the monitor. Returns `null` if the build fails, so the
+ * caller falls back to the standard fallback HTML.
+ */
+async function compilePluginAppHtmlEphemeral(
+  appId: string,
+  sourceDir: string,
+): Promise<string | null> {
+  // `resolveAppSource` classifies any app without a root index.html as
+  // multi-file, even a malformed one with no src/ (or one whose source was
+  // removed before the monitor built dist/). Building that would make the
+  // compiler throw, so skip it and let the caller serve the standard fallback
+  // rather than surfacing a 500 from a plain open.
+  if (!existsSync(join(sourceDir, "src"))) {
+    return null;
+  }
+  const tmpRoot = mkdtempSync(join(tmpdir(), "vellum-plugin-app-"));
+  try {
+    const result = await runCompile(sourceDir, join(tmpRoot, "dist"));
+    if (!result.ok) {
+      log.warn(
+        { appId, errors: result.errors },
+        "Ephemeral compile failed on plugin app open",
+      );
+      return null;
+    }
+    // resolveEffectiveAppHtmlFromDir reads `<tmpRoot>/dist/index.html` and
+    // inlines its JS/CSS, yielding a self-contained page.
+    return resolveEffectiveAppHtmlFromDir(tmpRoot);
+  } catch (err) {
+    // The compiler reports build failures via `ok: false`; a thrown error is
+    // unexpected (e.g. a filesystem fault mid-build) and must still degrade to
+    // the fallback instead of a 500.
+    log.warn({ appId, err }, "Ephemeral compile threw on plugin app open");
+    return null;
+  } finally {
+    rmSync(tmpRoot, { recursive: true, force: true });
+  }
+}
+
 async function handleOpenApp({ pathParams }: RouteHandlerArgs) {
   const appId = pathParams?.id as string;
   const source = resolveAppSource(appId);
@@ -658,33 +757,40 @@ async function handleOpenApp({ pathParams }: RouteHandlerArgs) {
     throw new NotFoundError(`App not found: ${appId}`);
   }
 
-  // Multifile workspace apps auto-compile on open when their dist is missing.
-  // Plugin apps are not compiled here — a compile cache for plugin sources is a
-  // follow-up — so a multifile plugin app without a prebuilt dist/ renders its
-  // fallback message.
-  if (source.formatVersion === 2 && source.origin.kind === "workspace") {
-    const distIndex = join(source.sourceDir, "dist", "index.html");
-    if (!existsSync(distIndex)) {
-      const result = await compileApp(source.sourceDir);
-      if (!result.ok) {
+  const result = {
+    appId: source.id,
+    dirName: source.dirName,
+    name: source.name,
+    origin: appOriginWire(source.origin),
+  };
+
+  // Apps auto-compile on open when their dist/ is missing so a freshly
+  // installed app renders immediately instead of the "not compiled yet"
+  // fallback.
+  if (!existsSync(join(source.sourceDir, "dist", "index.html"))) {
+    if (source.origin.kind === "workspace") {
+      // Workspace apps own their dist/ and are only compiled in this (daemon)
+      // process, so building in place is safe.
+      const compiled = await compileApp(source.sourceDir);
+      if (!compiled.ok) {
         log.warn(
-          { appId, errors: result.errors },
+          { appId, errors: compiled.errors },
           "Auto-compile failed on app open",
         );
       }
+    } else {
+      // Plugin apps: compile off to the side (see helper) rather than write
+      // into the plugin tree or race the monitor.
+      const html = await compilePluginAppHtmlEphemeral(appId, source.sourceDir);
+      if (html !== null) {
+        return { ...result, html };
+      }
+      // Build failed — fall through to the standard fallback HTML.
     }
   }
 
-  const html = resolveEffectiveAppHtmlFromDir(
-    source.sourceDir,
-    source.formatVersion,
-  );
-  return {
-    appId: source.id,
-    dirName: source.dirName,
-    name: source.name,
-    html,
-  };
+  const html = resolveEffectiveAppHtmlFromDir(source.sourceDir);
+  return { ...result, html };
 }
 
 /**
@@ -1015,6 +1121,7 @@ export const ROUTES: RouteDefinition[] = [
       dirName: z.string(),
       name: z.string(),
       html: z.string(),
+      origin: z.string(),
     }),
   },
   {