@vellumai/assistant 0.11.9-staging.1 → 0.11.9-staging.2

package/package.json

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

package/src/__tests__/gemini-provider.test.ts

@@ -467,6 +467,52 @@ describe("GeminiProvider", () => {
     });
   });
 
+  test("3.8 Flash: disabled maps to the LOW floor, not MINIMAL", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    const flash38Provider = new GeminiProvider(
+      "test-api-key",
+      "gemini-3.8-flash",
+    );
+    await flash38Provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      { config: { thinking: { type: "disabled" } } },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "LOW",
+      includeThoughts: false,
+    });
+  });
+
+  test("3.8 Flash: an explicit minimal level is clamped up to LOW", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    const flash38Provider = new GeminiProvider(
+      "test-api-key",
+      "models/gemini-3.8-flash",
+    );
+    await flash38Provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      {
+        config: {
+          thinking: {
+            type: "adaptive",
+            level: "minimal",
+            streamThinking: false,
+          },
+        },
+      },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "LOW",
+      includeThoughts: false,
+    });
+  });
+
   test("Pro: a supported explicit level passes through unchanged", async () => {
     fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
 

package/src/__tests__/pricing.test.ts

@@ -224,6 +224,17 @@ describe("resolvePricing", () => {
       );
     });
 
+    test("returns priced for gemini-3.8-flash", () => {
+      const result = resolvePricing(
+        "gemini",
+        "gemini-3.8-flash",
+        1_000_000,
+        1_000_000,
+      );
+      expect(result.pricingStatus).toBe("priced");
+      expect(result.estimatedCostUsd).toBe(1.5 + 7.5);
+    });
+
     test("returns priced for gemini-3-flash-preview", () => {
       const result = resolvePricing(
         "gemini",

package/src/cli/__tests__/catalog-search-help.test.ts

@@ -58,5 +58,11 @@ describe("catalog search help for setup-intent retrieval", () => {
     expect(list?.helpText).toBeDefined();
     expect(indexed).toContain("assistant plugins search <name>");
     expect(indexed).toContain("not listed");
+    expect(channelsHelp.description).toBe(
+      "Inspect and repair messaging channels",
+    );
+    expect(channelsHelp.description.toLowerCase()).not.toContain("slack");
+    expect(channelsHelp.description.toLowerCase()).not.toContain("telegram");
+    expect(channelsHelp.description.toLowerCase()).not.toContain("email");
   });
 });

package/src/cli/commands/channels/index.help.ts

@@ -19,12 +19,11 @@ export const CHANNELS_PLUGIN_SEARCH_HINT =
 
 export const channelsHelp: CliCommandHelp = {
   name: "channels",
-  description:
-    "Inspect and repair messaging channels (slack, telegram, email, etc.)",
+  description: "Inspect and repair messaging channels",
   helpText: `
-Channels are the messaging surfaces the assistant talks over — slack,
-telegram, whatsapp, email, phone, vellum, platform, a2a. Each channel
-has a probe that reports whether it's configured and reachable.
+Channels are the messaging surfaces the assistant talks over. Built-in
+readiness probes cover slack, telegram, whatsapp, email, phone, vellum,
+platform, and a2a.
 
 ${CHANNELS_PLUGIN_SEARCH_HINT} Plugins can bundle additional channels
 from other Vellum users.

package/src/daemon/handlers/config-model.test.ts

@@ -65,6 +65,7 @@ describe("projectProviderForWire", () => {
     const wire = projectProviderForWire(gemini!);
     const modelIds = wire.models.map((model) => model.id);
     const expectedGemini3ModelIds = [
+      "gemini-3.8-flash",
       "gemini-3.7-flash",
       "gemini-3.6-flash",
       "gemini-3.5-flash",

package/src/plugins/defaults/memory/substrate/__tests__/skill-content.test.ts

@@ -119,3 +119,20 @@ describe("augmentMcpSetupDescription", () => {
     expect(out.id).toBe("mcp-setup");
   });
 });
+
+describe("SKILLS_INJECTION_CATALOG_HINT", () => {
+  test("points a missing product at plugin and skill search", async () => {
+    const { SKILLS_INJECTION_CATALOG_HINT } = await import(
+      "../skill-content.js"
+    );
+    expect(SKILLS_INJECTION_CATALOG_HINT).toContain(
+      "assistant plugins search <name>",
+    );
+    expect(SKILLS_INJECTION_CATALOG_HINT).toContain(
+      "assistant skills search <name>",
+    );
+    expect(SKILLS_INJECTION_CATALOG_HINT.toLowerCase()).toContain(
+      "currently in the workspace",
+    );
+  });
+});

package/src/plugins/defaults/memory/substrate/skill-content.ts

@@ -29,6 +29,13 @@ export const ALWAYS_CANDIDATE_CARD_CHARS = 900;
  */
 export const DEFAULT_CARD_CHARS = 500;
 
+/**
+ * One-shot line under injected skill cards. The cards list workspace skills
+ * only, so a missing product is not evidence it is unsupported.
+ */
+export const SKILLS_INJECTION_CATALOG_HINT =
+  "Injected skills are only ones currently in the workspace. Run `assistant plugins search <name>` and `assistant skills search <name>` before concluding a given integration or skill is unsupported";
+
 /**
  * Render the prose-style capability statement embedded into the unified
  * `memory_v2_concept_pages` Qdrant collection (under the `skills/<id>` slug

package/src/plugins/defaults/memory/v3/__tests__/render-injection.test.ts

@@ -36,6 +36,28 @@ describe("renderCardsBlockInner", () => {
   test("empty card list renders the empty string (no header-only block)", () => {
     expect(renderCardsBlockInner([])).toBe("");
   });
+
+  test("skill cards get a one-shot catalog hint that is not a concept card", () => {
+    const inner = renderCardsBlockInner([
+      "# Skill: telegram-setup\nSet up Telegram.",
+      "# memory/concepts/page-a.md\nhead a",
+    ]);
+    expect(inner).toContain(V3_CARDS_INJECTION_HEADER);
+    expect(inner).toContain("# Skills\n");
+    expect(inner).toContain("assistant plugins search <name>");
+    expect(inner).toContain("assistant skills search <name>");
+    expect(inner).toContain("currently in the workspace");
+    expect(inner.indexOf("# Skills")).toBeLessThan(inner.indexOf("# Skill:"));
+    expect(inner.startsWith(`${V3_CARDS_INJECTION_HEADER}\n\n# Skills\n`)).toBe(
+      true,
+    );
+  });
+
+  test("concept-only cards omit the skill catalog hint", () => {
+    const inner = renderCardsBlockInner(["# memory/concepts/page-a.md\nhead a"]);
+    expect(inner).not.toContain("# Skills\n");
+    expect(inner).not.toContain("assistant plugins search");
+  });
 });
 
 describe("renderSpotlightInner", () => {

package/src/plugins/defaults/memory/v3/prune.test.ts

@@ -190,6 +190,18 @@ describe("parseCardSections / filterPrunedCardSections", () => {
     expect(parsed.sections[1]!.text).toBe(card("page-b"));
   });
 
+  test("skill catalog hint is a non-card piece and leaves the read-affordance preamble intact", () => {
+    const mixed = renderCardsBlockInner([
+      "# Skill: telegram-setup\nSet up Telegram.",
+      card("page-a"),
+    ]);
+    const parsed = parseCardSections(mixed);
+    expect(parsed.preamble).toBe(V3_CARDS_INJECTION_HEADER);
+    expect(parsed.sections.map((s) => s.slug)).toEqual(["page-a"]);
+    expect(parsed.pieces.some((piece) => piece.kind === "other")).toBe(true);
+    expect(mixed).toContain("assistant plugins search <name>");
+  });
+
   test("no pruned slug present → returns the SAME reference (no-op)", () => {
     expect(filterPrunedCardSections(inner, new Set(["page-z"]))).toBe(inner);
     expect(filterPrunedCardSections(inner, new Set())).toBe(inner);
@@ -228,8 +240,14 @@ describe("parseCardSections / filterPrunedCardSections", () => {
     expect(parsed.sections.map((s) => s.slug)).toEqual(["page-a", "page-b"]);
     // page-a's section stops AT the capability header — it must not absorb it.
     expect(parsed.sections[0]!.text).toBe(card("page-a"));
-    expect(parsed.pieces.map((p) => p.kind)).toEqual(["card", "other", "card"]);
-    expect(parsed.pieces[1]!.text).toBe(CAPABILITY_CHUNK);
+    expect(parsed.pieces.map((p) => p.kind)).toEqual([
+      "other",
+      "card",
+      "other",
+      "card",
+    ]);
+    expect(parsed.pieces[0]!.text).toContain("assistant plugins search <name>");
+    expect(parsed.pieces[2]!.text).toBe(CAPABILITY_CHUNK);
   });
 
   test("pruning a concept card never swallows a trailing capability chunk", () => {

package/src/plugins/defaults/memory/v3/render-injection.ts

@@ -1,6 +1,10 @@
 import { wrapMemoryBlock } from "../memory-marker.js";
+import { SKILLS_INJECTION_CATALOG_HINT } from "../substrate/skill-content.js";
 import { Section, Slug } from "./types.js";
 
+/** Own `# ` chunk so prune treats the catalog hint as a non-card piece. */
+const SKILLS_CATALOG_HINT_CHUNK = `# Skills\n${SKILLS_INJECTION_CATALOG_HINT}`;
+
 /**
  * Leading instruction line of the frozen card block — byte-identical to v2's
  * `INJECTION_HEADER` (`memory/v2/injection.ts`) so the read affordance the
@@ -23,7 +27,12 @@ export function renderCardsBlockInner(cards: string[]): string {
   if (cards.length === 0) {
     return "";
   }
-  return [V3_CARDS_INJECTION_HEADER, ...cards].join("\n\n");
+  const parts = [V3_CARDS_INJECTION_HEADER];
+  if (cards.some((card) => card.startsWith("# Skill:"))) {
+    parts.push(SKILLS_CATALOG_HINT_CHUNK);
+  }
+  parts.push(...cards);
+  return parts.join("\n\n");
 }
 
 /**

package/src/providers/gemini/client.ts

@@ -121,8 +121,9 @@ function clampThinkingLevelToFloor(
  * dynamic medium-level thinking).
  *
  * - `enabled: false` maps to the model's floor (the most "off" state it
- *   allows): `"minimal"` for most models, `"low"` for Pro and Gemini 3.7
- *   Flash, which reject `"minimal"`.
+ *   allows): `"minimal"` for most models, `"low"` for models whose catalog
+ *   `thinkingFloor` is `"low"` (Pro and recent Flash IDs that reject
+ *   `"minimal"`).
  * - An explicit `level` below the floor is raised to the floor.
  * - When no `level` is pinned, Pro models get the documented default (`"high"`)
  *   because an absent level resolves to the unsupported `"minimal"` upstream;

package/src/providers/model-catalog.ts

@@ -631,6 +631,22 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Google AI Studio",
     },
     models: [
+      {
+        id: "gemini-3.8-flash",
+        displayName: "Gemini 3.8 Flash",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        thinkingFloor: "low",
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 1.5,
+          outputPer1mTokens: 7.5,
+          cacheReadPer1mTokens: 0.15,
+        },
+      },
       {
         id: "gemini-3.7-flash",
         displayName: "Gemini 3.7 Flash",