@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.0",
+  "version": "0.11.1-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/build-plugin-api.ts

@@ -69,8 +69,11 @@ function parseArgs(argv: string[]): Args {
   let buildDir = join(ASSISTANT_DIR, ".plugin-api-build");
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
-    if (arg === "--version") version = argv[++i] ?? "";
-    else if (arg === "--out") buildDir = resolve(argv[++i] ?? "");
+    if (arg === "--version") {
+      version = argv[++i] ?? "";
+    } else if (arg === "--out") {
+      buildDir = resolve(argv[++i] ?? "");
+    }
   }
   if (!version) {
     throw new Error(
@@ -184,8 +187,12 @@ function main(): void {
   const bundled: string[] = [];
   for (const name of readdirSync(vellumDir)) {
     const dir = join(vellumDir, name);
-    if (!existsSync(join(dir, "tsconfig.json"))) continue;
-    if (!existsSync(join(dir, "src"))) continue;
+    if (!existsSync(join(dir, "tsconfig.json"))) {
+      continue;
+    }
+    if (!existsSync(join(dir, "src"))) {
+      continue;
+    }
     const dest = join(vellumOverlay, name);
     if (emitContract(dir, dest)) {
       writeContractManifest(join(dir, "package.json"), dest);

package/scripts/capture-x-graphql.ts

@@ -98,8 +98,9 @@ class CDPClient {
             }
           }
         } else if (msg.method) {
-          for (const h of this.eventHandlers.get(msg.method) ?? [])
+          for (const h of this.eventHandlers.get(msg.method) ?? []) {
             h(msg.params ?? {});
+          }
         }
       };
     });
@@ -137,7 +138,9 @@ const captured: CapturedQuery[] = [];
 const seenQueries = new Set<string>();
 
 // Ensure capture directory exists
-if (!existsSync(CAPTURE_DIR)) mkdirSync(CAPTURE_DIR, { recursive: true });
+if (!existsSync(CAPTURE_DIR)) {
+  mkdirSync(CAPTURE_DIR, { recursive: true });
+}
 
 // ─── Auto-navigation steps ───────────────────────────────────────────────────
 
