@vellumai/assistant 0.9.0-dev.202606191938.289c607 → 0.9.0-dev.202606192038.d313bf2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.9.0-dev.202606191938.289c607",
+  "version": "0.9.0-dev.202606192038.d313bf2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-skill-tools.test.ts

@@ -372,7 +372,9 @@ describe("projectSkillTools", () => {
       previouslyActiveSkillIds: sessionState,
     });
 
-    // Tool definitions are no longer sent to the LLM — tools are invoked via skill_execute dispatch.
+    // Tool definitions are not sent to the LLM here — tools are invoked via
+    // skill_execute dispatch; weak-open-model first-class exposure resolves
+    // defs from the registry by name in createResolveToolsCallback.
     expect(result.toolDefinitions).toEqual([]);
     expect(result.allowedToolNames).toEqual(
       new Set(["deploy_run", "deploy_status"]),

package/src/__tests__/first-class-skill-defs.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Tests for resolveFirstClassSkillDefs: weak open models get loaded skill tools
+ * exposed first-class (resolved from the registry by name), capable models do
+ * not, and the turn allowlist still gates which defs are included.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { resolveFirstClassSkillDefs } from "../daemon/conversation-tool-setup.js";
+import { RiskLevel } from "../permissions/types.js";
+import { registerSkillTools, unregisterSkillTools } from "../tools/registry.js";
+import type { Tool } from "../tools/types.js";
+
+const MINIMAX = "accounts/fireworks/models/minimax-m3";
+const CLAUDE = "claude-opus-4-8";
+
+const SKILL_ID = "first-class-test-skill";
+
+function makeSkillTool(name: string): Tool {
+  return {
+    name,
+    description: `Test tool ${name}`,
+    category: "testing",
+    defaultRiskLevel: RiskLevel.Low,
+    executionTarget: "host",
+    input_schema: {
+      type: "object",
+      properties: { content: { type: "string" } },
+      required: ["content"],
+    },
+    execute: async () => ({ content: "", isError: false }),
+  };
+}
+
+describe("resolveFirstClassSkillDefs", () => {
+  beforeEach(() => {
+    registerSkillTools(SKILL_ID, [
+      makeSkillTool("document_update"),
+      makeSkillTool("document_create"),
+    ]);
+  });
+
+  afterEach(() => {
+    unregisterSkillTools(SKILL_ID);
+  });
+
+  const allowed = new Set(["document_update", "document_create"]);
+  const turnAllowed = new Set([
+    "document_update",
+    "document_create",
+    "skill_execute",
+  ]);
+
+  test("exposes loaded skill tools for a weak open model", () => {
+    const defs = resolveFirstClassSkillDefs(allowed, turnAllowed, MINIMAX);
+    expect(defs.map((d) => d.name).sort()).toEqual([
+      "document_create",
+      "document_update",
+    ]);
+  });
+
+  test("returns nothing for a capable model", () => {
+    const defs = resolveFirstClassSkillDefs(allowed, turnAllowed, CLAUDE);
+    expect(defs).toEqual([]);
+  });
+
+  test("returns nothing when the model is unknown/absent", () => {
+    expect(resolveFirstClassSkillDefs(allowed, turnAllowed, null)).toEqual([]);
+    expect(resolveFirstClassSkillDefs(allowed, turnAllowed, undefined)).toEqual(
+      [],
+    );
+  });
+
+  test("respects the turn allowlist (subagent / exclude gating)", () => {
+    // Only document_update is allowed this turn — document_create is filtered.
+    const restricted = new Set(["document_update", "skill_execute"]);
+    const defs = resolveFirstClassSkillDefs(allowed, restricted, MINIMAX);
+    expect(defs.map((d) => d.name)).toEqual(["document_update"]);
+  });
+
+  test("skips names with no registered tool", () => {
+    const withGhost = new Set([...allowed, "not_registered"]);
+    const turn = new Set([...turnAllowed, "not_registered"]);
+    const defs = resolveFirstClassSkillDefs(withGhost, turn, MINIMAX);
+    expect(defs.map((d) => d.name).sort()).toEqual([
+      "document_create",
+      "document_update",
+    ]);
+  });
+
+  test("each exposed def carries its real scalar schema (single-escape)", () => {
+    const defs = resolveFirstClassSkillDefs(allowed, turnAllowed, MINIMAX);
+    const update = defs.find((d) => d.name === "document_update");
+    expect(update?.input_schema).toMatchObject({
+      properties: { content: { type: "string" } },
+      required: ["content"],
+    });
+  });
+});

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -12,7 +12,12 @@ let providerRefreshCalls = 0;
 const PLATFORM_BASE_URL = "https://platform.example.com";
 const ASSISTANT_API_KEY_PATH = credentialKey("vellum", "assistant_api_key");
 const PLATFORM_BASE_URL_PATH = credentialKey("vellum", "platform_base_url");
-const MANAGED_PROVIDERS = ["anthropic", "openai", "gemini", "fireworks"] as const;
+const MANAGED_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "gemini",
+  "fireworks",
+] as const;
 
 let platformBaseUrlOverride: string | undefined;
 
