@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.3",
+  "version": "0.11.4-dev.202608190019.b94dbf2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/voice-ttft-spike.ts

@@ -8,7 +8,7 @@
  * script's `full` variants and the live session's `llmFirstDeltaMs`).
  *
  * Variants:
- *   slim-haiku    voiceFrontDecision call site (Haiku pin), slim prompt
+ *   slim-front    voiceFrontDoor call site, slim prompt
  *   slim-flash    cost-optimized profile, same slim prompt
  *   full-notools  cost-optimized, real buildSystemPrompt(), no tools
  *   full-flash    cost-optimized, real buildSystemPrompt() + full tool defs
@@ -170,8 +170,8 @@ async function main(): Promise<void> {
 
   const variants: VariantSpec[] = [
     {
-      name: "slim-haiku",
-      callSite: "voiceFrontDecision",
+      name: "slim-front",
+      callSite: "voiceFrontDoor",
       systemPrompt: () => SLIM_SYSTEM_PROMPT,
     },
     {

package/scripts/write-plugin-api-shim.ts

@@ -0,0 +1,10 @@
+import path from "node:path";
+
+import { ensurePluginApiShim } from "../src/plugins/ensure-plugin-api-shim.js";
+
+const outputDir = Bun.argv[2];
+if (!outputDir || !path.isAbsolute(outputDir)) {
+  throw new Error("An absolute plugin API shim output directory is required.");
+}
+
+await ensurePluginApiShim({ workspaceDir: outputDir });

package/src/__tests__/app-compiler.test.ts

@@ -20,6 +20,7 @@ import {
   packageName,
   resolvePackage,
 } from "../bundler/package-resolver.js";
+import { ensureBun } from "../util/bun-runtime.js";
 
 // ---------------------------------------------------------------------------
 // Shared temp directory
@@ -56,6 +57,29 @@ async function scaffold(
   return appDir;
 }
 
+/**
+ * Download `pkg` into bun's global module cache via a throwaway install.
+ *
+ * `resolvePackage` bounds its own install at INSTALL_TIMEOUT_MS (10s), which a
+ * cold global cache can exceed for a large package on a slow network. Priming
+ * first is unbounded, so the install the test measures resolves from cache and
+ * stays well inside that bound.
+ */
+async function primeBunCache(pkg: string): Promise<void> {
+  const primeDir = join(tempDir, `prime-${pkg.replaceAll(/[^a-z0-9]/gi, "-")}`);
+  await mkdir(primeDir, { recursive: true });
+  await writeFile(
+    join(primeDir, "package.json"),
+    JSON.stringify({ name: "prime-cache", private: true }),
+  );
+  const proc = Bun.spawn([await ensureBun(), "install", "--no-save", pkg], {
+    cwd: primeDir,
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+  await proc.exited;
+}
+
 const MINIMAL_HTML = `<!DOCTYPE html>
 <html>
 <head><title>Test</title></head>
@@ -466,10 +490,21 @@ describe("package-resolver", () => {
     expect(ALLOWED_PACKAGES).toContain("clsx");
   });
 
-  // `lucide` (the vanilla package) unpacks to ~29 MB, far above the resolver's
-  // size cap, so it is installed then deleted and never resolves. It also
-  // exports icon data arrays, not Preact components. Apps use inline SVG.
+  // `lucide` (the vanilla package) exports icon data arrays, not Preact
+  // components, and unpacks to ~29 MB for no benefit. Apps use inline SVG.
   test("ALLOWED_PACKAGES excludes lucide", () => {
     expect(ALLOWED_PACKAGES).not.toContain("lucide");
   });
+
+  // `chart.js` is a large allowlisted package: it must install into the shared
+  // cache and resolve so apps importing it can compile.
+  test("resolvePackage installs a large allowlisted package", async () => {
+    await primeBunCache("chart.js");
+
+    const result = await resolvePackage("chart.js");
+    expect(result).not.toBeNull();
+    expect(existsSync(join(getCacheDir(), "node_modules", "chart.js"))).toBe(
+      true,
+    );
+  }, 60_000);
 });

package/src/__tests__/app-control-flow.test.ts

@@ -140,6 +140,7 @@ function buildContext(
       guardianPrincipalId: "user-1",
     },
     sendToClient: () => {},
+    emit: () => {},
     pendingSurfaceActions: new Map(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),

package/src/__tests__/approval-routes-http.test.ts

@@ -113,7 +113,7 @@ function makeIdleSession(opts?: {
     ensureActorScopedHistory: async () => {},
     getMessages: () => [],
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
-    updateClient: () => {},
+    replayActivityState: () => {},
     setHostBrowserProxy: () => {},
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},
@@ -176,7 +176,7 @@ function makeConfirmationEmittingSession(opts?: {
     ensureActorScopedHistory: async () => {},
     getMessages: () => [],
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
-    updateClient: () => {},
+    replayActivityState: () => {},
     setHostBrowserProxy: () => {},
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},

package/src/__tests__/assistant-feature-flag-guard.test.ts

@@ -40,7 +40,10 @@ interface RegistryFlag {
   key: string;
   label: string;
   description: string;
-  defaultEnabled: boolean;
+  /** Boolean for a gate; the winning variation's name for a multivariate flag. */
+  defaultEnabled: boolean | string;
+  /** Declared variations. Present only on multivariate flags. */
+  values?: string[];
 }
 
 interface Registry {
@@ -179,8 +182,27 @@ describe("assistant feature flag guard", () => {
     const violations: string[] = [];
 
     for (const flag of assistantFlags) {
-      if (typeof flag.defaultEnabled !== "boolean") {
-        violations.push(`${flag.key}: missing or non-boolean 'defaultEnabled'`);
+      // A gate declares a boolean default. A multivariate flag declares its
+      // variations in `values` and names the winning one in `defaultEnabled`,
+      // which the resolver serves verbatim to string consumers.
+      if (flag.values === undefined) {
+        if (typeof flag.defaultEnabled !== "boolean") {
+          violations.push(
+            `${flag.key}: missing or non-boolean 'defaultEnabled'`,
+          );
+        }
+      } else if (
+        !Array.isArray(flag.values) ||
+        flag.values.length < 2 ||
+        flag.values.some((value) => typeof value !== "string")
+      ) {
+        violations.push(
+          `${flag.key}: 'values' must list at least two string variations`,
+        );
+      } else if (!flag.values.includes(flag.defaultEnabled as string)) {
+        violations.push(
+          `${flag.key}: 'defaultEnabled' must name one of the declared 'values'`,
+        );
       }
       if (
         typeof flag.description !== "string" ||

package/src/__tests__/attachments-store.test.ts

@@ -722,12 +722,6 @@ describe("validateAttachmentUpload", () => {
       expect(exeResult.error).toContain(".exe");
     }
 
-    const shResult = validateAttachmentUpload("script.sh", "text/plain");
-    expect(shResult.ok).toBe(false);
-    if (!shResult.ok) {
-      expect(shResult.error).toContain(".sh");
-    }
-
     const isoResult = validateAttachmentUpload(
       "disk.iso",
       "application/octet-stream",
@@ -738,6 +732,24 @@ describe("validateAttachmentUpload", () => {
     }
   });
 
+  test("accepts shell scripts as text attachments", () => {
+    expect(validateAttachmentUpload("script.sh", "text/plain").ok).toBe(true);
+    expect(validateAttachmentUpload("script.SH", "text/plain").ok).toBe(true);
+    expect(
+      validateAttachmentUpload("setup.sh", "application/x-sh").ok,
+    ).toBe(true);
+    expect(
+      validateAttachmentUpload("run.sh", "application/x-shellscript").ok,
+    ).toBe(true);
+    expect(validateAttachmentUpload("run.sh", "text/x-sh").ok).toBe(true);
+    expect(validateAttachmentUpload("run.sh", "text/x-shellscript").ok).toBe(
+      true,
+    );
+    expect(
+      validateAttachmentUpload("run.sh", "application/octet-stream").ok,
+    ).toBe(true);
+  });
+
   test("rejects dangerous extensions regardless of claimed MIME type", () => {
     // .exe disguised as image/png
     const result = validateAttachmentUpload("payload.exe", "image/png");
@@ -748,7 +760,9 @@ describe("validateAttachmentUpload", () => {
     expect(
       validateAttachmentUpload("PROGRAM.EXE", "application/octet-stream").ok,
     ).toBe(false);
-    expect(validateAttachmentUpload("script.SH", "text/plain").ok).toBe(false);
+    expect(validateAttachmentUpload("INSTALL.DMG", "application/octet-stream").ok).toBe(
+      false,
+    );
   });
 
   test("rejects unsupported MIME types", () => {
@@ -815,11 +829,6 @@ describe("validateAttachmentUpload", () => {
         trustedSource: true,
       }).ok,
     ).toBe(true);
-    expect(
-      validateAttachmentUpload("build.sh", "text/plain", {
-        trustedSource: true,
-      }).ok,
-    ).toBe(true);
   });
 
   test("trustedSource: false keeps strict validation", () => {

package/src/__tests__/byok-default-profile-ensure.test.ts

@@ -278,13 +278,30 @@ describe("ensureByokDefaultProfiles", () => {
     ["openrouter", "quality-optimized", "anthropic/claude-opus-4.8"],
     ["gemini", "cost-optimized", "gemini-3.1-flash-lite-preview"],
     ["openai", "cost-optimized", "gpt-5.4-nano"],
+    ["openai", "balanced", "gpt-5.4-mini"],
+    ["openai", "quality-optimized", "gpt-5.4"],
     ["fireworks", "balanced", "accounts/fireworks/models/kimi-k2p5"],
     ["fireworks", "balanced", "accounts/fireworks/models/kimi-k2p6"],
+    [
+      "fireworks",
+      "balanced",
+      "accounts/fireworks/models/deepseek-v4-flash-0731",
+    ],
     [
       "fireworks",
       "quality-optimized",
       "accounts/fireworks/models/deepseek-v4-flash",
     ],
+    [
+      "fireworks",
+      "quality-optimized",
+      "accounts/fireworks/models/deepseek-v4-flash-0731",
+    ],
+    [
+      "fireworks",
+      "cost-optimized",
+      "accounts/fireworks/models/deepseek-v4-flash",
+    ],
   ] as const)(
     "a historical intent-era copy converts (%s %s pinned to %s)",
     (provider, key, model) => {

package/src/__tests__/call-setup-flow-name-capture.test.ts

@@ -360,7 +360,6 @@ describe("CallSetupFlow name capture", () => {
     ).toEqual({ from: PHONE_NUMBER, callerName: CALLER_NAME });
     expect(f.notifyCalls).toEqual([
       {
-        canonicalAssistantId: "self",
         sourceChannel: "phone",
         conversationExternalId: PHONE_NUMBER,
         actorExternalId: PHONE_NUMBER,

package/src/__tests__/call-site-routing-provider.test.ts

@@ -67,7 +67,7 @@ function makeConnectionHook(
   byConnection: Record<string, Provider>,
 ): (
   connectionName: string,
-  expectedProvider: string,
+  expectedProvider: string | undefined,
 ) => Promise<Provider | null> {
   return async (connectionName, _expectedProvider) =>
     byConnection[connectionName] ?? null;

package/src/__tests__/channel-availability-routes.test.ts

@@ -57,6 +57,8 @@ const handler = ROUTES[0]!.handler;
 
 interface ChannelEntry {
   id: string;
+  /** `default` here, `plugin:<name>` for a channel a plugin brings. */
+  source: string;
   label: string;
   subtitle: string;
   icon: string;
@@ -173,10 +175,21 @@ describe("channels/available", () => {
     for (const channel of result.channels) {
       const expected = (CHANNEL_METADATA as any)[channel.id];
       expect(expected).toBeDefined();
-      expect(channel).toEqual(expected);
+      // Plus `source`, which the metadata does not carry: it says who
+      // contributes the row, and every row here comes from the assistant.
+      expect(channel).toEqual({ ...expected, source: "default" });
     }
   });
 
+  test("marks every channel the assistant ships as its own", async () => {
+    // The base list is what a client compares a plugin-contributed row
+    // against, so the marker has to be present rather than implied by an
+    // absent field.
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.every((c) => c.source === "default")).toBe(true);
+  });
+
   test("email metadata: not verification-capable, mail icon", async () => {
     mockEmailAddressesResponse = {
       ok: true,

package/src/__tests__/channel-capabilities-dedupe.test.ts

@@ -0,0 +1,214 @@
+/**
+ * `<channel_capabilities>` must not accumulate one copy per turn, and
+ * deduplicating it must not disturb the cross-turn byte-identity that prompt
+ * caching depends on (see `prompt-cache-cross-turn-stability.test.ts`, which
+ * owns that invariant end to end).
+ */
+import { describe, expect, test } from "bun:test";
+
+import {
+  dedupeChannelCapabilityBlocks,
+  preModelCallSanitize,
+} from "../context/outbound-sanitize.js";
+import type { Message } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Fixtures, shaped like what runtime injection actually produces: the block is
+// its OWN text content block, prepended to the turn-starting user message by
+// `injectChannelCapabilityContext`, and then frozen into history.
+// ---------------------------------------------------------------------------
+
+const slackCapabilities = (dynamicUi = false): string =>
+  [
+    "<channel_capabilities>",
+    "channel: slack",
+    "dashboard_capable: false",
+    `supports_dynamic_ui: ${dynamicUi}`,
+    "supports_voice_input: false",
+    "",
+    "CHANNEL CONSTRAINTS:",
+    "- Do NOT reference the dashboard UI, settings panels, or visual preference pickers.",
+    '- Do NOT use app_create. Only use ui_show/ui_update for card surfaces with template: "task_progress"; present all other information as text.',
+    "- Present information as well-formatted text instead of dynamic UI.",
+    "</channel_capabilities>",
+  ].join("\n");
+
+const CAPS = slackCapabilities();
+
+const turnContextBlock = (turn: number): string =>
+  [
+    "<turn_context>",
+    `current_time: 2026-05-21 (Thursday) 10:${String(turn).padStart(2, "0")}:00 -05:00 (America/Chicago)`,
+    "interface: slack",
+    "trust_class: guardian",
+    "</turn_context>",
+  ].join("\n");
+
+const userTurn = (turn: number, caps: string = CAPS): Message => ({
+  role: "user",
+  content: [
+    { type: "text", text: turnContextBlock(turn) },
+    { type: "text", text: caps },
+    { type: "text", text: `User message ${turn}.` },
+  ],
+});
+
+const assistantTurn = (turn: number): Message => ({
+  role: "assistant",
+  content: [{ type: "text", text: `Reply ${turn}.` }],
+});
+
+/** An N-turn conversation, every user row carrying its own injected copy. */
+const conversation = (turns: number): Message[] => {
+  const messages: Message[] = [];
+  for (let turn = 1; turn <= turns; turn++) {
+    messages.push(userTurn(turn));
+    if (turn < turns) {
+      messages.push(assistantTurn(turn));
+    }
+  }
+  return messages;
+};
+
+const allText = (messages: Message[]): string =>
+  messages
+    .flatMap((m) =>
+      m.content.filter((b) => b.type === "text").map((b) => b.text),
+    )
+    .join("\n");
+
+const countOccurrences = (haystack: string, needle: string): number =>
+  haystack.split(needle).length - 1;
+
+// ---------------------------------------------------------------------------
+
+describe("<channel_capabilities> does not accumulate across a conversation", () => {
+  test("a 50-turn conversation carries exactly one copy", () => {
+    const raw = conversation(50);
+    expect(countOccurrences(allText(raw), "<channel_capabilities>")).toBe(50);
+
+    const text = allText(preModelCallSanitize(raw));
+    expect(countOccurrences(text, "<channel_capabilities>")).toBe(1);
+    expect(countOccurrences(text, "CHANNEL CONSTRAINTS:")).toBe(1);
+  });
+
+  test("the surviving copy is the first one, unmodified", () => {
+    const sanitized = preModelCallSanitize(conversation(6));
+    expect(sanitized[0].content).toEqual(conversation(6)[0].content);
+    expect(allText([sanitized[2]])).not.toContain("<channel_capabilities>");
+  });
+
+  test("outbound size stops growing with the repeated block", () => {
+    const rawGrowth =
+      allText(conversation(45)).length - allText(conversation(5)).length;
+    const sanitizedGrowth =
+      allText(preModelCallSanitize(conversation(45))).length -
+      allText(preModelCallSanitize(conversation(5))).length;
+
+    // Every extra raw turn pays for a full copy of the block; the deduplicated
+    // projection pays nothing for it.
+    expect((rawGrowth - sanitizedGrowth) / 40).toBeGreaterThanOrEqual(
+      CAPS.length,
+    );
+  });
+
+  test("everything else on the row is untouched", () => {
+    const sanitized = preModelCallSanitize(conversation(4));
+    // `<turn_context>` is deliberately left alone: it carries a fresh
+    // timestamp each turn and historical copies are read back by the
+    // compactor's tail resolution.
+    expect(countOccurrences(allText(sanitized), "<turn_context>")).toBe(4);
+    // The dropped block is the only thing that goes: the row keeps its
+    // `<turn_context>` and the user's own text, in order.
+    expect(sanitized[6].content).toEqual([
+      { type: "text", text: turnContextBlock(4) },
+      { type: "text", text: "User message 4." },
+    ]);
+  });
+});
+
+describe("cross-turn byte stability", () => {
+  test("a message renders identically no matter how many turns follow it", () => {
+    // The prompt cache is only readable when turn N's messages recur
+    // byte-identically at the same index in turn N+1. Deduplication must
+    // therefore depend only on what sits ABOVE a message, never on how far it
+    // is from the end.
+    const turn2 = preModelCallSanitize(conversation(2));
+    const turn20 = preModelCallSanitize(conversation(20));
+
+    turn2.forEach((message, index) => {
+      expect(JSON.stringify(turn20[index])).toBe(JSON.stringify(message));
+    });
+  });
+
+  test("the turn-starting message is not treated specially", () => {
+    const sanitized = preModelCallSanitize(conversation(3));
+    const turnStart = sanitized[sanitized.length - 1];
+    // Turn 3 opened this turn and still drops its duplicate copy, which is
+    // exactly what keeps it stable once turn 4 arrives.
+    expect(allText([turnStart])).not.toContain("<channel_capabilities>");
+  });
+
+  test("is idempotent", () => {
+    const once = preModelCallSanitize(conversation(6));
+    expect(preModelCallSanitize(once)).toEqual(once);
+  });
+});
+
+describe("changes and safety", () => {
+  test("capabilities that actually change mid-conversation are kept", () => {
+    const changed = slackCapabilities(true);
+    const history: Message[] = [
+      userTurn(1),
+      assistantTurn(1),
+      userTurn(2),
+      assistantTurn(2),
+      userTurn(3, changed),
+      assistantTurn(3),
+      userTurn(4, changed),
+    ];
+
+    const sanitized = dedupeChannelCapabilityBlocks(history);
+    const text = allText(sanitized);
+    expect(countOccurrences(text, "<channel_capabilities>")).toBe(2);
+    expect(text).toContain("supports_dynamic_ui: false");
+    expect(text).toContain("supports_dynamic_ui: true");
+    // Turn 2 and turn 4 are the repeats and are the ones that go.
+    expect(allText([sanitized[2]])).not.toContain("<channel_capabilities>");
+    expect(allText([sanitized[6]])).not.toContain("<channel_capabilities>");
+  });
+
+  test("a conversation with a single copy is returned untouched", () => {
+    const history = conversation(1);
+    expect(dedupeChannelCapabilityBlocks(history)).toBe(history);
+  });
+
+  test("user-authored text that merely mentions the tag is left alone", () => {
+    const authored =
+      "why does <channel_capabilities> say dashboard_capable: false?";
+    const history: Message[] = [
+      { role: "user", content: [{ type: "text", text: authored }] },
+      assistantTurn(1),
+      { role: "user", content: [{ type: "text", text: authored }] },
+    ];
+
+    expect(dedupeChannelCapabilityBlocks(history)).toBe(history);
+  });
+
+  test("a user row made only of the block is never emptied or dropped", () => {
+    const history: Message[] = [
+      userTurn(1),
+      assistantTurn(1),
+      { role: "user", content: [{ type: "text", text: CAPS }] },
+      assistantTurn(2),
+      userTurn(3),
+    ];
+
+    const sanitized = dedupeChannelCapabilityBlocks(history);
+    expect(sanitized).toHaveLength(5);
+    expect(sanitized[2].content).toEqual(history[2].content);
+    // The all-block row is retained, so it becomes the baseline the later
+    // duplicate is measured against and turn 3 still drops.
+    expect(allText([sanitized[4]])).not.toContain("<channel_capabilities>");
+  });
+});

package/src/__tests__/channel-delivery-store.test.ts

@@ -504,23 +504,23 @@ describe("channel-delivery-store", () => {
     expect(r1.conversationId).not.toBe(r2.conversationId);
   });
 
-  test("same chat/channel but different assistantId uses different conversations", () => {
-    const r1 = recordInbound("telegram", "chat-1", "msg-1", {
-      assistantId: "asst-A",
-    });
-    const r2 = recordInbound("telegram", "chat-1", "msg-2", {
-      assistantId: "asst-B",
-    });
+  test("the same chat keeps the same conversation", () => {
+    const r1 = recordInbound("telegram", "chat-1", "msg-1");
+    const r2 = recordInbound("telegram", "chat-1", "msg-2");
 
-    expect(r1.conversationId).not.toBe(r2.conversationId);
+    expect(r1.conversationId).toBe(r2.conversationId);
   });
 
-  test("no assistantId defaults to self-scoped key", () => {
-    const r1 = recordInbound("telegram", "chat-1", "msg-1");
-    const r2 = recordInbound("telegram", "chat-1", "msg-2", {
-      assistantId: "self",
-    });
-    expect(r1.conversationId).toBe(r2.conversationId);
+  test("binds under the self-scoped key", () => {
+    // The prefix is a stored format, not an internal detail. It reads like a
+    // leftover of the assistant id that used to be interpolated into it, so
+    // pin it: rows already written under `asst:self:` stop resolving if a
+    // later tidy-up drops it.
+    const { conversationId } = recordInbound("telegram", "chat-1", "msg-1");
+
+    expect(
+      getConversationByKey("asst:self:telegram:chat-1")?.conversationId,
+    ).toBe(conversationId);
   });
 
   test("external bindings allow multiple Slack thread anchors per channel", () => {

package/src/__tests__/channel-inbound-disk-pressure.test.ts

@@ -250,7 +250,7 @@ describe("channel inbound disk pressure gate", () => {
 
     expect(body).toMatchObject({
       accepted: true,
-      duplicate: false,
+      reaction: "dropped_disk_pressure",
       diskPressure: "blocked",
       reason: "trusted-contact",
     });
@@ -268,9 +268,9 @@ describe("channel inbound disk pressure gate", () => {
         eq(channelInboundEvents.externalMessageId, "slack-reaction-blocked"),
       )
       .get();
-    expect(event?.processingStatus).toBe("processed");
-    expect(event?.messageId).toBeNull();
-    expect(event?.rawPayload).toBeNull();
+    // A blocked reaction writes nothing at all: it is dropped before the
+    // reacted message is resolved, so no event row is opened either.
+    expect(event).toBeUndefined();
     expect(db.select().from(messages).all()).toHaveLength(0);
   });
 

package/src/__tests__/channel-setup-panel-ack.test.ts

@@ -28,7 +28,7 @@ function makeContext(
 ): Conversation {
   return asConversation({
     conversationId: "session-1",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,