@@ -150,7 +153,9 @@ interface GuideStep {
 
 // Resolve the logged-in user's screen name for profile-based URLs
 async function getScreenName(): Promise<string | null> {
-  if (!navigationClient) return null;
+  if (!navigationClient) {
+    return null;
+  }
   try {
     const result = (await navigationClient.send("Runtime.evaluate", {
       expression: `
@@ -263,16 +268,22 @@ function waitForAnyQuery(
   queryNames: string[],
   timeoutMs = 15000,
 ): Promise<boolean> {
-  if (queryNames.some((q) => seenQueries.has(q))) return Promise.resolve(true);
+  if (queryNames.some((q) => seenQueries.has(q))) {
+    return Promise.resolve(true);
+  }
   return new Promise((resolve) => {
     const timer = setTimeout(() => {
-      for (const q of queryNames) queryWaiters.delete(q);
+      for (const q of queryNames) {
+        queryWaiters.delete(q);
+      }
       resolve(false);
     }, timeoutMs);
     for (const q of queryNames) {
       queryWaiters.set(q, () => {
         clearTimeout(timer);
-        for (const q2 of queryNames) queryWaiters.delete(q2);
+        for (const q2 of queryNames) {
+          queryWaiters.delete(q2);
+        }
         resolve(true);
       });
     }
@@ -297,7 +308,9 @@ for (const page of pages) {
   client.on("Network.requestWillBeSent", (params) => {
     const req = params.request as Record<string, unknown> | undefined;
     const url = (req?.url ?? params.url) as string | undefined;
-    if (!url?.includes("/i/api/graphql/")) return;
+    if (!url?.includes("/i/api/graphql/")) {
+      return;
+    }
 
     const match = url.match(/\/graphql\/([^/]+)\/([^?]+)/);
     const queryId = match?.[1] ?? "unknown";
@@ -305,7 +318,9 @@ for (const page of pages) {
     const method = (req?.method as string) ?? "GET";
 
     // Apply relevance filter
-    if (!captureAll && !RELEVANT_QUERIES.has(queryName)) return;
+    if (!captureAll && !RELEVANT_QUERIES.has(queryName)) {
+      return;
+    }
 
     let variables: unknown = undefined;
     let features: unknown = undefined;
@@ -322,17 +337,22 @@ for (const page of pages) {
       try {
         const u = new URL(url);
         const v = u.searchParams.get("variables");
-        if (v) variables = JSON.parse(v);
+        if (v) {
+          variables = JSON.parse(v);
+        }
         const f = u.searchParams.get("features");
-        if (f) features = JSON.parse(f);
+        if (f) {
+          features = JSON.parse(f);
+        }
       } catch {
         /* ignore */
       }
     }
 
     console.log(`\n>>> ${method} ${queryName} (${queryId})`);
-    if (variables)
+    if (variables) {
       console.log(`    variables: ${JSON.stringify(variables).slice(0, 200)}`);
+    }
 
     pendingRequests.set(params.requestId as string, { url, queryName });
     captured.push({
@@ -348,7 +368,9 @@ for (const page of pages) {
   client.on("Network.responseReceived", (params) => {
     const requestId = params.requestId as string;
     const pending = pendingRequests.get(requestId);
-    if (!pending) return;
+    if (!pending) {
+      return;
+    }
 
     const response = params.response as Record<string, unknown>;
     const status = response.status as number;
@@ -410,14 +432,18 @@ if (!navigationClient && pages.length > 0) {
 // ─── CDP navigation helpers ──────────────────────────────────────────────────
 
 async function navigateTo(url: string): Promise<void> {
-  if (!navigationClient) return;
+  if (!navigationClient) {
+    return;
+  }
   await navigationClient.send("Page.navigate", { url });
   // Wait for page to load
   await new Promise((r) => setTimeout(r, 3000));
 }
 
 async function clickElement(selector: string): Promise<boolean> {
-  if (!navigationClient) return false;
+  if (!navigationClient) {
+    return false;
+  }
   try {
     const result = (await navigationClient.send("Runtime.evaluate", {
       expression: `
@@ -439,7 +465,9 @@ async function clickElement(selector: string): Promise<boolean> {
 }
 
 async function scrollDown(): Promise<void> {
-  if (!navigationClient) return;
+  if (!navigationClient) {
+    return;
+  }
   try {
     await navigationClient.send("Runtime.evaluate", {
       expression: "window.scrollBy(0, 800)",
@@ -467,14 +495,18 @@ async function runAutoMode() {
     console.log(`  Detected user: @${screenName}\n`);
     // Fill in profile-based URLs
     for (const step of GUIDE_STEPS) {
-      if (step.label === "Likes")
+      if (step.label === "Likes") {
         step.url = `https://x.com/${screenName}/likes`;
-      if (step.label === "Followers")
+      }
+      if (step.label === "Followers") {
         step.url = `https://x.com/${screenName}/followers`;
-      if (step.label === "Following")
+      }
+      if (step.label === "Following") {
         step.url = `https://x.com/${screenName}/following`;
-      if (step.label === "Media")
+      }
+      if (step.label === "Media") {
         step.url = `https://x.com/${screenName}/media`;
+      }
     }
   } else {
     console.log(
@@ -553,7 +585,9 @@ function printSummary() {
   // Dedupe by queryName
   const seen = new Set<string>();
   const unique = captured.filter((q) => {
-    if (seen.has(q.queryName)) return false;
+    if (seen.has(q.queryName)) {
+      return false;
+    }
     seen.add(q.queryName);
     return true;
   });

package/scripts/generate-openapi.ts

@@ -369,7 +369,9 @@ function buildSpec(
   // Sort by path, then by method for deterministic output
   uniqueRoutes.sort((a, b) => {
     const pathCmp = a.path.localeCompare(b.path);
-    if (pathCmp !== 0) return pathCmp;
+    if (pathCmp !== 0) {
+      return pathCmp;
+    }
     return a.method.localeCompare(b.method);
   });
 
@@ -607,15 +609,17 @@ async function main() {
         );
         if (inGeneratedOnly.length) {
           console.error(`  Only in generated (missing from committed yaml):`);
-          for (const p of inGeneratedOnly.slice(0, 20))
+          for (const p of inGeneratedOnly.slice(0, 20)) {
             console.error(`    + ${p}`);
+          }
         }
         if (inExistingOnly.length) {
           console.error(
             `  Only in existing (stale entries in committed yaml):`,
           );
-          for (const p of inExistingOnly.slice(0, 20))
+          for (const p of inExistingOnly.slice(0, 20)) {
             console.error(`    - ${p}`);
+          }
         }
       }
       process.exit(1);

package/scripts/memory-inspect.ts

@@ -143,11 +143,17 @@ function showList() {
 function relativeAge(epochMs: number): string {
   const elapsed = Date.now() - epochMs;
   const mins = Math.floor(elapsed / 60_000);
-  if (mins < 60) return `${mins}m ago`;
+  if (mins < 60) {
+    return `${mins}m ago`;
+  }
   const hours = Math.floor(mins / 60);
-  if (hours < 24) return `${hours}h ago`;
+  if (hours < 24) {
+    return `${hours}h ago`;
+  }
   const days = Math.floor(hours / 24);
-  if (days <= 90) return `${days}d ago`;
+  if (days <= 90) {
+    return `${days}d ago`;
+  }
   const months = Math.floor(days / 30);
   return `${months}mo ago`;
 }
@@ -320,9 +326,12 @@ function showNode(nodeId: string) {
   console.log(
     `  Emotional: valence=${node.emotionalCharge.valence.toFixed(2)} intensity=${node.emotionalCharge.intensity.toFixed(2)} curve=${node.emotionalCharge.decayCurve}`,
   );
-  if (node.narrativeRole)
+  if (node.narrativeRole) {
     console.log(`  Narrative role: ${node.narrativeRole}`);
-  if (node.partOfStory) console.log(`  Part of story: ${node.partOfStory}`);
+  }
+  if (node.partOfStory) {
+    console.log(`  Part of story: ${node.partOfStory}`);
+  }
   console.log(`  Source conversations: ${node.sourceConversations.length}`);
   console.log(`\n  Content:\n  ${node.content}\n`);
 
@@ -520,7 +529,9 @@ async function runDecay() {
 // ---------------------------------------------------------------------------
 
 function printScoredNodes(nodes: ScoredNode[]) {
-  if (nodes.length === 0) return;
+  if (nodes.length === 0) {
+    return;
+  }
   console.log(`  Scored nodes:`);
   for (const s of nodes) {
     const b = s.scoreBreakdown;

package/scripts/sync-llm-catalog.ts

@@ -52,28 +52,40 @@ function projectModel(model: CatalogModel): Record<string, unknown> {
     id: model.id,
     displayName: model.displayName,
   };
-  if (model.contextWindowTokens !== undefined)
+  if (model.contextWindowTokens !== undefined) {
     projected.contextWindowTokens = model.contextWindowTokens;
-  if (model.maxOutputTokens !== undefined)
+  }
+  if (model.maxOutputTokens !== undefined) {
     projected.maxOutputTokens = model.maxOutputTokens;
-  if (model.defaultContextWindowTokens !== undefined)
+  }
+  if (model.defaultContextWindowTokens !== undefined) {
     projected.defaultContextWindowTokens = model.defaultContextWindowTokens;
-  if (model.longContextPricingThresholdTokens !== undefined)
+  }
+  if (model.longContextPricingThresholdTokens !== undefined) {
     projected.longContextPricingThresholdTokens =
       model.longContextPricingThresholdTokens;
-  if (model.longContextMode !== undefined)
+  }
+  if (model.longContextMode !== undefined) {
     projected.longContextMode = model.longContextMode;
-  if (model.supportsThinking !== undefined)
+  }
+  if (model.supportsThinking !== undefined) {
     projected.supportsThinking = model.supportsThinking;
-  if (model.adaptiveThinkingOnly !== undefined)
+  }
+  if (model.adaptiveThinkingOnly !== undefined) {
     projected.adaptiveThinkingOnly = model.adaptiveThinkingOnly;
-  if (model.supportsCaching !== undefined)
+  }
+  if (model.supportsCaching !== undefined) {
     projected.supportsCaching = model.supportsCaching;
-  if (model.supportsVision !== undefined)
+  }
+  if (model.supportsVision !== undefined) {
     projected.supportsVision = model.supportsVision;
-  if (model.supportsToolUse !== undefined)
+  }
+  if (model.supportsToolUse !== undefined) {
     projected.supportsToolUse = model.supportsToolUse;
-  if (model.pricing !== undefined) projected.pricing = model.pricing;
+  }
+  if (model.pricing !== undefined) {
+    projected.pricing = model.pricing;
+  }
   return projected;
 }
 
@@ -82,16 +94,27 @@ function projectProvider(entry: ProviderCatalogEntry): 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)
+  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)
+  }
+  if (entry.credentialsGuide !== undefined) {
     projected.credentialsGuide = entry.credentialsGuide;
-  if (entry.supportsPlatformAuth !== undefined)
+  }
+  if (entry.supportsPlatformAuth !== undefined) {
     projected.supportsPlatformAuth = entry.supportsPlatformAuth;
+  }
   projected.defaultModel = entry.defaultModel;
   projected.models = entry.models.map(projectModel);
   // NOTE: `apiKeyUrl` intentionally omitted — clients use
@@ -134,7 +157,9 @@ async function main() {
       }
       console.log(`${rel} is up to date.`);
     }
-    if (anyStale) process.exit(1);
+    if (anyStale) {
+      process.exit(1);
+    }
     return;
   }
 

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

@@ -108,7 +108,9 @@ async function main(): Promise<void> {
       }
       console.log(`${rel} is up to date.`);
     }
-    if (anyStale) process.exit(1);
+    if (anyStale) {
+      process.exit(1);
+    }
     return;
   }
 

package/scripts/voice-ttft-spike.ts

@@ -142,8 +142,7 @@ async function main(): Promise<void> {
   try {
     await initializeTools();
   } catch (error) {
-    toolInitError =
-      error instanceof Error ? error.message : String(error);
+    toolInitError = error instanceof Error ? error.message : String(error);
   }
   // Registry entries are definition-shaped objects (see tool-manifest.ts);
   // getDefinition exists only on some registrations. Either way this
@@ -155,7 +154,11 @@ async function main(): Promise<void> {
       };
       return typeof t.getDefinition === "function"
         ? t.getDefinition()
-        : { name: t.name, description: t.description, input_schema: t.input_schema };
+        : {
+            name: t.name,
+            description: t.description,
+            input_schema: t.input_schema,
+          };
     })
     .filter((def) => Boolean(def.name && def.input_schema));
   const fullPrompt = buildSystemPrompt();

package/src/__tests__/add-message-skip-indexing.test.ts

@@ -56,7 +56,8 @@ const LONG_TEXT =
 
 function resetTables(): void {
   const db = getDb();
-  db.run("DELETE FROM memory_segments");
+  // memory_segments and memory_jobs live on the memory connection.
+  getMemoryDb()!.run("DELETE FROM memory_segments");
   db.run("DELETE FROM messages");
   db.run("DELETE FROM conversations");
   getMemoryDb()!.run("DELETE FROM memory_jobs");
@@ -87,7 +88,7 @@ function messageRow(messageId: string) {
 }
 
 function segmentCountFor(messageId: string): number {
-  return getDb()
+  return getMemoryDb()!
     .select()
     .from(memorySegments)
     .where(eq(memorySegments.messageId, messageId))

package/src/__tests__/agent-loop-history-repair.test.ts

@@ -0,0 +1,180 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type { AgentEvent } from "../agent/loop.js";
+import { AgentLoop } from "../agent/loop.js";
+import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
+import { registerPlugin } from "../plugins/registry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+} from "../providers/types.js";
+import { textResponse } from "./helpers/mock-provider.js";
+
+/**
+ * The agent loop invokes history repair as built-in daemon logic (not a
+ * plugin): on a provider rejection whose message denotes a tool-use/tool-result
+ * pairing or ordering violation, it deep-repairs the working history and
+ * re-issues the call once per turn. These tests exercise that loop-integrated
+ * recovery; the repair transform itself is covered by `history-repair.test.ts`.
+ */
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "Hello" }],
+};
+
+// A provider whose message-ordering rejection matches `ORDERING_ERROR_PATTERNS`,
+// so the loop treats it as repairable.
+const ORDERING_REJECTION =
+  "messages: `tool_use` ids must have corresponding `tool_result` blocks";
+
+/**
+ * Provider that rejects the first `errorCount` calls with an ordering error,
+ * then returns a plain text reply. Records how many times it was called.
+ */
+function orderingRejectionProvider(errorCount: number): {
+  provider: Provider;
+  callCount: () => number;
+} {
+  let calls = 0;
+  const provider: Provider = {
+    name: "test-ordering",
+    async sendMessage(): Promise<ProviderResponse> {
+      calls += 1;
+      if (calls <= errorCount) {
+        throw new Error(ORDERING_REJECTION);
+      }
+      return textResponse("recovered");
+    },
+  };
+  return { provider, callCount: () => calls };
+}
+
+describe("agent loop — built-in history-repair recovery", () => {
+  beforeEach(() => {
+    resetPluginRegistryAndRegisterDefaults();
+  });
+
+  test("deep-repairs and retries once on a provider ordering rejection", async () => {
+    const { provider, callCount } = orderingRejectionProvider(1);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    const events: AgentEvent[] = [];
+    const { history } = await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // Initial call rejected → deep-repair → one retry that succeeded.
+    expect(callCount()).toBe(2);
+    expect(history[history.length - 1]).toEqual({
+      role: "assistant",
+      content: [{ type: "text", text: "recovered" }],
+    });
+    expect(events.some((e) => e.type === "error")).toBe(false);
+  });
+
+  test("bounds ordering-repair recovery to one attempt per turn", async () => {
+    // Provider keeps rejecting: the loop must not retry forever.
+    const { provider, callCount } = orderingRejectionProvider(Infinity);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    const events: AgentEvent[] = [];
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // Initial call + exactly one deep-repair retry, then the rejection surfaces.
+    expect(callCount()).toBe(2);
+    expect(events.some((e) => e.type === "error")).toBe(true);
+  });
+
+  test("dispatches post-model-call but lets native repair drive the ordering retry", async () => {
+    // A user hook that observes the rejection and blindly continues without
+    // repairing. It must still fire (the hook contract dispatches at every
+    // model-call outcome), but native ordering repair takes precedence, so the
+    // retry sends a repaired history rather than the hook's unrepaired continue.
+    let genericContinueFired = 0;
+    registerPlugin({
+      manifest: { name: "generic-continue", version: "0.0.1" },
+      hooks: {
+        "post-model-call": async (ctx) => {
+          if (ctx.error) {
+            genericContinueFired += 1;
+            ctx.decision = "continue";
+          }
+        },
+      },
+    });
+
+    // History with an orphan tool_use: deep repair appends a synthetic
+    // tool_result so the retry is well-formed.
+    const orphanHistory: Message[] = [
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+      {
+        role: "assistant",
+        content: [{ type: "tool_use", id: "t1", name: "noop", input: {} }],
+      },
+    ];
+
+    let calls = 0;
+    let retryMessages: Message[] | null = null;
+    const provider: Provider = {
+      name: "test-ordering",
+      async sendMessage(messages): Promise<ProviderResponse> {
+        calls += 1;
+        if (calls === 1) {
+          throw new Error(ORDERING_REJECTION);
+        }
+        retryMessages = messages;
+        return textResponse("recovered");
+      },
+    };
+
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    const events: AgentEvent[] = [];
+    await loop.run({
+      requestId: "test-request",
+      messages: orphanHistory,
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // The hook observed the rejection (contract preserved).
+    expect(genericContinueFired).toBeGreaterThanOrEqual(1);
+    // Recovery happened in exactly one retry, and that retry used the repaired
+    // history: the orphan tool_use now has a matching tool_result. If the hook's
+    // unrepaired continue had driven the retry, this block would be absent.
+    expect(calls).toBe(2);
+    const repaired: Message[] = retryMessages ?? [];
+    const hasPairedResult = repaired.some((m) =>
+      m.content.some((b) => b.type === "tool_result" && b.tool_use_id === "t1"),
+    );
+    expect(hasPairedResult).toBe(true);
+  });
+});