@@ -116,6 +121,13 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+// `handleAddSecret` fires this detached when a managed-proxy credential lands —
+// a v2-memory side effect outside this suite's provider-registry scope. Stub it
+// to a no-op; its behavior is covered by memory-v2-startup.test.ts.
+mock.module("../daemon/memory-v2-startup.js", () => ({
+  maybeReseedCapabilitiesAfterManagedCredential: async () => {},
+}));
+
 import {
   getProviderRoutingSource,
   initializeProviders,
@@ -199,7 +211,9 @@ describe("secret routes managed proxy registry sync", () => {
   test("provider API key writes notify live-conversation refresh listeners", async () => {
     await addApiKey("fireworks", "fw-key");
 
-    expect(secureKeyStore[credentialKey("fireworks", "api_key")]).toBe("fw-key");
+    expect(secureKeyStore[credentialKey("fireworks", "api_key")]).toBe(
+      "fw-key",
+    );
     expect(providerRefreshCalls).toBe(1);
 
     await deleteApiKey("fireworks");

package/src/__tests__/skill-tool-factory.test.ts

@@ -255,6 +255,24 @@ describe("createSkillTool — unknown parameter validation", () => {
     expect(result.isError).toBe(false);
   });
 
+  test("strips the harness `activity` field before validation", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({ executor: "echo.ts" }),
+      tempDir,
+      hash,
+    );
+
+    // A first-class skill-tool call may carry `activity` (the harness progress
+    // field). It must not be rejected as an unknown parameter.
+    const result = await tool.execute(
+      { query: "hello", activity: "Doing the thing" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+  });
+
   test("allows empty input when schema has no required fields", async () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(

package/src/daemon/conversation-skill-tools.ts

@@ -360,7 +360,10 @@ export function projectSkillTools(
     return { toolDefinitions: [], allowedToolNames: new Set() };
   }
 
-  // Tool definitions are no longer sent to the LLM — tools are invoked via skill_execute dispatch.
+  // Tool definitions are not sent to the LLM here — tools are invoked via
+  // skill_execute dispatch (capable models), and the weak-open-model
+  // first-class exposure resolves the registered defs from the registry in
+  // createResolveToolsCallback by name.
   const allToolNames = new Set<string>();
   const successfulEntries = new Map<string, string>();
   // Track skills already unregistered in the version-change branch so the

package/src/daemon/conversation-tool-setup.ts

@@ -19,6 +19,7 @@ import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import { advisorEnabledForProfile } from "../plugins/defaults/advisor/advisor-gate.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
+import { isWeakOpenModel } from "../providers/weak-open-model.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
 import type { ToolExecutor } from "../tools/executor.js";
@@ -681,6 +682,36 @@ export function isToolActiveForContext(
   return true;
 }
 
+/**
+ * Resolve the loaded skill tools to expose first-class to weak open models.
+ *
+ * Weak open models (MiniMax, Kimi, DeepSeek, GLM) fail to serialize the nested
+ * `skill_execute` envelope — a large value double-escaped as a JSON string in
+ * `input` — and either drop it or emit it bare. Exposing each loaded skill
+ * tool first-class lets the model fill the tool's own scalar params directly
+ * (single-escape). Capable models keep the envelope-only contract: this returns
+ * `[]` for them, so their wire surface is unchanged.
+ *
+ * Defs are resolved from the registry by name; `skillToolNames` come from the
+ * projection (skill tools only), filtered by `turnAllowed` so subagent
+ * allowlists and the tool exclude list still apply. The generic `skill_execute`
+ * tool remains available as a fallback for both model tiers.
+ */
+export function resolveFirstClassSkillDefs(
+  skillToolNames: Iterable<string>,
+  turnAllowed: ReadonlySet<string>,
+  resolvedModel: string | null | undefined,
+): ToolDefinition[] {
+  if (!isWeakOpenModel(resolvedModel)) return [];
+  const defs: ToolDefinition[] = [];
+  for (const name of skillToolNames) {
+    if (!turnAllowed.has(name)) continue;
+    const tool = getTool(name);
+    if (tool) defs.push(tool);
+  }
+  return defs;
+}
+
 /**
  * Build a resolveTools callback that merges base tool definitions with
  * dynamically projected skill tools on each agent turn. Also updates
@@ -810,7 +841,30 @@ export function createResolveToolsCallback(
     }
 
     ctx.allowedToolNames = turnAllowed;
-    const baseDefs = injectActivityField(allBaseDefs, ACTIVITY_SKIP_SET);
+
+    // Weak open models fail to serialize the nested `skill_execute` envelope
+    // (a large value double-escaped as a JSON string in `input`), so expose the
+    // loaded skill tools first-class — their scalar params are emitted directly
+    // (single-escape). The defs are resolved from the registry by name; the
+    // names are already in `turnAllowed`. The generic `skill_execute` stays
+    // available as a fallback, and capable models keep the envelope-only
+    // contract (this branch is skipped for them).
+    const resolvedModel = resolveConversationAttribution({
+      conversationId: ctx.conversationId ?? "",
+      currentCallSite: ctx.currentCallSite,
+      currentTurnOverrideProfile: ctx.currentTurnOverrideProfile,
+    })?.resolvedModel;
+    const baseDefs = [
+      ...injectActivityField(allBaseDefs, ACTIVITY_SKIP_SET),
+      ...injectActivityField(
+        resolveFirstClassSkillDefs(
+          projection.allowedToolNames,
+          turnAllowed,
+          resolvedModel,
+        ),
+        ACTIVITY_SKIP_SET,
+      ),
+    ];
 
     const config = getConfig();
     if (

package/src/daemon/memory-v2-startup.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Tests for `maybeReseedCapabilitiesAfterManagedCredential` in
+ * `memory-v2-startup.ts`.
+ *
+ * The secrets route calls this when a managed-proxy credential lands, to close
+ * the first-boot race where the daemon's startup capability seed (skills + CLI
+ * commands) runs before the platform provisions the managed embedding
+ * credential — the seed's embed throws and the synthetic capability pages never
+ * reach the page index. The reseed must fire only when v2 memory is enabled AND
+ * the managed-proxy prerequisites are now satisfied, so self-hosted / BYOK
+ * assistants (no managed proxy) are never made to run a doomed embed. When v3 is
+ * live it then enqueues a `memory_v3_maintain` job so v3 picks up the capability
+ * pages immediately instead of waiting out the 6h maintain backstop.
+ *
+ * Dynamic-imported collaborators are mocked at module scope; `bun:test`
+ * isolates `mock.module` per test file.
+ */
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "../__tests__/helpers/mock-logger.js";
+import type { AssistantConfig } from "../config/schema.js";
+
+const proxyState = { prereqs: true };
+const v3State = { live: true };
+const seedSkill = mock(async () => {});
+const seedCli = mock(async () => {});
+const enqueueJob = mock(
+  (_type: string, _payload: Record<string, unknown>) => 1,
+);
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+mock.module("../providers/platform-proxy/context.js", () => ({
+  hasManagedProxyPrereqs: async () => proxyState.prereqs,
+}));
+
+mock.module("../config/memory-v3-gate.js", () => ({
+  isMemoryV3Live: () => v3State.live,
+}));
+
+mock.module("../memory/jobs-store.js", () => ({
+  enqueueMemoryJob: enqueueJob,
+}));
+
+mock.module("../memory/v2/skill-store.js", () => ({
+  seedV2SkillEntries: seedSkill,
+}));
+
+mock.module("../memory/v2/cli-command-store.js", () => ({
+  seedV2CliCommandEntries: seedCli,
+}));
+
+const { maybeReseedCapabilitiesAfterManagedCredential } =
+  await import("./memory-v2-startup.js");
+
+function configWithV2(enabled: boolean): AssistantConfig {
+  return { memory: { v2: { enabled } } } as unknown as AssistantConfig;
+}
+
+afterEach(() => {
+  seedSkill.mockClear();
+  seedCli.mockClear();
+  enqueueJob.mockClear();
+  proxyState.prereqs = true;
+  v3State.live = true;
+});
+
+describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
+  test("reseeds both skill and CLI entries when v2 is enabled and managed-proxy prereqs are satisfied", async () => {
+    proxyState.prereqs = true;
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    expect(seedSkill).toHaveBeenCalledTimes(1);
+    expect(seedCli).toHaveBeenCalledTimes(1);
+  });
+
+  test("enqueues a v3 maintain pass after reseeding when v3 is live", async () => {
+    proxyState.prereqs = true;
+    v3State.live = true;
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    expect(enqueueJob).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
+  });
+
+  test("reseeds but does not enqueue a v3 maintain pass when v3 is not live", async () => {
+    proxyState.prereqs = true;
+    v3State.live = false;
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    expect(seedSkill).toHaveBeenCalledTimes(1);
+    expect(seedCli).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).not.toHaveBeenCalled();
+  });
+
+  test("no-op when v2 memory is disabled", async () => {
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(false));
+
+    expect(seedSkill).not.toHaveBeenCalled();
+    expect(seedCli).not.toHaveBeenCalled();
+    expect(enqueueJob).not.toHaveBeenCalled();
+  });
+
+  test("no-op for non-managed assistants (managed-proxy prereqs not satisfied)", async () => {
+    proxyState.prereqs = false;
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    expect(seedSkill).not.toHaveBeenCalled();
+    expect(seedCli).not.toHaveBeenCalled();
+    expect(enqueueJob).not.toHaveBeenCalled();
+  });
+
+  test("swallows a seed failure and still reseeds the other catalog", async () => {
+    proxyState.prereqs = true;
+    seedSkill.mockImplementationOnce(async () => {
+      throw new Error('Embedding backend "gemini" is not configured');
+    });
+
+    // Must not reject — the helper contains each seed's failure so a doomed
+    // embed never propagates back to the credential-store caller.
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    expect(seedCli).toHaveBeenCalledTimes(1);
+  });
+});

package/src/daemon/memory-v2-startup.ts

@@ -3,7 +3,8 @@
 // ---------------------------------------------------------------------------
 //
 // Small focused module that holds the gating + dispatch logic for v2-specific
-// startup work invoked from `lifecycle.ts`. Lives in its own file so the unit
+// startup work invoked from `lifecycle.ts` (and, for the post-credential
+// capability reseed, from the secrets route). Lives in its own file so the unit
 // test for the gate does not have to mount the entire lifecycle import graph.
 
 import type { AssistantConfig } from "../config/schema.js";
@@ -48,6 +49,104 @@ export function maybeSeedMemoryV2CliCommands(config: AssistantConfig): void {
     .catch((err) => log.warn({ err }, "Failed to seed v2 CLI-command entries"));
 }
 
+/**
+ * Re-seed the v2 skill and CLI-command capability entries once a managed-proxy
+ * credential lands, closing the first-boot race where the daemon's startup seed
+ * runs before the platform has provisioned the managed embedding credential.
+ *
+ * On a brand-new managed assistant the memory worker fires the startup seed
+ * (`maybeSeedMemoryV2Skills` / `maybeSeedMemoryV2CliCommands`) seconds after
+ * boot, but the platform pushes `vellum:assistant_api_key` (the credential the
+ * managed Gemini embedding backend needs) tens of seconds later. The seed's
+ * `embedWithBackend` call throws `EmbeddingBackendUnavailableError` before the
+ * skill/CLI `entries` cache is replaced, so `listSkillEntries()` /
+ * `listCliCommandEntries()` stay empty and the synthetic `skills/<id>` and
+ * `cli-commands/<name>` rows never reach the page index — leaving the v3 needle
+ * finder lane and always-candidate skill pinning with nothing to surface until
+ * the next daemon restart. Re-running the seed when the credential arrives
+ * restores the capability pages without a restart.
+ *
+ * Gated on the managed-proxy prerequisites now being satisfied (both the
+ * platform base URL and the assistant API key present) so a non-managed
+ * credential write — or a partial update that has not yet completed the pair —
+ * does not kick a doomed embed. Idempotent: `seedV2SkillEntries` /
+ * `seedV2CliCommandEntries` atomically replace their caches, so a redundant
+ * reseed (the startup seed already succeeded) is cheap and harmless. The two
+ * catalogs are independent, so they reseed in parallel. Callers invoke this
+ * detached (`void`) — it must not block the credential-store response.
+ *
+ * Reseeding alone only repopulates the shared page index — v3 reads its
+ * synthetic capability rows from the v2 stores, but its memoized lanes and its
+ * `memory_v3_sections` dense store refresh only on the v3 maintain pass (6-hour
+ * backstop). So when v3 is live, enqueue a `memory_v3_maintain` job after the
+ * reseed: its capability-reconcile stage embeds the freshly-seeded rows into the
+ * dense store and its lane-invalidation stage forces a rebuild against the now-
+ * populated index, so v3 surfaces the skill/CLI pages within seconds instead of
+ * waiting out the backstop.
+ */
+export async function maybeReseedCapabilitiesAfterManagedCredential(
+  config: AssistantConfig,
+): Promise<void> {
+  if (!config.memory.v2.enabled) return;
+
+  const { hasManagedProxyPrereqs } =
+    await import("../providers/platform-proxy/context.js");
+  if (!(await hasManagedProxyPrereqs())) return;
+
+  // Skills and CLI commands are independent catalogs sharing the unified
+  // collection — reseed in parallel, each contained so one catalog's embed
+  // failure does not abort the other or reject the detached caller.
+  const catalogs: ReadonlyArray<[label: string, seed: () => Promise<void>]> = [
+    [
+      "skill",
+      async () => {
+        const { seedV2SkillEntries } =
+          await import("../memory/v2/skill-store.js");
+        await seedV2SkillEntries({ throwOnError: true });
+      },
+    ],
+    [
+      "CLI-command",
+      async () => {
+        const { seedV2CliCommandEntries } =
+          await import("../memory/v2/cli-command-store.js");
+        await seedV2CliCommandEntries({ throwOnError: true });
+      },
+    ],
+  ];
+
+  await Promise.all(
+    catalogs.map(async ([label, seed]) => {
+      try {
+        await seed();
+        log.info(
+          `Memory v2 ${label} entries seeded after managed proxy credential update`,
+        );
+      } catch (err) {
+        log.warn(
+          { err },
+          `Failed to seed v2 ${label} entries after managed proxy credential update`,
+        );
+      }
+    }),
+  );
+
+  // The stores (and the page index) are now populated; when v3 is live, kick a
+  // maintain pass so it embeds the capability rows into `memory_v3_sections` and
+  // invalidates its lanes immediately rather than waiting out the 6h backstop.
+  const { isMemoryV3Live } = await import("../config/memory-v3-gate.js");
+  if (!isMemoryV3Live(config)) return;
+  try {
+    const { enqueueMemoryJob } = await import("../memory/jobs-store.js");
+    enqueueMemoryJob("memory_v3_maintain", {});
+  } catch (err) {
+    log.warn(
+      { err },
+      "Failed to enqueue memory_v3_maintain after managed proxy credential update",
+    );
+  }
+}
+
 /**
  * Build the v2 BM25 corpus stats (per-token document frequencies + avg doc
  * length), then re-seed the v2 skill entries so any skills written during

package/src/runtime/routes/secret-routes.ts

@@ -22,6 +22,7 @@ import {
   invalidateConfigCache,
 } from "../../config/loader.js";
 import type { CesClient } from "../../credential-execution/client.js";
+import { maybeReseedCapabilitiesAfterManagedCredential } from "../../daemon/memory-v2-startup.js";
 import { setSentryOrganizationId, setSentryUserId } from "../../instrument.js";
 import { clearEmbeddingBackendCache } from "../../memory/embedding-backend.js";
 import { syncManualTokenConnection } from "../../oauth/manual-token-connection.js";
@@ -296,6 +297,10 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
       }
       if (isManagedProxyCredential(service, field)) {
         await refreshProvidersAfterSecretChange();
+        // Close the first-boot race where the startup capability seed ran before
+        // the managed embedding credential was provisioned, leaving skill/CLI
+        // pages unseeded until restart. Detached — must not block the response.
+        void maybeReseedCapabilitiesAfterManagedCredential(getConfig());
         if (service === "vellum" && field === "assistant_api_key") {
           const generation = ++apiKeyGeneration;
           const deps = getSecretsDeps();

package/src/tools/skills/skill-tool-factory.ts

@@ -46,7 +46,12 @@ export function createSkillTool(
       context: ToolContext,
     ): Promise<ToolExecutionResult> {
       const schema = entry.input_schema as Record<string, unknown> | undefined;
-      const coercedInput = coerceStringBooleans(input, schema);
+      // `activity` is a harness field (the skill_execute envelope and
+      // first-class skill-tool exposure both surface it for progress display),
+      // never an inner tool parameter. Strip it before validation so a model
+      // that includes it on a direct call isn't rejected for an unknown field.
+      const { activity: _activity, ...rest } = input;
+      const coercedInput = coerceStringBooleans(rest, schema);
       const validation = validateInputAgainstSchema(
         entry.name,
         coercedInput,