@vellumai/assistant 0.11.8 → 0.11.9-staging.1

package/src/daemon/handlers/config-channels.ts

@@ -3,6 +3,7 @@ import { randomBytes } from "node:crypto";
 import type { GuardianDelivery } from "@vellumai/gateway-client";
 import { hashVerificationSecret } from "@vellumai/gateway-client";
 import { MarkChannelRevokedIpcResponseSchema } from "@vellumai/gateway-client/gateway-ipc-contracts";
+import { z } from "zod";
 
 import { startVerificationCall } from "../../calls/call-domain.js";
 import {
@@ -14,7 +15,7 @@ import {
   revokePendingSessions,
   updateSessionDelivery,
 } from "../../channels/gateway-verification-sessions.js";
-import type { ChannelId } from "../../channels/types.js";
+import { CHANNEL_IDS, type ChannelId } from "../../channels/types.js";
 import {
   findContactChannel,
   getChannelById,
@@ -173,9 +174,38 @@ export async function createInboundChallenge(
   };
 }
 
+/**
+ * Exactly what {@link getVerificationStatus} returns.
+ *
+ * Its own shape rather than the wide {@link ChannelVerificationSessionResult},
+ * which spans five different responses and so marks every field optional. A
+ * status caller always gets the binding verdict, and the route publishes this
+ * as its response body so clients read it from a generated type.
+ */
+export const verificationStatusResponseSchema = z.object({
+  success: z.boolean(),
+  bound: z.boolean(),
+  channel: z.enum(CHANNEL_IDS),
+  assistantId: z.string(),
+  hasPendingChallenge: z.boolean(),
+  guardianExternalUserId: z.string().optional(),
+  guardianDeliveryChatId: z.string().optional(),
+  guardianUsername: z.string().optional(),
+  guardianDisplayName: z.string().optional(),
+  verificationSessionId: z.string().optional(),
+  expiresAt: z.number().optional(),
+  nextResendAt: z.number().nullable().optional(),
+  sendCount: z.number().optional(),
+  pendingBootstrap: z.boolean().optional(),
+});
+
+export type VerificationStatusResponse = z.infer<
+  typeof verificationStatusResponseSchema
+>;
+
 export async function getVerificationStatus(
   channel?: ChannelId,
-): Promise<ChannelVerificationSessionResult> {
+): Promise<VerificationStatusResponse> {
   const resolvedAssistantId = DAEMON_INTERNAL_ASSISTANT_ID;
   const resolvedChannel = channel ?? "telegram";
 
@@ -215,7 +245,7 @@ export async function getVerificationStatus(
     findActiveSession(resolvedChannel, { verificationPurpose: "guardian" }),
   ]);
   const hasPendingChallenge = pendingSession != null;
-  const outboundFields: Record<string, unknown> = {};
+  const outboundFields: Partial<VerificationStatusResponse> = {};
   if (activeOutboundSession) {
     outboundFields.verificationSessionId = activeOutboundSession.id;
     outboundFields.expiresAt = activeOutboundSession.expiresAt;

package/src/daemon/handlers/shared.ts

@@ -15,6 +15,7 @@ import { ConfirmationDecisionSchema } from "../../api/responses/conversation-mes
 import { getConfig } from "../../config/loader.js";
 import type { LLMCallSite, Speed } from "../../config/schemas/llm.js";
 import { ipcCall as gatewayIpcCall } from "../../ipc/gateway-client.js";
+import type { ProviderMessageMetadata } from "../../messaging/provider-message-metadata.js";
 import type { SecretPromptResult } from "../../permissions/secret-prompt-types.js";
 import type { ConversationCreateType } from "../../persistence/conversation-types.js";
 import { resolveMediaSourceData } from "../../providers/media-resolve.js";
@@ -223,6 +224,14 @@ export interface ConversationCreateOptions {
    * chronological renderer to consume.
    */
   slackInbound?: SlackInboundMessageMetadata;
+  /**
+   * Neutral per-row channel envelope captured at the channel ingress
+   * boundary, the non-Slack counterpart of `slackInbound`. When present (and
+   * the turn channel matches its `source`), persistence writes it as the
+   * message's `providerMeta` metadata key so the stored row can say which
+   * external message it is, in which thread, from whom.
+   */
+  channelInbound?: ProviderMessageMetadata;
   /**
    * Conversation type for newly created conversations. When omitted,
    * defaults to `"standard"` (visible in the sidebar). Set to

package/src/daemon/port-oversized-content.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, test } from "bun:test";
+
+import { createConversation } from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  assembleUserContentBlocks,
+  offloadLinkPlan,
+  offloadOversizedText,
+  OVERSIZED_CONTENT_FILENAME_PREFIX,
+  OVERSIZED_CONTENT_NOTE,
+  oversizedContentFilename,
+} from "./port-oversized-content.js";
+
+const OVERSIZED_FILENAME_RE = /^oversized-content-[0-9a-f-]{36}\.txt$/;
+
+await initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+describe("offloadOversizedText", () => {
+  test("leaves text under the cap unchanged", async () => {
+    resetTables();
+    const conv = createConversation();
+    const result = await offloadOversizedText("hello", {
+      conversationId: conv.id,
+      conversationCreatedAt: conv.createdAt,
+    });
+    expect(result).toEqual({ text: "hello" });
+  });
+
+  test("ports over-cap text into a workspace_ref attachment", async () => {
+    resetTables();
+    const conv = createConversation();
+    const original = "x".repeat(32);
+    const result = await offloadOversizedText(
+      original,
+      {
+        conversationId: conv.id,
+        conversationCreatedAt: conv.createdAt,
+      },
+      16,
+    );
+
+    expect(result.text).toBe(OVERSIZED_CONTENT_NOTE);
+    expect(result.attachmentId).toBeDefined();
+    expect(result.filename).toMatch(OVERSIZED_FILENAME_RE);
+    expect(result.fileBlock).toMatchObject({
+      type: "file",
+      source: {
+        type: "workspace_ref",
+        media_type: "text/plain",
+        filename: result.filename,
+        attachmentId: result.attachmentId,
+      },
+    });
+    expect(JSON.stringify(result)).not.toContain(original);
+    if (result.fileBlock === undefined) {
+      throw new Error("expected an offloaded file block");
+    }
+
+    const blocks = assembleUserContentBlocks(result.text, [], result.fileBlock);
+    expect(JSON.stringify(blocks)).not.toContain(original);
+    expect(blocks[0]).toEqual({ type: "text", text: OVERSIZED_CONTENT_NOTE });
+    expect(blocks[1]).toEqual(result.fileBlock);
+  });
+
+  test("assigns a distinct generated filename per offload in one conversation", async () => {
+    resetTables();
+    const conv = createConversation();
+    const ctx = {
+      conversationId: conv.id,
+      conversationCreatedAt: conv.createdAt,
+    };
+    const first = await offloadOversizedText("a".repeat(32), ctx, 16);
+    const second = await offloadOversizedText("b".repeat(32), ctx, 16);
+
+    expect(first.filename).toMatch(OVERSIZED_FILENAME_RE);
+    expect(second.filename).toMatch(OVERSIZED_FILENAME_RE);
+    expect(first.filename).not.toBe(second.filename);
+    expect(first.filename).toContain(OVERSIZED_CONTENT_FILENAME_PREFIX);
+  });
+});
+
+describe("oversizedContentFilename", () => {
+  test("embeds the given id", () => {
+    expect(oversizedContentFilename("11111111-1111-1111-1111-111111111111")).toBe(
+      "oversized-content-11111111-1111-1111-1111-111111111111.txt",
+    );
+  });
+});
+
+describe("offloadLinkPlan", () => {
+  test("same persist and live id is linked and model-facing", () => {
+    const plan = offloadLinkPlan("att-1", "att-1");
+    expect(plan.linkIds).toEqual(["att-1"]);
+    expect([...plan.modelFacingIds]).toEqual(["att-1"]);
+  });
+
+  test("display-only persist offload is linked but not model-facing", () => {
+    const plan = offloadLinkPlan("att-display", undefined);
+    expect(plan.linkIds).toEqual(["att-display"]);
+    expect(plan.modelFacingIds.size).toBe(0);
+  });
+
+  test("distinct persist and live ids keep only live model-facing", () => {
+    const plan = offloadLinkPlan("att-display", "att-live");
+    expect(plan.linkIds).toEqual(["att-display", "att-live"]);
+    expect([...plan.modelFacingIds]).toEqual(["att-live"]);
+  });
+});

package/src/daemon/port-oversized-content.ts

@@ -0,0 +1,110 @@
+/**
+ * Move a user text payload that exceeds the provider string cap into the
+ * conversation attachment store, and leave a short note plus a workspace_ref
+ * in the message. The full text stays on disk, off the model prompt.
+ */
+
+import { randomUUID } from "node:crypto";
+
+import { createInlineAttachment } from "../persistence/attachments-store.js";
+import {
+  MAX_PROVIDER_STRING_BYTES,
+  utf8ByteLength,
+} from "../providers/content-block-size.js";
+import type { ContentBlock } from "../providers/types.js";
+
+export const OVERSIZED_CONTENT_FILENAME_PREFIX = "oversized-content";
+
+export const OVERSIZED_CONTENT_NOTE =
+  "Content exceeded the provider size limit and was saved as a workspace file.";
+
+/** Unique per offload so two oversized payloads in one conversation do not share a name. */
+export function oversizedContentFilename(id: string = randomUUID()): string {
+  return `${OVERSIZED_CONTENT_FILENAME_PREFIX}-${id}.txt`;
+}
+
+export interface PortOversizedContext {
+  conversationId: string;
+  conversationCreatedAt: number;
+}
+
+export interface OffloadOversizedTextResult {
+  text: string;
+  fileBlock?: Extract<ContentBlock, { type: "file" }>;
+  attachmentId?: string;
+  filename?: string;
+}
+
+export async function offloadOversizedText(
+  text: string,
+  ctx: PortOversizedContext,
+  maxBytes: number = MAX_PROVIDER_STRING_BYTES,
+): Promise<OffloadOversizedTextResult> {
+  if (utf8ByteLength(text) <= maxBytes) {
+    return { text };
+  }
+
+  const filename = oversizedContentFilename();
+  const stored = await createInlineAttachment(
+    ctx.conversationId,
+    ctx.conversationCreatedAt,
+    filename,
+    "text/plain",
+    Buffer.from(text, "utf8").toString("base64"),
+    { skipSizeLimit: true },
+  );
+
+  return {
+    text: OVERSIZED_CONTENT_NOTE,
+    fileBlock: {
+      type: "file",
+      source: {
+        type: "workspace_ref",
+        media_type: "text/plain",
+        attachmentId: stored.id,
+        sizeBytes: stored.sizeBytes,
+        filename,
+      },
+    },
+    attachmentId: stored.id,
+    filename,
+  };
+}
+
+/**
+ * Persist may offload a display-only copy (raw Slack, etc.) that must stay
+ * linked for GC but must not be named on the model-facing attachment list.
+ * The live offload is the only one `enrichMessageWithSourcePaths` may see.
+ */
+export function offloadLinkPlan(
+  persistAttachmentId: string | undefined,
+  liveAttachmentId: string | undefined,
+): { linkIds: string[]; modelFacingIds: ReadonlySet<string> } {
+  const linkIds = [
+    ...new Set(
+      [persistAttachmentId, liveAttachmentId].filter(
+        (id): id is string => id !== undefined,
+      ),
+    ),
+  ];
+  return {
+    linkIds,
+    modelFacingIds: new Set(liveAttachmentId ? [liveAttachmentId] : []),
+  };
+}
+
+export function assembleUserContentBlocks(
+  text: string,
+  attachmentBlocks: ContentBlock[],
+  extraFileBlock?: ContentBlock,
+): ContentBlock[] {
+  const blocks: ContentBlock[] = [];
+  if (text.trim().length > 0) {
+    blocks.push({ type: "text", text });
+  }
+  blocks.push(...attachmentBlocks);
+  if (extraFileBlock) {
+    blocks.push(extraFileBlock);
+  }
+  return blocks;
+}

package/src/daemon/process-message.ts

@@ -38,6 +38,7 @@ import {
 import { getLogger } from "../util/logger.js";
 import type { Conversation } from "./conversation.js";
 import {
+  buildProviderMetaForPersistence,
   buildSlackMetaForPersistence,
   CONVERSATION_BUSY_MESSAGE,
   serializePersistedUserMessageContent,
@@ -124,6 +125,17 @@ type ProcessMessageOptions = ConversationCreateOptions & {
    * {@link deriveIngressIdempotencyKey}).
    */
   clientMessageId?: string;
+  /**
+   * Serialized `slackMeta` reaction envelope for a Slack reaction-driven
+   * turn, stamped onto the persisted user row so it reads as a reaction to
+   * every envelope consumer. Slack-only on purpose: every other channel's
+   * reaction turn rides `channelInbound`, whose lane declines Slack while
+   * Slack writes its own envelope.
+   *
+   * TRANSITIONAL: dies when Slack joins the neutral `providerMeta`
+   * envelope; do not extend it.
+   */
+  slackReactionRowMeta?: string;
 };
 
 /**
@@ -148,6 +160,58 @@ export function deriveIngressIdempotencyKey(options?: {
   return undefined;
 }
 
+/**
+ * The transient carrier bag `persistUserMessage` strips back out of the
+ * metadata: the channel ingress envelopes threaded through options.
+ * Undefined when the turn carries neither, so non-channel turns persist no
+ * extra keys.
+ */
+function buildIngressCarrierMetadata(
+  options?: ProcessMessageOptions,
+): Record<string, unknown> | undefined {
+  if (!options?.slackInbound && !options?.channelInbound) {
+    return undefined;
+  }
+  return {
+    ...(options.slackInbound ? { slackInbound: options.slackInbound } : {}),
+    ...(options.channelInbound
+      ? { channelInbound: options.channelInbound }
+      : {}),
+  };
+}
+
+/**
+ * The metadata a server-side ingress turn persists with its user row: the
+ * transient carrier bag above, plus the pre-built `slackMeta` a Slack
+ * reaction turn stamps directly (see `slackReactionRowMeta`).
+ */
+function buildPersistMetadata(
+  options?: ProcessMessageOptions,
+): Record<string, unknown> | undefined {
+  const carrier = buildIngressCarrierMetadata(options);
+  if (!options?.slackReactionRowMeta) {
+    return carrier;
+  }
+  return { slackMeta: options.slackReactionRowMeta, ...carrier };
+}
+
+/**
+ * Layer the turn's persisted channel envelopes onto a metadata object:
+ * `slackMeta` for Slack turns, `providerMeta` for every other channel.
+ * At most one is non-null per turn.
+ */
+function withChannelEnvelopes(
+  base: Record<string, unknown>,
+  slackMeta: string | null,
+  providerMeta: string | null,
+): Record<string, unknown> {
+  return {
+    ...base,
+    ...(slackMeta ? { slackMeta } : {}),
+    ...(providerMeta ? { providerMeta } : {}),
+  };
+}
+
 function buildEventEmitter(
   observer?: (msg: AssistantEvent) => void,
 ): (msg: AssistantEvent) => void {
@@ -432,9 +496,14 @@ export async function processMessage(
   });
   const slashResult = await resolveSlash(content, slashContext);
 
+  const turnChannel = conversation.getTurnChannelContext()?.userMessageChannel;
   const slackMeta = buildSlackMetaForPersistence({
     slackInbound: options?.slackInbound,
-    turnChannel: conversation.getTurnChannelContext()?.userMessageChannel,
+    turnChannel,
+  });
+  const providerMeta = buildProviderMetaForPersistence({
+    channelInbound: options?.channelInbound,
+    turnChannel,
   });
 
   if (slashResult.kind === "unknown") {
@@ -469,9 +538,11 @@ export async function processMessage(
         : {}),
       ...(Object.keys(imageSourcePaths).length > 0 ? { imageSourcePaths } : {}),
     };
-    const userMetaWithSlack = slackMeta
-      ? { ...serverChannelMeta, slackMeta }
-      : serverChannelMeta;
+    const userMetaWithSlack = withChannelEnvelopes(
+      serverChannelMeta,
+      slackMeta,
+      providerMeta,
+    );
     const cleanMsg = await createUserMessage(content, attachments);
     const llmMsg = enrichMessageWithSourcePaths(cleanMsg, attachments);
     const persisted = await addMessage(
@@ -566,9 +637,11 @@ export async function processMessage(
           }
         : {}),
     };
-    const compactUserMeta = slackMeta
-      ? { ...compactChannelMeta, slackMeta }
-      : compactChannelMeta;
+    const compactUserMeta = withChannelEnvelopes(
+      compactChannelMeta,
+      slackMeta,
+      providerMeta,
+    );
     const cleanMsg = await createUserMessage(content, attachments);
     const persisted = await addMessage(
       conversationId,
@@ -624,9 +697,11 @@ export async function processMessage(
           }
         : {}),
     };
-    const cleanUserMeta = slackMeta
-      ? { ...cleanChannelMeta, slackMeta }
-      : cleanChannelMeta;
+    const cleanUserMeta = withChannelEnvelopes(
+      cleanChannelMeta,
+      slackMeta,
+      providerMeta,
+    );
     const cleanMsg = await createUserMessage(content, attachments);
     const persisted = await addMessage(
       conversationId,
@@ -660,9 +735,7 @@ export async function processMessage(
   const resolvedContent = slashResult.content;
 
   const requestId = uuidv7();
-  const persistMetadata = options?.slackInbound
-    ? { slackInbound: options.slackInbound }
-    : undefined;
+  const persistMetadata = buildPersistMetadata(options);
   const ingressKey = deriveIngressIdempotencyKey(options);
   const { id: messageId, deduplicated } = await conversation.persistUserMessage(
     {
@@ -743,9 +816,7 @@ export async function processMessageInBackground(
   const emitEvent = buildEventEmitter(options?.onEvent);
 
   const requestId = uuidv7();
-  const persistMetadata = options?.slackInbound
-    ? { slackInbound: options.slackInbound }
-    : undefined;
+  const persistMetadata = buildPersistMetadata(options);
   const ingressKey = deriveIngressIdempotencyKey(options);
   const { id: messageId, deduplicated } = await conversation.persistUserMessage(
     {

package/src/daemon/reaction-record.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { readSlackMetadataFromMessageMetadata } from "../messaging/providers/slack/message-metadata.js";
 import type { QueuedReactionRecord } from "./reaction-record.js";
 
 let persisted: Array<{
@@ -75,24 +76,35 @@ describe("persistReactionRecords", () => {
     expect(row.metadata?.slackMeta).toBeUndefined();
   });
 
-  test("a Slack record writes the slackMeta envelope the Slack context reads", async () => {
+  test("a Slack record writes the neutral envelope, which the Slack context reads through its Slack view", async () => {
     await persistReactionRecords("conv-1", [
       record({ channel: "slack", chatId: "C1", messageId: "1700.1" }),
     ]);
     const row = persisted[0]!;
-    expect(row.metadata?.providerMeta).toBeUndefined();
-    const slackMeta = JSON.parse(String(row.metadata?.slackMeta)) as {
+    expect(row.metadata?.slackMeta).toBeUndefined();
+    const envelope = JSON.parse(String(row.metadata?.providerMeta)) as {
       source: string;
-      channelId: string;
-      channelTs: string;
+      conversationExternalId: string;
       eventKind: string;
-      reaction: { emoji: string; targetChannelTs: string; op: string };
+      reaction: { targetMessageId: string; emoji: string; op: string };
     };
-    expect(slackMeta.source).toBe("slack");
-    expect(slackMeta.channelId).toBe("C1");
-    expect(slackMeta.channelTs).toBe("1700.1");
-    expect(slackMeta.eventKind).toBe("reaction");
-    expect(slackMeta.reaction).toEqual({
+    expect(envelope.source).toBe("slack");
+    expect(envelope.conversationExternalId).toBe("C1");
+    expect(envelope.eventKind).toBe("reaction");
+    expect(envelope.reaction).toEqual({
+      targetMessageId: "1700.1",
+      emoji: "🎉",
+      op: "added",
+    });
+    // The Slack transcript's view of the same row: the reacted message's ts
+    // stands in as `channelTs`, as the Slack envelope stores it.
+    const view = readSlackMetadataFromMessageMetadata(
+      JSON.stringify(row.metadata),
+    );
+    expect(view?.channelId).toBe("C1");
+    expect(view?.channelTs).toBe("1700.1");
+    expect(view?.eventKind).toBe("reaction");
+    expect(view?.reaction).toEqual({
       emoji: "🎉",
       targetChannelTs: "1700.1",
       op: "added",

package/src/daemon/reaction-record.ts

@@ -16,11 +16,7 @@
  * included.
  */
 import type { ChannelId } from "../channels/types.js";
-import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
-import {
-  buildNeutralReactionMeta,
-  buildSlackReactionMeta,
-} from "../messaging/reaction-envelopes.js";
+import { buildNeutralReactionMeta } from "../messaging/reaction-envelopes.js";
 import {
   addMessage,
   REACTION_MESSAGE_KIND,
@@ -58,10 +54,11 @@ export async function persistReactionRecords(
         emoji: record.emoji,
         op: record.op,
       };
-      const envelope =
-        record.channel === "slack"
-          ? { slackMeta: writeSlackMetadata(buildSlackReactionMeta(facts)) }
-          : { providerMeta: JSON.stringify(buildNeutralReactionMeta(facts)) };
+      // The assistant's own rows carry the neutral envelope on every channel;
+      // the Slack renderers read it through the envelope's Slack view.
+      const envelope = {
+        providerMeta: JSON.stringify(buildNeutralReactionMeta(facts)),
+      };
       await addMessage(conversationId, "assistant", "[reaction]", {
         metadata: {
           messageKind: REACTION_MESSAGE_KIND,

package/src/documents/document-store.ts

@@ -470,10 +470,6 @@ export type ReplaceInDocumentResult =
   | { success: true; replacements_made: number; content_changed: boolean }
   | { success: false; error: string };
 
-function escapeRegExpChars(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 /**
  * Find and replace text within a document — like sed.
  * Supports literal text and regex patterns with optional backreferences.
@@ -497,7 +493,7 @@ export function replaceInDocument(
     const flags = "g" + (options.caseSensitive === true ? "" : "i");
     const pattern = options.regex
       ? new RegExp(find, flags)
-      : new RegExp(escapeRegExpChars(find), flags);
+      : new RegExp(RegExp.escape(find), flags);
 
     const totalMatches = [...row.content.matchAll(pattern)].length;
     if (

package/src/home/conversation-starter-validation.ts

@@ -79,10 +79,6 @@ function mentionsCurrentUser(
   context: ConversationStarterValidationContext,
 ): boolean {
   return context.userReferences.some((reference) =>
-    new RegExp(`\\b${escapeRegExp(reference)}\\b`, "i").test(text),
+    new RegExp(`\\b${RegExp.escape(reference)}\\b`, "i").test(text),
   );
 }
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}