@vellumai/assistant 0.8.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -15,6 +15,8 @@
     "db:generate": "drizzle-kit generate",
     "db:push": "drizzle-kit push",
     "generate:openapi": "bun run scripts/generate-openapi.ts",
+    "sync:llm-catalog": "bun run scripts/sync-llm-catalog.ts",
+    "sync:web-search-catalog": "bun run scripts/sync-web-search-catalog.ts",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "eslint",

package/scripts/generate-openapi.ts

@@ -19,6 +19,7 @@
 import { readFileSync } from "node:fs";
 import { readdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { Readable } from "node:stream";
 
 import { stringify } from "yaml";
 import { z } from "zod";
@@ -110,8 +111,48 @@ interface JSONSchemaObject {
   [key: string]: unknown;
 }
 
+/**
+ * Recursively strip fields with a `default` from `required[]` on every
+ * object schema in the tree. Zod 4's `toJSONSchema` (output mode) marks
+ * defaulted fields as required because the output always carries them,
+ * but for request bodies the server fills the default when the client
+ * omits the field — generated clients should not be forced to send it.
+ */
+function dropDefaultedFromRequired(node: unknown): void {
+  if (node == null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) dropDefaultedFromRequired(item);
+    return;
+  }
+  const obj = node as Record<string, unknown>;
+  const props = obj.properties;
+  const required = obj.required;
+  if (
+    Array.isArray(required) &&
+    props != null &&
+    typeof props === "object"
+  ) {
+    const propsRecord = props as Record<string, unknown>;
+    const filtered = required.filter((name) => {
+      if (typeof name !== "string") return true;
+      const prop = propsRecord[name];
+      return !(
+        prop != null &&
+        typeof prop === "object" &&
+        "default" in (prop as Record<string, unknown>)
+      );
+    });
+    if (filtered.length > 0) obj.required = filtered;
+    else delete obj.required;
+  }
+  for (const value of Object.values(obj)) dropDefaultedFromRequired(value);
+}
+
 /** Convert a Zod schema or plain JSON Schema object to a JSON Schema object. */
