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

package/src/__tests__/mode-session-wire.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test";
+
+import { AssistantTextDeltaEventSchema } from "../api/events/assistant-text-delta.js";
+import { AssistantThinkingDeltaEventSchema } from "../api/events/assistant-thinking-delta.js";
+import { AssistantTurnStartEventSchema } from "../api/events/assistant-turn-start.js";
+import { GenerationHandoffEventSchema } from "../api/events/generation-handoff.js";
+import { MessageCompleteEventSchema } from "../api/events/message-complete.js";
+import { ToolResultEventSchema } from "../api/events/tool-result.js";
+import { ToolUseStartEventSchema } from "../api/events/tool-use-start.js";
+import { UserMessageEchoEventSchema } from "../api/events/user-message-echo.js";
+import {
+  ModeSessionDescriptorSchema,
+  ModeSessionSchema,
+} from "../api/mode-session.js";
+import { ConversationMessageSchema } from "../api/responses/conversation-message.js";
+import { messageMetadataSchema } from "../persistence/conversation-crud.js";
+
+const owner = { mode: "browser", id: "session-123" } as const;
+
+describe("mode session wire contract", () => {
+  test("accepts canonical membership on history and row-boundary events", () => {
+    expect(ModeSessionSchema.parse(owner)).toEqual(owner);
+    expect(
+      ConversationMessageSchema.parse({
+        id: "message-123",
+        role: "assistant",
+        timestamp: new Date(0).toISOString(),
+        attachments: [],
+        contentBlocks: [],
+        modeSession: owner,
+        modeSessionActivity: { firstAt: 100, lastAt: 150 },
+      }).modeSession,
+    ).toEqual(owner);
+
+    const boundaryEvents = [
+      UserMessageEchoEventSchema.parse({
+        type: "user_message_echo",
+        text: "Continue",
+        modeSession: owner,
+      }),
+      AssistantTurnStartEventSchema.parse({
+        type: "assistant_turn_start",
+        messageId: "message-123",
+        modeSession: owner,
+      }),
+      ToolUseStartEventSchema.parse({
+        type: "tool_use_start",
+        toolName: "browser_navigate",
+        input: {},
+        modeSession: owner,
+      }),
+      ToolResultEventSchema.parse({
+        type: "tool_result",
+        toolName: "browser_navigate",
+        result: "Complete",
+        modeSession: owner,
+      }),
+      MessageCompleteEventSchema.parse({
+        type: "message_complete",
+        modeSession: owner,
+      }),
+      GenerationHandoffEventSchema.parse({
+        type: "generation_handoff",
+        queuedCount: 1,
+        modeSession: owner,
+      }),
+    ];
+    expect(
+      boundaryEvents.every((event) => event.modeSession?.id === owner.id),
+    ).toBe(true);
+  });
+
+  test("keeps text and thinking deltas free of session fields", () => {
+    expect(
+      AssistantTextDeltaEventSchema.parse({
+        type: "assistant_text_delta",
+        text: "Working",
+        modeSession: owner,
+      }),
+    ).not.toHaveProperty("modeSession");
+    expect(
+      AssistantThinkingDeltaEventSchema.parse({
+        type: "assistant_thinking_delta",
+        thinking: "Checking",
+        modeSession: owner,
+      }),
+    ).not.toHaveProperty("modeSession");
+  });
+
+  test("exposes runtime state only for active summaries", () => {
+    const summary = {
+      id: "session-123",
+      conversationId: "conv-123",
+      mode: "browser",
+      status: "active",
+      sourceStartedAt: 100,
+      firstIncludedAt: null,
+      firstIncludedMessageId: null,
+      lastActivityAt: 100,
+      lastOwnedMessageId: null,
+      endedAt: null,
+      endReason: null,
+      revision: 1,
+    } as const;
+    expect(
+      ModeSessionDescriptorSchema.parse({
+        summary,
+        runtimeState: "waiting",
+      }).runtimeState,
+    ).toBe("waiting");
+    expect(
+      ModeSessionDescriptorSchema.safeParse({
+        summary: {
+          ...summary,
+          status: "completed",
+          endedAt: 120,
+          endReason: "settled",
+        },
+        runtimeState: "finishing",
+      }).success,
+    ).toBe(false);
+  });
+
+  test("types canonical metadata while preserving unrelated keys", () => {
+    expect(
+      messageMetadataSchema.parse({
+        modeSession: owner,
+        futureMetadata: { value: true },
+      }),
+    ).toEqual({
+      modeSession: owner,
+      futureMetadata: { value: true },
+    });
+    expect(
+      messageMetadataSchema.parse({
+        modeSession: { mode: "unknown", id: "session-123" },
+        futureMetadata: { value: true },
+      }),
+    ).toEqual({ futureMetadata: { value: true } });
+  });
+});

