@vellumai/assistant 0.12.5-dev.202609261222.09a30ca → 0.12.5-dev.202609261415.2575c70

package/openapi.yaml

@@ -21572,6 +21572,7 @@ paths:
                                           - searxng
                                           - tinyfish
                                           - exa
+                                          - serply
                                       resultCount:
                                         type: number
                                       durationMs:
@@ -22191,6 +22192,7 @@ paths:
                                                   - searxng
                                                   - tinyfish
                                                   - exa
+                                                  - serply
                                               resultCount:
                                                 type: number
                                               durationMs:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.5-dev.202609261222.09a30ca",
+  "version": "0.12.5-dev.202609261415.2575c70",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/headless-browser-navigate.test.ts

@@ -233,6 +233,7 @@ describe("executeBrowserNavigate", () => {
     resetMockPage();
     resetCdp();
     __resetPinnedTabsForTests();
+    mockExtensionAvailable = false;
   });
 
   // ── Input validation ───────────────────────────────────────────
@@ -606,6 +607,13 @@ describe("executeBrowserNavigate", () => {
     const routeCallsBefore = mockPage.route.mock.calls.length;
     const unrouteCallsBefore = mockPage.unroute.mock.calls.length;
 
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") {
+        return { tabId: "42" };
+      }
+      return defaultCdpHandler(method, params);
+    };
+
     const result = await executeBrowserNavigate(
       { url: "https://example.com/page" },
       extensionCtx,
@@ -643,6 +651,9 @@ describe("executeBrowserNavigate", () => {
     // navigateAndWait returns a private final URL (simulating a
     // server-side redirect).
     cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") {
+        return { tabId: "42" };
+      }
       if (method === "Page.navigate") {
         return { frameId: "f1" };
       }
@@ -745,13 +756,7 @@ describe("executeBrowserNavigate", () => {
     expect(cdpDisposed).toBe(true);
   });
 
-  test("new_tab: true on extension path with no tabId in response clears live session and still continues", async () => {
-    // Defensive: dispatcher returns success but no tabId. The
-    // executor logs a warn, resets the live cdp session to undefined
-    // (so the follow-on Page.navigate routes to the active tab
-    // instead of any stale pin the cdp instance was constructed
-    // with), and proceeds. The navigate still runs (degraded
-    // behaviour but not a hard failure).
+  test("new_tab: true on extension path with no tabId in response fails closed", async () => {
     parseUrlResult = new URL("https://example.com/page");
     mockExtensionAvailable = true;
 
@@ -767,25 +772,13 @@ describe("executeBrowserNavigate", () => {
       { ...ctx },
     );
 
-    expect(result.isError).toBe(false);
-    // No new pin was set, BUT the live session was reset to undefined
-    // so the follow-on Page.navigate falls back to active-tab routing
-    // instead of any stale pin the cdp instance held at construction.
-    expect(cdpSetSessionIdCalls).toEqual([undefined]);
-    // Page.navigate still ran.
-    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
+    expect(result.isError).toBe(true);
+    expect(String(result.content)).toContain("returned no tabId");
+    expect(cdpSetSessionIdCalls).toEqual([]);
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(false);
   });
 
-  test("new_tab: true with no tabId in response clears a pre-existing stale pin AND live session (regression)", async () => {
-    // Regression for the Codex round-2 findings (P2 + round-3 P1):
-    // when Vellum.createTab returns a malformed response with no
-    // tabId, the executor falls back to active-tab routing — but
-    // (a) the pin store still held the stale pin (round-2 P2 fix
-    // added clearPinnedTab), and (b) the LIVE cdp instance was
-    // already constructed with that stale cdpSessionId, so the
-    // follow-on Page.navigate would still route to the dead tab
-    // unless we reset the session on the cdp instance too (round-3
-    // P1 fix added cdp.setCdpSessionId(undefined)).
+  test("new_tab: true with no tabId in response clears a pre-existing stale pin and fails closed", async () => {
     const { setPinnedTab, getPinnedTab } =
       await import("../tools/browser/pinned-tabs.js");
     setPinnedTab(ctx.conversationId, "stale-pinned-tab-id");
@@ -806,12 +799,9 @@ describe("executeBrowserNavigate", () => {
       { ...ctx },
     );
 
-    expect(result.isError).toBe(false);
-    // (a) Pin store cleared.
+    expect(result.isError).toBe(true);
     expect(getPinnedTab(ctx.conversationId)).toBeUndefined();
-    // (b) Live cdp session reset (the fake records every
-    // setCdpSessionId arg; expect exactly one call with undefined).
-    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+    expect(cdpSetSessionIdCalls).toEqual([]);
   });
 
   test("new_tab: true on LOCAL path is a no-op (Playwright manages its own isolated browser)", async () => {
@@ -935,7 +925,7 @@ describe("executeBrowserNavigate", () => {
       false,
     );
     expect(getPinnedTab(ctx.conversationId)).toBeUndefined();
-    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+    expect(cdpSetSessionIdCalls).toEqual(["active"]);
     expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
   });
 

package/src/api/events/tool-result.ts

@@ -55,6 +55,7 @@ export const WebSearchProviderIdSchema = z.enum([
   "searxng",
   "tinyfish",
   "exa",
+  "serply",
 ]);
 
 export type WebSearchProviderId = z.infer<typeof WebSearchProviderIdSchema>;

package/src/cli/lib/__tests__/plugin-artifact.test.ts

@@ -123,6 +123,23 @@ describe("parsePluginArtifact", () => {
     });
   });
 
+  test("ignores a malformed icon beside a valid artifact", () => {
+    expect(
+      parsePluginArtifact({
+        vellum: {
+          artifact: {
+            url: "https://example.com/App.dmg",
+            sha256: VALID_SHA,
+          },
+          icon: 42,
+        },
+      }),
+    ).toEqual({
+      url: "https://example.com/App.dmg",
+      sha256: VALID_SHA,
+    });
+  });
+
   test.each([
     ["no vellum block", { name: "x" }],
     ["no artifact block", { vellum: {} }],
@@ -202,6 +219,12 @@ describe("parsePluginIcon", () => {
     expect(parsePluginIcon({ vellum: { icon: sixteen } })).toBe(sixteen);
   });
 
+  test("ignores a malformed artifact beside a valid icon", () => {
+    expect(
+      parsePluginIcon({ vellum: { artifact: "App.dmg", icon: "🚀" } }),
+    ).toBe("🚀");
+  });
+
   test.each([
     ["no vellum block", { name: "x" }],
     ["no icon field", { vellum: {} }],

package/src/cli/lib/__tests__/plugin-details.test.ts

@@ -309,6 +309,22 @@ describe("getPluginDetails (bundled catalog, offline)", () => {
     expect(details.icon).toBeNull();
   });
 
+  test("reads a legacy object-form license from an installed package.json", async () => {
+    const target = join(workspace, "caveman");
+    mkdirSync(target, { recursive: true });
+    writeFileSync(
+      join(target, "package.json"),
+      JSON.stringify({ version: "2.0.0", license: { type: "MIT" } }),
+    );
+
+    const details = await getPluginDetails(
+      { name: "caveman" },
+      { fetch: makeFetch({}), workspacePluginsDir: workspace },
+    );
+
+    expect(details.license).toBe("MIT");
+  });
+
   test("reads metadata from an installed standard-only plugin.json", async () => {
     const target = join(workspace, "caveman");
     mkdirSync(target, { recursive: true });

package/src/cli/lib/inspect-plugin.ts

@@ -16,6 +16,8 @@
  * is a thin wrapper that supplies production deps and formats the result.
  */
 
+import { z } from "zod";
+
 import { PRESERVED_ENTRIES } from "../../plugins/plugin-tree-walk.js";
 import type { FetchLike } from "./fetch-like.js";
 import {
@@ -50,6 +52,14 @@ import type { PluginCatalog, PluginSearchMatch } from "./search-plugins.js";
 /** Full commit SHA (40 hex SHA-1 or 64 hex SHA-256). */
 const FULL_SHA_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
 
+const GitHubCommitResponseSchema = z.object({
+  commit: z.object({
+    committer: z.object({
+      date: z.string(),
+    }),
+  }),
+});
+
 /**
  * Drift classification between the installed copy and the marketplace pin.
  *
@@ -294,23 +304,13 @@ export async function fetchCommitDate(
     if (!res.ok) {
       return null;
     }
-    const json: unknown = JSON.parse(await res.text());
-    if (typeof json !== "object" || json === null) {
-      return null;
-    }
-    const commit = (json as Record<string, unknown>).commit;
-    if (typeof commit !== "object" || commit === null) {
-      return null;
-    }
-    const committer = (commit as Record<string, unknown>).committer;
-    if (typeof committer !== "object" || committer === null) {
-      return null;
-    }
-    const date = (committer as Record<string, unknown>).date;
-    if (typeof date !== "string") {
+    const parsed = GitHubCommitResponseSchema.safeParse(
+      JSON.parse(await res.text()),
+    );
+    if (!parsed.success) {
       return null;
     }
-    const ms = Date.parse(date);
+    const ms = Date.parse(parsed.data.commit.committer.date);
     return Number.isFinite(ms) ? new Date(ms).toISOString() : null;
   } catch {
     return null;

package/src/cli/lib/list-installed-plugins.ts

@@ -16,12 +16,14 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { z } from "zod";
+
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 import {
   LEGACY_PLUGIN_MANIFEST,
   readPluginManifest,
 } from "../../util/plugin-manifest.js";
-import { parsePluginIcon } from "./plugin-artifact.js";
+import { PluginPackageJsonSchema } from "./plugin-artifact.js";
 import { readValidatedPluginIcon } from "./plugin-icon-file.js";
 
 /**
@@ -39,6 +41,15 @@ const DEFAULT_PLUGINS_DIR = join(
   "defaults",
 );
 
+const DefaultPluginManifestSchema = z.object({
+  name: z.string(),
+  version: z.string().optional().catch(undefined),
+});
+
+const InstallMetadataSchema = z.object({
+  installedAt: z.string(),
+});
+
 /** Minimal manifest fields surfaced to the CLI. */
 export interface PluginPackageMetadata {
   readonly name?: string;
@@ -163,23 +174,17 @@ function readPluginEntry(
     issues.push(err instanceof Error ? err.message : String(err));
     return { name, target, packageJson: null, issues, ...iconFields };
   }
-  const meta = manifest.raw;
-  const icon =
-    manifest.source === LEGACY_PLUGIN_MANIFEST
-      ? parsePluginIcon(meta)
-      : undefined;
+  const parsedPackageJson = PluginPackageJsonSchema.safeParse(manifest.raw);
+  const legacyMetadata =
+    manifest.source === LEGACY_PLUGIN_MANIFEST && parsedPackageJson.success
+      ? parsedPackageJson.data
+      : null;
   const packageJson: PluginPackageMetadata = {
     name: manifest.name,
     version: manifest.version,
     description: manifest.description,
-    peerDependencies:
-      manifest.source === LEGACY_PLUGIN_MANIFEST &&
-      typeof meta.peerDependencies === "object" &&
-      meta.peerDependencies !== null &&
-      !Array.isArray(meta.peerDependencies)
-        ? (meta.peerDependencies as Record<string, string>)
-        : undefined,
-    ...(icon ? { icon } : {}),
+    peerDependencies: legacyMetadata?.peerDependencies,
+    ...(legacyMetadata?.icon ? { icon: legacyMetadata.icon } : {}),
   };
 
   return { name, target, packageJson, issues, ...iconFields };
@@ -319,14 +324,11 @@ function readDefaultPluginManifests(): readonly DefaultPluginManifest[] {
       continue;
     }
     try {
-      const raw = readFileSync(pkgJsonPath, "utf8");
-      const parsed = JSON.parse(raw) as Record<string, unknown>;
-      if (typeof parsed.name === "string") {
-        manifests.push({
-          name: parsed.name,
-          version:
-            typeof parsed.version === "string" ? parsed.version : undefined,
-        });
+      const parsed = DefaultPluginManifestSchema.safeParse(
+        JSON.parse(readFileSync(pkgJsonPath, "utf8")),
+      );
+      if (parsed.success) {
+        manifests.push(parsed.data);
       }
     } catch {
       // Skip malformed entries — lenient like listInstalledPlugins.
@@ -345,12 +347,11 @@ function getPluginInstallDate(plugin: AllPluginInfo): number {
   const metaPath = join(plugin.target, "install-meta.json");
   try {
     if (existsSync(metaPath)) {
-      const raw = JSON.parse(readFileSync(metaPath, "utf8")) as Record<
-        string,
-        unknown
-      >;
-      if (typeof raw.installedAt === "string") {
-        const ms = Date.parse(raw.installedAt);
+      const parsed = InstallMetadataSchema.safeParse(
+        JSON.parse(readFileSync(metaPath, "utf8")),
+      );
+      if (parsed.success) {
+        const ms = Date.parse(parsed.data.installedAt);
         if (Number.isFinite(ms)) {
           return ms;
         }

package/src/cli/lib/plugin-artifact.ts

@@ -52,21 +52,76 @@ const SHA256_HEX_RE = /^[0-9a-f]{64}$/;
  * the digest must be canonical lowercase hex so client-side comparison is a
  * plain string equality with no normalization step.
  */
-const PluginArtifactSchema = z.object({
-  url: z
-    .string()
-    .url()
-    .refine((u) => u.startsWith("https://"), {
-      message: "artifact url must be an https:// URL",
-    }),
-  sha256: z
-    .string()
-    .regex(SHA256_HEX_RE, "artifact sha256 must be 64 lowercase hex chars"),
-  // Optional, non-critical metadata: a malformed label must never nullify an
-  // otherwise-valid `url` + `sha256`, so a wrong-typed value falls back to
-  // `undefined` rather than failing the whole descriptor.
-  label: z.string().optional().catch(undefined),
-});
+const PluginArtifactSchema = z
+  .object({
+    url: z
+      .string()
+      .url()
+      .refine((u) => u.startsWith("https://"), {
+        message: "artifact url must be an https:// URL",
+      }),
+    sha256: z
+      .string()
+      .regex(SHA256_HEX_RE, "artifact sha256 must be 64 lowercase hex chars"),
+    // Optional, non-critical metadata: a malformed label must never nullify an
+    // otherwise-valid `url` + `sha256`, so a wrong-typed value falls back to
+    // `undefined` rather than failing the whole descriptor.
+    label: z
+      .string()
+      .transform((label) => label.trim())
+      .optional()
+      .catch(undefined),
+  })
+  .transform(({ label, ...artifact }) =>
+    label ? { ...artifact, label } : artifact,
+  );
+
+/** Upper bound on `vellum.icon`, in Unicode code points. */
+const MAX_ICON_CODE_POINTS = 16;
+
+const PluginIconSchema = z
+  .string()
+  .transform((icon) => icon.trim())
+  .refine(
+    (icon) => {
+      const codePoints = [...icon].length;
+      return codePoints >= 1 && codePoints <= MAX_ICON_CODE_POINTS;
+    },
+    { message: "plugin icon must contain 1 to 16 Unicode code points" },
+  );
+
+const LicenseSchema = z
+  .union([
+    z.string(),
+    z.object({ type: z.string() }).transform(({ type }) => type),
+    z.undefined(),
+  ])
+  .catch(undefined);
+
+export const PluginPackageJsonSchema = z
+  .object({
+    name: z.string().optional().catch(undefined),
+    version: z.string().optional().catch(undefined),
+    description: z.string().optional().catch(undefined),
+    homepage: z.string().optional().catch(undefined),
+    license: LicenseSchema.optional(),
+    peerDependencies: z
+      .record(z.string(), z.string())
+      .optional()
+      .catch(undefined),
+    vellum: z
+      .object({
+        artifact: PluginArtifactSchema.optional().catch(undefined),
+        icon: PluginIconSchema.optional().catch(undefined),
+      })
+      .optional()
+      .catch(undefined),
+  })
+  .transform(({ vellum, ...packageJson }) => ({
+    ...packageJson,
+    artifact: vellum?.artifact,
+    icon: vellum?.icon,
+  }));
 
 /**
  * Read `vellum.artifact` from an already-parsed `package.json` value and
@@ -78,36 +133,10 @@ const PluginArtifactSchema = z.object({
 export function parsePluginArtifact(
   packageJson: unknown,
 ): PluginArtifact | null {
-  if (
-    typeof packageJson !== "object" ||
-    packageJson === null ||
-    Array.isArray(packageJson)
-  ) {
-    return null;
-  }
-  const vellum = (packageJson as Record<string, unknown>).vellum;
-  if (typeof vellum !== "object" || vellum === null || Array.isArray(vellum)) {
-    return null;
-  }
-  const parsed = PluginArtifactSchema.safeParse(
-    (vellum as Record<string, unknown>).artifact,
-  );
-  if (!parsed.success) {
-    return null;
-  }
-  // A blank or whitespace-only label is treated as absent so it never
-  // invalidates an otherwise well-formed `url` + `sha256` descriptor.
-  const label = parsed.data.label?.trim();
-  return {
-    url: parsed.data.url,
-    sha256: parsed.data.sha256,
-    ...(label ? { label } : {}),
-  };
+  const parsed = PluginPackageJsonSchema.safeParse(packageJson);
+  return parsed.success ? (parsed.data.artifact ?? null) : null;
 }
 
-/** Upper bound on `vellum.icon`, in Unicode code points. */
-const MAX_ICON_CODE_POINTS = 16;
-
 /**
  * Read `vellum.icon` from an already-parsed `package.json` value and return
  * it only when it is a short, non-empty glyph (an emoji or similar). The
@@ -116,25 +145,6 @@ const MAX_ICON_CODE_POINTS = 16;
  * type, empty, or too long — yields `undefined` rather than throwing.
  */
 export function parsePluginIcon(packageJson: unknown): string | undefined {
-  if (
-    typeof packageJson !== "object" ||
-    packageJson === null ||
-    Array.isArray(packageJson)
-  ) {
-    return undefined;
-  }
-  const vellum = (packageJson as Record<string, unknown>).vellum;
-  if (typeof vellum !== "object" || vellum === null || Array.isArray(vellum)) {
-    return undefined;
-  }
-  const icon = (vellum as Record<string, unknown>).icon;
-  if (typeof icon !== "string") {
-    return undefined;
-  }
-  const trimmed = icon.trim();
-  const codePoints = [...trimmed].length;
-  if (codePoints < 1 || codePoints > MAX_ICON_CODE_POINTS) {
-    return undefined;
-  }
-  return trimmed;
+  const parsed = PluginPackageJsonSchema.safeParse(packageJson);
+  return parsed.success ? parsed.data.icon : undefined;
 }

package/src/cli/lib/plugin-details.ts

@@ -32,15 +32,16 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
+import { z } from "zod";
+
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 import { readPluginManifest } from "../../util/plugin-manifest.js";
 import { readBundledPluginFile } from "./bundled-plugin-packages.js";
 import type { FetchLike } from "./fetch-like.js";
 import { sanitizePluginName } from "./install-from-github.js";
 import {
-  parsePluginArtifact,
-  parsePluginIcon,
   type PluginArtifact,
+  PluginPackageJsonSchema,
 } from "./plugin-artifact.js";
 import {
   findCatalogEntry,
@@ -61,12 +62,16 @@ import {
 const README_RE = /^readme(\.md|\.markdown)?$/i;
 
 /** Entry shape returned by the GitHub Contents API for a directory listing. */
-interface GitHubContentEntry {
-  readonly name: string;
-  readonly path: string;
-  readonly type: "file" | "dir" | "symlink" | "submodule";
-  readonly download_url: string | null;
-}
+const GitHubContentEntrySchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  type: z.enum(["file", "dir", "symlink", "submodule"]),
+  download_url: z.string().nullable(),
+});
+
+const GitHubContentListingSchema = z.array(GitHubContentEntrySchema);
+
+type GitHubContentEntry = z.infer<typeof GitHubContentEntrySchema>;
 
 /** The subset of `package.json` fields the detail view surfaces. */
 interface PluginManifestFields {
@@ -249,11 +254,14 @@ function readLocalPlugin(pluginsDir: string, name: string): LocalPlugin {
       manifest = parseManifest(readFileSync(packagePath, "utf8"));
     } else {
       const selected = readPluginManifest(target);
+      const parsedPackageJson = PluginPackageJsonSchema.safeParse(selected.raw);
       manifest = {
         version: selected.version ?? null,
         description: selected.description ?? null,
         homepage: selected.homepage ?? null,
-        license: normalizeLicense(selected.license),
+        license: parsedPackageJson.success
+          ? (parsedPackageJson.data.license ?? null)
+          : null,
         artifact: null,
         icon: null,
       };
@@ -365,11 +373,8 @@ async function listDirSafe(
     if (!res.ok) {
       return null;
     }
-    const body = (await res.json()) as unknown;
-    if (!Array.isArray(body)) {
-      return null;
-    }
-    return body as readonly GitHubContentEntry[];
+    const parsed = GitHubContentListingSchema.safeParse(await res.json());
+    return parsed.success ? parsed.data : null;
   } catch {
     return null;
   }
@@ -502,36 +507,16 @@ function safeParseManifest(raw: string): PluginManifestFields {
 
 /** Extract the surfaced fields from a `package.json` body. Throws on bad JSON. */
 function parseManifest(raw: string): PluginManifestFields {
-  const parsed: unknown = JSON.parse(raw);
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+  const parsed = PluginPackageJsonSchema.safeParse(JSON.parse(raw));
+  if (!parsed.success) {
     return emptyManifest();
   }
-  const meta = parsed as Record<string, unknown>;
   return {
-    version: typeof meta.version === "string" ? meta.version : null,
-    description: typeof meta.description === "string" ? meta.description : null,
-    homepage: typeof meta.homepage === "string" ? meta.homepage : null,
-    license: normalizeLicense(meta.license),
-    artifact: parsePluginArtifact(parsed),
-    icon: parsePluginIcon(parsed) ?? null,
+    version: parsed.data.version ?? null,
+    description: parsed.data.description ?? null,
+    homepage: parsed.data.homepage ?? null,
+    license: parsed.data.license ?? null,
+    artifact: parsed.data.artifact ?? null,
+    icon: parsed.data.icon ?? null,
   };
 }
-
-/**
- * `package.json#license` is usually an SPDX string but the legacy object form
- * `{ "type": "MIT" }` still appears in the wild — surface its `type`.
- */
-function normalizeLicense(value: unknown): string | null {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (
-    typeof value === "object" &&
-    value !== null &&
-    "type" in value &&
-    typeof (value as { type: unknown }).type === "string"
-  ) {
-    return (value as { type: string }).type;
-  }
-  return null;
-}

package/src/cli/lib/plugin-marketplace.ts

@@ -183,15 +183,13 @@ const fetchedMarketplaceManifestSchema = marketplaceManifestBaseSchema.extend({
   plugins: z.array(z.unknown()),
 });
 
+const marketplaceSourceDiscriminatorSchema = z.object({
+  source: z.object({ source: z.unknown() }),
+});
+
 function readSourceDiscriminator(entry: unknown): unknown {
-  if (typeof entry !== "object" || entry === null) {
-    return null;
-  }
-  const source = (entry as Record<string, unknown>).source;
-  if (typeof source !== "object" || source === null) {
-    return null;
-  }
-  return (source as Record<string, unknown>).source;
+  const parsed = marketplaceSourceDiscriminatorSchema.safeParse(entry);
+  return parsed.success ? parsed.data.source.source : null;
 }
 
 /** A single reviewed plugin entry. */