-function toJSONSchemaObject(schema: unknown): JSONSchemaObject {
+function toJSONSchemaObject(
+  schema: unknown,
+  options: { stripRequiredDefaults?: boolean } = {},
+): JSONSchemaObject {
   if (schema == null || typeof schema !== "object") return {};
   // Zod schema: has _zod branded property
   if ("_zod" in (schema as Record<string, unknown>)) {
@@ -120,6 +161,7 @@ function toJSONSchemaObject(schema: unknown): JSONSchemaObject {
     });
     // z.toJSONSchema may add $schema — strip it for inline embedding
     const { $schema: _, ...rest } = converted as Record<string, unknown>;
+    if (options.stripRequiredDefaults) dropDefaultedFromRequired(rest);
     return rest as JSONSchemaObject;
   }
   // Plain JSON Schema object (backward compat for inline/pre-auth routes)
@@ -389,7 +431,9 @@ function buildSpec(
       const content: Record<string, { schema: JSONSchemaObject }> = {};
       for (const variant of entry.requestBodies) {
         content[variant.contentType] = {
-          schema: toJSONSchemaObject(variant.schema),
+          schema: toJSONSchemaObject(variant.schema, {
+            stripRequiredDefaults: true,
+          }),
         };
       }
       operation.requestBody = { required: true, content };
@@ -398,7 +442,9 @@ function buildSpec(
         required: true,
         content: {
           "application/json": {
-            schema: toJSONSchemaObject(entry.requestBody),
+            schema: toJSONSchemaObject(entry.requestBody, {
+              stripRequiredDefaults: true,
+            }),
           },
         },
       };
@@ -470,8 +516,10 @@ async function main() {
     stringify(spec, { lineWidth: 120 });
 
   // Format with prettier so the output matches what the pre-commit hook produces.
+  // Use a Node.js Readable stream for stdin — Bun.spawn with Blob stdin produces
+  // empty output on some platforms (Bun 1.3.x Linux sandbox).
   const prettierProc = Bun.spawn(["bunx", "prettier", "--parser", "yaml"], {
-    stdin: new Blob([rawYaml]),
+    stdin: Readable.from([rawYaml]) as unknown as Blob,
     stdout: "pipe",
     stderr: "pipe",
   });

package/scripts/sync-llm-catalog.ts

@@ -0,0 +1,165 @@
+#!/usr/bin/env bun
+/**
+ * Generate `llm-provider-catalog.json` from the canonical
+ * `PROVIDER_CATALOG` in `assistant/src/providers/model-catalog.ts`.
+ *
+ * The JSON file is the client-facing catalog bundled into native clients
+ * (macOS, web). Keeping it generated — rather than hand-mirrored — eliminates
+ * the recurring "I edited model-catalog.ts and forgot the JSON" failure mode
+ * that the parity test only catches after push.
+ *
+ * Two byte-identical copies are written:
+ *   - `meta/llm-provider-catalog.json` — primary checked-in artifact, read
+ *      by web codegen (§D) and any non-Swift consumer.
+ *   - `clients/shared/Resources/llm-provider-catalog.json` — SwiftPM resource
+ *      bundled into `VellumAssistantShared`. SwiftPM cannot reach files
+ *      outside a target's source directory, so this mirror is necessary;
+ *      both files are produced by the same generator and asserted equal by
+ *      the parity test, making drift impossible.
+ *
+ * The projection drops daemon-only fields (today: `apiKeyUrl`, which clients
+ * read from `credentialsGuide.url` instead) and pins field order so the
+ * diff stays minimal when models or providers change.
+ *
+ * Usage:
+ *   cd assistant && bun run scripts/sync-llm-catalog.ts
+ *   cd assistant && bun run sync:llm-catalog              # via npm script
+ *   cd assistant && bun run sync:llm-catalog -- --check   # CI: fail if stale
+ */
+
+import { readFile, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+
+import {
+  type CatalogModel,
+  PROVIDER_CATALOG,
+  type ProviderCatalogEntry,
+} from "../src/providers/model-catalog.js";
+
+const ROOT = resolve(import.meta.dir, "../..");
+const OUTPUT_PATHS = [
+  join(ROOT, "meta/llm-provider-catalog.json"),
+  join(ROOT, "clients/shared/Resources/llm-provider-catalog.json"),
+] as const;
+
+/**
+ * Bumped when the *shape* of the client catalog JSON changes in a way native
+ * clients must opt into. Adding fields that older clients can ignore does
+ * NOT require a bump.
+ */
+const CLIENT_CATALOG_VERSION = 1;
+
+// ---------------------------------------------------------------------------
+// Projection
+//
+// Each helper pins explicit field order so JSON.stringify produces a stable
+// diff. Optional fields are omitted (not serialized as null) when undefined.
+// ---------------------------------------------------------------------------
+
+function projectModel(model: CatalogModel): Record<string, unknown> {
+  const projected: Record<string, unknown> = {
+    id: model.id,
+    displayName: model.displayName,
+  };
+  if (model.contextWindowTokens !== undefined)
+    projected.contextWindowTokens = model.contextWindowTokens;
+  if (model.maxOutputTokens !== undefined)
+    projected.maxOutputTokens = model.maxOutputTokens;
+  if (model.defaultContextWindowTokens !== undefined)
+    projected.defaultContextWindowTokens = model.defaultContextWindowTokens;
+  if (model.longContextPricingThresholdTokens !== undefined)
+    projected.longContextPricingThresholdTokens =
+      model.longContextPricingThresholdTokens;
+  if (model.longContextMode !== undefined)
+    projected.longContextMode = model.longContextMode;
+  if (model.supportsThinking !== undefined)
+    projected.supportsThinking = model.supportsThinking;
+  if (model.supportsCaching !== undefined)
+    projected.supportsCaching = model.supportsCaching;
+  if (model.supportsVision !== undefined)
+    projected.supportsVision = model.supportsVision;
+  if (model.supportsToolUse !== undefined)
+    projected.supportsToolUse = model.supportsToolUse;
+  if (model.pricing !== undefined) projected.pricing = model.pricing;
+  return projected;
+}
+
+function projectProvider(entry: ProviderCatalogEntry): Record<string, unknown> {
+  const projected: Record<string, unknown> = {
+    id: entry.id,
+    displayName: entry.displayName,
+  };
+  if (entry.subtitle !== undefined) projected.subtitle = entry.subtitle;
+  if (entry.setupMode !== undefined) projected.setupMode = entry.setupMode;
+  if (entry.setupHint !== undefined) projected.setupHint = entry.setupHint;
+  if (entry.envVar !== undefined) projected.envVar = entry.envVar;
+  if (entry.apiKeyPlaceholder !== undefined)
+    projected.apiKeyPlaceholder = entry.apiKeyPlaceholder;
+  if (entry.credentialsGuide !== undefined)
+    projected.credentialsGuide = entry.credentialsGuide;
+  if (entry.supportsManagedAuth !== undefined)
+    projected.supportsManagedAuth = entry.supportsManagedAuth;
+  projected.defaultModel = entry.defaultModel;
+  projected.models = entry.models.map(projectModel);
+  // NOTE: `apiKeyUrl` intentionally omitted — clients use
+  // `credentialsGuide.url` instead. Daemon callers still read it from
+  // PROVIDER_CATALOG directly.
+  return projected;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const isCheck = process.argv.includes("--check");
+
+  const generated = {
+    version: CLIENT_CATALOG_VERSION,
+    providers: PROVIDER_CATALOG.map(projectProvider),
+  };
+
+  // 2-space indent + trailing newline matches the existing format.
+  const output = JSON.stringify(generated, null, 2) + "\n";
+
+  if (isCheck) {
+    let anyStale = false;
+    for (const path of OUTPUT_PATHS) {
+      const rel = relative(ROOT, path);
+      let existing: string;
+      try {
+        existing = await readFile(path, "utf-8");
+      } catch {
+        console.error(`${rel} does not exist. Run: bun run sync:llm-catalog`);
+        anyStale = true;
+        continue;
+      }
+      if (existing !== output) {
+        console.error(`${rel} is stale. Run: bun run sync:llm-catalog`);
+        anyStale = true;
+        continue;
+      }
+      console.log(`${rel} is up to date.`);
+    }
+    if (anyStale) process.exit(1);
+    return;
+  }
+
+  for (const path of OUTPUT_PATHS) {
+    await writeFile(path, output);
+    console.log(`Generated ${relative(ROOT, path)}`);
+  }
+
+  const modelCount = generated.providers.reduce(
+    (n, p) => n + (p.models as unknown[]).length,
+    0,
+  );
+  console.log(
+    `  ${generated.providers.length} providers, ${modelCount} models`,
+  );
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/sync-web-search-catalog.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env bun
+/**
+ * Generate `meta/web-search-provider-catalog.json` from the canonical
+ * `SEARCH_PROVIDER_CATALOG` in
+ * `assistant/src/providers/search-provider-catalog.ts`.
+ *
+ * Companion to `sync-llm-catalog.ts`. The meta JSON is the cross-package
+ * artifact consumed by:
+ *
+ *   - `cli/src/__tests__/search-provider-env-var-parity.test.ts`
+ *     (drift guard for the CLI's hardcoded env-var mirror).
+ *   - Downstream `vellum-assistant-platform/web/src/lib/generated/
+ *     web-search-provider-catalog.json` (manually sync'd today; scheduled
+ *     sync workflow is a planned follow-up).
+ *
+ * Usage:
+ *   cd assistant && bun run scripts/sync-web-search-catalog.ts
+ *   cd assistant && bun run sync:web-search-catalog              # via npm script
+ *   cd assistant && bun run sync:web-search-catalog -- --check   # CI: fail if stale
+ */
+
+import { readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+import {
+  SEARCH_PROVIDER_CATALOG,
+  type SearchProviderCatalogEntry,
+} from "../src/providers/search-provider-catalog.js";
+
+const ROOT = resolve(import.meta.dir, "../..");
+const OUTPUT_PATH = join(ROOT, "meta/web-search-provider-catalog.json");
+
+/**
+ * Bumped when the *shape* of the client catalog JSON changes in a way
+ * downstream consumers must opt into. Adding optional fields that older
+ * consumers can ignore does NOT require a bump.
+ */
+const CLIENT_CATALOG_VERSION = 1;
+
+function projectProvider(
+  entry: SearchProviderCatalogEntry,
+): Record<string, unknown> {
+  const projected: Record<string, unknown> = {
+    id: entry.id,
+    displayName: entry.displayName,
+  };
+  if (entry.displayNameLong !== undefined) {
+    projected.displayNameLong = entry.displayNameLong;
+  }
+  projected.kind = entry.kind;
+  if (entry.apiKeyPrefix !== undefined) {
+    projected.apiKeyPrefix = entry.apiKeyPrefix;
+  }
+  if (entry.envVar !== undefined) {
+    projected.envVar = entry.envVar;
+  }
+  if (entry.secretKey !== undefined) {
+    projected.secretKey = entry.secretKey;
+  }
+  if (entry.fallbackOrder !== undefined) {
+    projected.fallbackOrder = entry.fallbackOrder;
+  }
+  if (entry.privacyPolicyUrl !== undefined) {
+    projected.privacyPolicyUrl = entry.privacyPolicyUrl;
+  }
+  return projected;
+}
+
+function generate(): string {
+  return (
+    JSON.stringify(
+      {
+        version: CLIENT_CATALOG_VERSION,
+        providers: SEARCH_PROVIDER_CATALOG.map(projectProvider),
+      },
+      null,
+      2,
+    ) + "\n"
+  );
+}
+
+async function main(): Promise<void> {
+  const checkMode = process.argv.includes("--check");
+  const next = generate();
+
+  if (checkMode) {
+    let current = "";
+    try {
+      current = await readFile(OUTPUT_PATH, "utf8");
+    } catch {
+      // File doesn't exist yet — treat as stale.
+    }
+    if (current !== next) {
+      console.error(
+        `\n${OUTPUT_PATH} is out of sync with SEARCH_PROVIDER_CATALOG.\n` +
+          `Run: cd assistant && bun run sync:web-search-catalog\n`,
+      );
+      process.exit(1);
+    }
+    return;
+  }
+
+  await writeFile(OUTPUT_PATH, next, "utf8");
+  console.log(`Wrote ${OUTPUT_PATH}`);
+}
+
+await main();

package/src/__tests__/actor-trust-resolver-address-fallback.test.ts

@@ -0,0 +1,169 @@
+/**
+ * Tests for the address-fallback path in resolveActorTrust.
+ *
+ * Phone channels registered by the inbound name-capture flow have `address`
+ * set (E.164) but `externalUserId` = NULL until DTMF verification completes.
+ * The primary `findContactByChannelExternalId` lookup misses these channels,
+ * which historically caused the relay router to fall into the name-capture
+ * ("I don't recognize this number") path instead of the unverified-caller
+ * guidance path.
+ *
+ * This suite verifies that the address-based fallback fires correctly and
+ * that the returned `memberRecord` carries the right channel/status so
+ * relay-setup-router can emit the `unverified_caller` outcome.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Logger mock (suppress output) ───────────────────────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+// ── Contact store stubs — filled in per test ─────────────────────────────────
+let _byExternalId: ReturnType<
+  typeof import("../contacts/contact-store.js")["findContactByChannelExternalId"]
+> = null;
+let _byAddress: ReturnType<
+  typeof import("../contacts/contact-store.js")["findContactByAddress"]
+> = null;
+let _guardian: ReturnType<
+  typeof import("../contacts/contact-store.js")["findGuardianForChannel"]
+> = null;
+
+mock.module("../contacts/contact-store.js", () => ({
+  findContactByChannelExternalId: (_type: string, _id: string) => _byExternalId,
+  findContactByAddress: (_type: string, _addr: string) => _byAddress,
+  findGuardianForChannel: (_channel: string) => _guardian,
+}));
+
+// ── Real import after mocks ───────────────────────────────────────────────────
+import type { ContactWithChannels } from "../contacts/types.js";
+import { resolveActorTrust } from "../runtime/actor-trust-resolver.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+const PHONE = "+15559871234";
+
+function makeContact(
+  role: "guardian" | "contact" = "contact",
+  status: "unverified" | "active" = "unverified",
+  externalUserId: string | null = null,
+): ContactWithChannels {
+  const channelId = "ch-test";
+  return {
+    id: "contact-test",
+    displayName: "Patrick Test",
+    role,
+    principalId: null,
+    notes: null,
+    lastInteraction: null,
+    interactionCount: 0,
+    contactType: "human" as const,
+    userFile: null,
+    createdAt: 0,
+    updatedAt: 0,
+    channels: [
+      {
+        id: channelId,
+        contactId: "contact-test",
+        type: "phone",
+        address: PHONE.toLowerCase(),
+        externalUserId,
+        externalChatId: null,
+        isPrimary: true,
+        status,
+        policy: "allow",
+        verifiedAt: null,
+        verifiedVia: null,
+        revokedReason: null,
+        blockedReason: null,
+        interactionCount: 0,
+        lastInteraction: null,
+        lastSeenAt: null,
+        inviteId: null,
+        createdAt: 0,
+        updatedAt: 0,
+      },
+    ],
+  };
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("resolveActorTrust — address fallback", () => {
+  beforeEach(() => {
+    _byExternalId = null;
+    _byAddress = null;
+    _guardian = null;
+  });
+
+  test("finds unverified channel via address when externalUserId is null", () => {
+    // Simulate a contact registered by name-capture: address set, externalUserId null.
+    _byAddress = makeContact("contact", "unverified", null);
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord).not.toBeNull();
+    expect(result.memberRecord?.contact.displayName).toBe("Patrick Test");
+    expect(result.memberRecord?.channel.status).toBe("unverified");
+    // trustClass is 'unknown' for an unverified member (correct — not yet active)
+    expect(result.trustClass).toBe("unknown");
+  });
+
+  test("externalUserId path takes priority over address path", () => {
+    // Both lookups return a contact; the externalUserId one should win.
+    const primaryContact = makeContact("contact", "active", PHONE);
+    const addressContact = makeContact("contact", "unverified", null);
+    _byExternalId = primaryContact;
+    _byAddress = addressContact;
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord?.channel.status).toBe("active");
+    expect(result.memberRecord?.channel.externalUserId).toBe(PHONE);
+  });
+
+  test("returns null memberRecord when neither lookup finds the number", () => {
+    _byExternalId = null;
+    _byAddress = null;
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord).toBeNull();
+    expect(result.trustClass).toBe("unknown");
+  });
+
+  test("address-found active channel elevates trust to trusted_contact", () => {
+    // An active channel found via address (e.g. after manual verify without externalUserId set)
+    // should still yield trusted_contact trust class.
+    _byAddress = makeContact("contact", "active", null);
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord).not.toBeNull();
+    expect(result.memberRecord?.channel.status).toBe("active");
+    expect(result.trustClass).toBe("trusted_contact");
+  });
+});

package/src/__tests__/agent-loop-override-profile.test.ts

@@ -256,11 +256,36 @@ const anthropicStub = { name: "anthropic" };
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => anthropicStub,
+  listProviders: () => ["anthropic"],
+  initializeProviders: () => {},
+  resolveProviderFromConnection: async () => anthropicStub,
+}));
+
+// Connection-aware resolver path: satisfy
+// `tryResolveProviderForConnectionName` lookups so resolveDefaultProvider
+// returns a usable provider for the inline `anthropic-conn` fixture.
+mock.module("../providers/inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) => ({
+    id: 1,
+    name,
+    provider: "anthropic",
+    auth_strategy: "user_managed_credential",
+    credential_alias: null,
+    metadata_json: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  }),
 }));
 
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
-    llm: { default: { provider: "anthropic", model: "claude-opus-4-7" } },
+    llm: {
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        provider_connection: "anthropic-conn",
+      },
+    },
     rateLimit: { maxRequestsPerMinute: 0 },
   }),
 }));