package/src/__tests__/notification-guardian-path.test.ts

@@ -160,6 +160,7 @@ describe("ASK_GUARDIAN notification path", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -220,6 +221,7 @@ describe("ASK_GUARDIAN notification path", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -263,6 +265,7 @@ describe("ASK_GUARDIAN notification path", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -308,6 +311,7 @@ describe("ASK_GUARDIAN notification path", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -338,6 +342,7 @@ describe("ASK_GUARDIAN notification path", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -370,6 +375,7 @@ describe("ASK_GUARDIAN notification path", () => {
     const sharedConvId = "conv-guardian-shared-thread";
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -463,6 +469,7 @@ describe("ASK_GUARDIAN notification path", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",

package/src/__tests__/notification-telegram-adapter.test.ts

@@ -183,7 +183,7 @@ describe("TelegramAdapter", () => {
 
     await adapter.send(
       makePayload({
-        sourceEventName: "watcher.escalation",
+        sourceEventName: "watcher.notification",
         copy: {
           title: " ",
           body: "",
@@ -191,7 +191,7 @@ describe("TelegramAdapter", () => {
       }),
       makeDestination(),
     );
-    expect(sendCalls[2]?.text).toBe("watcher escalation");
+    expect(sendCalls[2]?.text).toBe("watcher notification");
   });
 
   // ── Access request inline keyboard tests ──────────────────────────────

package/src/__tests__/notification-vellum-adapter.test.ts

@@ -35,6 +35,7 @@ import type {
   ChannelDeliveryPayload,
   ChannelDestination,
 } from "../notifications/types.js";
+import type { BroadcastMessageOptions } from "../runtime/assistant-event-hub.js";
 
 function makePayload(
   overrides?: Partial<ChannelDeliveryPayload>,
@@ -362,3 +363,36 @@ describe("VellumAdapter update", () => {
     expect(result.error).toBe("DB write failed");
   });
 });
+
+describe("VellumAdapter guardian scoping", () => {
+  function captureOptions(): {
+    adapter: VellumAdapter;
+    options: Array<BroadcastMessageOptions | undefined>;
+  } {
+    const options: Array<BroadcastMessageOptions | undefined> = [];
+    const adapter = new VellumAdapter((_msg, _conversationId, opts) => {
+      options.push(opts);
+    });
+    return { adapter, options };
+  }
+
+  test("a guardian-sensitive intent is delivered only to the guardian's connections", async () => {
+    const { adapter, options } = captureOptions();
+    await adapter.send(
+      makePayload({ sourceEventName: "guardian.question", urgency: "high" }),
+      makeDestination({ metadata: { guardianPrincipalId: "principal-g" } }),
+    );
+
+    expect(options).toEqual([{ targetActorPrincipalId: "principal-g" }]);
+  });
+
+  test("an ordinary intent is broadcast to every connection", async () => {
+    const { adapter, options } = captureOptions();
+    await adapter.send(
+      makePayload({ sourceEventName: "schedule.notify" }),
+      makeDestination({ metadata: { guardianPrincipalId: "principal-g" } }),
+    );
+
+    expect(options).toEqual([{ targetActorPrincipalId: undefined }]);
+  });
+});

package/src/__tests__/oauth-provider-serializer.test.ts

@@ -292,11 +292,23 @@ describe("serializeProviderSummary", () => {
       supports_managed_mode: true,
       managed_service_is_paid: false,
       feature_flag: null,
+      category: "productivity",
       tenant_host: null,
       acts_as: "user",
     });
   });
 
+  test("files the provider under its seeded category", () => {
+    // The category is catalog metadata the seed carries, not a column, so a
+    // provider a user registered by hand has none.
+    const category = (provider: string) =>
+      serializeProviderSummary(makeRow({ provider }))!.category;
+
+    expect(category("hubspot")).toBe("sales");
+    expect(category("calendly")).toBe("meetings");
+    expect(category("custom-provider")).toBeNull();
+  });
+
   test("exposes the tenant host a per-tenant provider needs at connect", () => {
     // Shopify's OAuth endpoints live on the merchant's own host, so a client
     // has to collect it before the managed flow can start. The summary is the

package/src/__tests__/oauth-providers-routes.test.ts

@@ -180,6 +180,7 @@ describe("GET /v1/oauth/providers", () => {
       "supports_managed_mode",
       "managed_service_is_paid",
       "feature_flag",
+      "category",
       "tenant_host",
       "acts_as",
     ];

package/src/__tests__/outbound-slack-persistence.test.ts

@@ -185,6 +185,7 @@ import {
 } from "../daemon/conversation-agent-loop-handlers.js";
 import { readSlackMetadataFromMessageMetadata } from "../messaging/providers/slack/message-metadata.js";
 import { deliverReplyViaCallback } from "../runtime/channel-reply-delivery.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // ── Helpers ────────────────────────────────────────────────────────────────
@@ -216,6 +217,7 @@ function makeDeps(
         sourceThreadId: overrides.sourceThreadId,
       },
       clientTimezone: overrides.clientTimezone,
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (_msg: AssistantEvent) => {},
     reqId: "test-req-id",

package/src/__tests__/persistence-secret-redaction.test.ts

@@ -102,6 +102,7 @@ import {
   handleLlmCallStarted,
   handleMessageComplete,
 } from "../daemon/conversation-agent-loop-handlers.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
@@ -117,6 +118,7 @@ function makeDeps(): EventHandlerDeps {
         sourceChannel: "vellum",
         trustClass: "guardian",
       },
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: () => {},
     reqId: "test-req",

package/src/__tests__/plugin-api-provider.test.ts

@@ -21,4 +21,9 @@ describe("plugin-api provider access", () => {
     // registry), not a disjoint, uninitialized module copy.
     expect(PLUGIN_API_EXPORTS).toContain("getConfiguredProvider");
   });
+
+  test("getEffectiveContextWindow is exported and shim-rebound", () => {
+    expect(typeof pluginApi.getEffectiveContextWindow).toBe("function");
+    expect(PLUGIN_API_EXPORTS).toContain("getEffectiveContextWindow");
+  });
 });

package/src/__tests__/plugin-api-resolve-credential.test.ts

@@ -14,6 +14,7 @@ import {
 
 import { credentialKey } from "@vellumai/credential-storage";
 
+import { PLUGIN_NAME_ENV } from "../plugin-api/plugin-name-env.js";
 import {
   CredentialResolutionError,
   resolveCredential,
@@ -22,8 +23,10 @@ import { runInPluginContext } from "../plugins/plugin-execution-context.js";
 import * as secureKeys from "../security/secure-keys.js";
 import {
   _setMetadataPath,
+  type CredentialMetadata,
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
+import * as metadataStore from "../tools/credentials/metadata-store.js";
 
 // Real metadata store backed by a temp file (no module mocking — a mock.module
 // on metadata-store / secure-keys would replace the whole module namespace and
@@ -65,6 +68,7 @@ beforeEach(() => {
 
 afterEach(() => {
   getSpy.mockRestore();
+  delete process.env[PLUGIN_NAME_ENV];
 });
 
 afterAll(() => {
@@ -145,5 +149,98 @@ describe("resolveCredential", () => {
         ),
       ).resolves.toBe("proj-id");
     });
+
+    test("scopes resolution from VELLUM_PLUGIN_NAME when ALS is empty", async () => {
+      seedCredential("sms", "account_sid", "sid-secret");
+      process.env[PLUGIN_NAME_ENV] = "sms";
+      await expect(resolveCredential("sms/account_sid")).resolves.toBe(
+        "sid-secret",
+      );
+    });
+
+    test("blocks another service when identity comes from VELLUM_PLUGIN_NAME", async () => {
+      seedCredential("openai", "api_key", "sk-secret");
+      process.env[PLUGIN_NAME_ENV] = "sms";
+      await expect(resolveCredential("openai/api_key")).rejects.toThrow(
+        /out of scope/,
+      );
+    });
+  });
+
+  describe("live catalog on cache miss", () => {
+    function liveRecord(
+      service: string,
+      field: string,
+    ): CredentialMetadata {
+      return {
+        credentialId: `${service}-${field}`,
+        service,
+        field,
+        allowedTools: [],
+        allowedDomains: [],
+        createdAt: 1,
+        updatedAt: 1,
+      };
+    }
+
+    test("consults the live catalog when plugin context is set and the cache misses", async () => {
+      const liveSpy = spyOn(
+        metadataStore,
+        "listCredentialRecordsLive",
+      ).mockResolvedValue({
+        records: [liveRecord("sms", "account_sid")],
+        unreachable: false,
+      });
+      secureStore.set(credentialKey("sms", "account_sid"), "live-sid");
+      process.env[PLUGIN_NAME_ENV] = "sms";
+
+      try {
+        await expect(resolveCredential("sms/account_sid")).resolves.toBe(
+          "live-sid",
+        );
+        expect(liveSpy).toHaveBeenCalledTimes(1);
+      } finally {
+        liveSpy.mockRestore();
+      }
+    });
+
+    test("does not list live records when no plugin is in context", async () => {
+      const liveSpy = spyOn(
+        metadataStore,
+        "listCredentialRecordsLive",
+      ).mockResolvedValue({
+        records: [liveRecord("sms", "account_sid")],
+        unreachable: false,
+      });
+      secureStore.set(credentialKey("sms", "account_sid"), "live-sid");
+
+      try {
+        await expect(resolveCredential("sms/account_sid")).rejects.toThrow(
+          /Credential not found/,
+        );
+        expect(liveSpy).not.toHaveBeenCalled();
+      } finally {
+        liveSpy.mockRestore();
+      }
+    });
+
+    test("reports an unreachable live catalog instead of not found", async () => {
+      const liveSpy = spyOn(
+        metadataStore,
+        "listCredentialRecordsLive",
+      ).mockResolvedValue({
+        records: [],
+        unreachable: true,
+      });
+      process.env[PLUGIN_NAME_ENV] = "sms";
+
+      try {
+        await expect(resolveCredential("sms/account_sid")).rejects.toThrow(
+          /unreachable/,
+        );
+      } finally {
+        liveSpy.mockRestore();
+      }
+    });
   });
 });

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -99,6 +99,8 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../../persistence/schema/index.js",
     "../../../../../security/untrusted-content.js",
     "../../../../api/events/memory-recalled.js",
+    "../../../../api/events/tool-result.js",
+    "../../../../api/remember-tool.js",
     "../../../../api/responses/memory-v3-selection-log.js",
     "../../../../config/assistant-feature-flags.js",
     "../../../../config/default-profile-catalog.js",
@@ -166,6 +168,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../util/json.js",
     "../../../../util/logger.js",
     "../../../../util/platform.js",
+    "../../../api/remember-tool.js",
     "../../../channels/types.js",
     "../../../config/loader.js",
     "../../../config/memory-v3-gate.js",
@@ -272,6 +275,12 @@ const BASELINE: Record<string, readonly string[]> = {
     "zod",
   ],
   "platform-hosted": ["node:fs/promises", "node:path"],
+  // Host-internal surface snapshot and task_progress parser. UI surfaces
+  // stay host-owned, so there is no plugin-api equivalent.
+  "task-progress": [
+    "../../../../daemon/conversation-surface-snapshots.js",
+    "../../../../runtime/task-progress.js",
+  ],
   session: [
     "../../../config/loader.js",
     "../../types.js",

package/src/__tests__/process-message-display-content.test.ts

@@ -148,6 +148,7 @@ import { persistQueuedMessageBody } from "../daemon/conversation-messaging.js";
 import type { MessageQueue } from "../daemon/conversation-queue-manager.js";
 import type { UserMessageAttachment } from "../daemon/message-protocol.js";
 import { processMessage } from "../daemon/process-message.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import type { Message } from "../providers/types.js";
 
 function makeTestConversation() {
@@ -554,3 +555,58 @@ describe("processMessage skipUserMessageIndexing", () => {
     expect(addMessageCalls[0]!.skipIndexing).toBeUndefined();
   });
 });
+
+describe("processMessage author", () => {
+  const author: TrustContext = {
+    sourceChannel: "slack",
+    trustClass: "trusted_contact",
+    requesterContactId: "contact-alice",
+  };
+
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+    activeConversation = undefined;
+    resolveSlashForTest = (content) => ({ kind: "passthrough", content });
+  });
+
+  test("a relayed message names its author on the user row", async () => {
+    activeConversation = makeTestConversation();
+
+    await processMessage("conv-display-content", "the export needs a token", {
+      author,
+    });
+
+    expect(addMessageCalls[0]!.role).toBe("user");
+    expect(addMessageCalls[0]!.metadata?.provenanceContactId).toBe(
+      "contact-alice",
+    );
+  });
+
+  test("a message nobody relayed names no author", async () => {
+    activeConversation = makeTestConversation();
+
+    await processMessage("conv-display-content", "kickoff prompt body", {});
+
+    expect(addMessageCalls[0]!.metadata?.provenanceContactId).toBeUndefined();
+  });
+
+  test("a relayed slash command names its author on the user row, not the reply", async () => {
+    resolveSlashForTest = () => ({
+      kind: "unknown",
+      message: "Unknown slash command.",
+    });
+    activeConversation = makeTestConversation();
+
+    await processMessage("conv-display-content", "/missing-command", {
+      author,
+    });
+
+    expect(addMessageCalls).toHaveLength(2);
+    expect(addMessageCalls[0]!.role).toBe("user");
+    expect(addMessageCalls[0]!.metadata?.provenanceContactId).toBe(
+      "contact-alice",
+    );
+    expect(addMessageCalls[1]!.role).toBe("assistant");
+    expect(addMessageCalls[1]!.metadata?.provenanceContactId).toBeUndefined();
+  });
+});

package/src/__tests__/reaction-persistence.test.ts

@@ -116,9 +116,12 @@ function resetState(): void {
   _conversationMocks.clear();
 }
 
+const REACTOR_CONTACT_ID = "contact-reactor";
+
 function seedActiveMember(): void {
   seedContactChannel({
     sourceChannel: "slack",
+    contactId: REACTOR_CONTACT_ID,
     externalUserId: SLACK_USER_ID,
     externalChatId: SLACK_CHANNEL_ID,
     status: "active",
@@ -276,6 +279,8 @@ describe("Slack reaction event persistence", () => {
     // filterMessagesForUntrustedActor drops rows with no trust class.
     expect(envelope.provenanceTrustClass).toBe("trusted_contact");
     expect(envelope.provenanceSourceChannel).toBe("slack");
+    // The reactor wrote this row, so it names them as its author.
+    expect(envelope.provenanceContactId).toBe(REACTOR_CONTACT_ID);
     const slackMetaRaw = envelope.slackMeta;
     expect(typeof slackMetaRaw).toBe("string");
 

package/src/__tests__/request-secret-standalone-channel-gate.test.ts

@@ -220,21 +220,37 @@ describe("requestSecretStandalone channel gate", () => {
     await promise;
   });
 
-  test("broadcasts for a conversation-less prompt (plain CLI invocation)", async () => {
+  test("mints a collection link for a conversation-less prompt (headless exec)", async () => {
+    /**
+     * A prompt with no conversationId (Doctor's `run_assistant_cli`, a bare
+     * shell) has no surface that can render it: clients drop
+     * conversation-scoped events without a conversationId and
+     * `/v1/pending-interactions` is keyed by conversation. Broadcasting would
+     * only sit until the permission timeout, so it must fail fast into the
+     * collection-link fallback.
+     */
+    gatewayMintResult = {
+      ok: true,
+      token: "tok",
+      url: "https://x.test/assistant/credentials/enter#token=tok",
+      expiresAt: 1234,
+    };
+
     // WHEN a standalone prompt carries no conversationId
-    const promise = requestSecretStandalone({
+    const result = await requestSecretStandalone({
       service: "stripe",
       field: "api_key",
       label: "Stripe API Key",
     });
 
-    // THEN the secret_request is broadcast (desktop/web clients render it)
-    expect(broadcastMessages).toHaveLength(1);
-    expect(broadcastMessages[0]!.type).toBe("secret_request");
-
-    const entry = [..._piStore.values()][0];
-    entry?.rpcResolve?.({ value: "v", delivery: "store" });
-    await promise;
+    // THEN nothing is broadcast or registered and the link is returned
+    expect(broadcastMessages).toHaveLength(0);
+    expect(_piStore.size).toBe(0);
+    expect(result.error).toBe("unsupported_channel");
+    expect(result.collectionUrl).toBe(
+      "https://x.test/assistant/credentials/enter#token=tok",
+    );
+    expect(gatewayMintCalls).toHaveLength(1);
   });
 
   test("broadcasts when the conversation is not loaded in the registry", async () => {

package/src/__tests__/runtime-events-sse-reconnect.test.ts

@@ -270,7 +270,7 @@ describe("SSE reconnect replay (B7.2)", () => {
   test("replay excludes events the subscriber is not targeted to receive", async () => {
     // Stamp three events: two untargeted (seq 1, 3) + one with a
     // capability target (seq 2, host_bash). A process subscriber
-    // does NOT match capability targeting (matchesSubscriber requires
+    // does NOT match capability targeting (matchesTargeting requires
     // type=client + matching capability), so the replay filters out
     // seq 2. The subscriber receives seq 1 and 3.
     const { conversationId } = getOrCreateConversation("replay-targeting");