@vellumai/assistant 0.4.55 → 0.4.57

package/src/__tests__/{session-runtime-assembly.test.ts → conversation-runtime-assembly.test.ts}

@@ -4,23 +4,22 @@ import type {
   ChannelCapabilities,
   ChannelTurnContextParams,
   InboundActorContext,
-} from "../daemon/session-runtime-assembly.js";
+} from "../daemon/conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
-  buildChannelTurnContextBlock,
+  buildTurnContextBlock,
   injectChannelCapabilityContext,
-  injectChannelTurnContext,
+  injectChannelCommandContext,
   injectInboundActorContext,
   injectTemporalContext,
+  injectTurnContext,
   isGroupChatType,
   resolveChannelCapabilities,
-  sanitizePttActivationKey,
   stripChannelCapabilityContext,
   stripChannelTurnContext,
   stripInboundActorContext,
   stripTemporalContext,
-} from "../daemon/session-runtime-assembly.js";
-import { buildChannelAwarenessSection } from "../prompts/system-prompt.js";
+} from "../daemon/conversation-runtime-assembly.js";
 import type { Message } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -135,7 +134,7 @@ describe("resolveChannelCapabilities", () => {
   });
 
   test("propagates chatType when provided", () => {
-    const caps = resolveChannelCapabilities("telegram", null, null, "group");
+    const caps = resolveChannelCapabilities("telegram", null, "group");
     expect(caps.chatType).toBe("group");
   });
 
@@ -155,7 +154,7 @@ describe("injectChannelCapabilityContext", () => {
     content: [{ type: "text", text: "Hello" }],
   };
 
-  test("injects channel capabilities block for dashboard channel", () => {
+  test("skips injection entirely for desktop happy path (all capabilities true)", () => {
     const caps: ChannelCapabilities = {
       channel: "vellum",
       dashboardCapable: true,
@@ -165,26 +164,9 @@ describe("injectChannelCapabilityContext", () => {
 
     const result = injectChannelCapabilityContext(baseUserMessage, caps);
 
-    // Should prepend a text block with channel_capabilities
-    expect(result.content.length).toBe(2);
-    const injected = result.content[0];
-    expect(injected.type).toBe("text");
-    expect((injected as { type: "text"; text: string }).text).toContain(
-      "<channel_capabilities>",
-    );
-    expect((injected as { type: "text"; text: string }).text).toContain(
-      "dashboard_capable: true",
-    );
-    expect((injected as { type: "text"; text: string }).text).toContain(
-      "supports_dynamic_ui: true",
-    );
-    expect((injected as { type: "text"; text: string }).text).toContain(
-      "</channel_capabilities>",
-    );
-    // Should NOT contain constraint rules for dashboard
-    expect((injected as { type: "text"; text: string }).text).not.toContain(
-      "CHANNEL CONSTRAINTS",
-    );
+    // Message returned unchanged — no injection at all
+    expect(result).toBe(baseUserMessage);
+    expect(result.content.length).toBe(1);
   });
 
   test("injects constraint rules for non-dashboard channel", () => {
@@ -293,6 +275,50 @@ describe("injectChannelCapabilityContext", () => {
     expect(text).toContain("GROUP CHAT ETIQUETTE");
     expect(text).toContain("emoji reactions");
   });
+
+  test("still injects for group chats even when all capabilities are true", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: true,
+      supportsDynamicUi: true,
+      supportsVoiceInput: true,
+      chatType: "channel",
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    // Not the happy path because chatType is a group type
+    expect(result).not.toBe(baseUserMessage);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("GROUP CHAT ETIQUETTE");
+  });
+
+  test("injects WhatsApp formatting constraint for whatsapp channel", () => {
+    const caps: ChannelCapabilities = {
+      channel: "whatsapp",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("Do NOT use markdown tables");
+    expect(text).toContain("bullet lists");
+    expect(text).toContain("CAPS for emphasis");
+  });
+
+  test("does NOT inject WhatsApp formatting for non-whatsapp channels", () => {
+    const caps: ChannelCapabilities = {
+      channel: "telegram",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+
+    const result = injectChannelCapabilityContext(baseUserMessage, caps);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).not.toContain("Do NOT use markdown tables");
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -449,60 +475,12 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// buildChannelAwarenessSection
-// ---------------------------------------------------------------------------
-
-describe("buildChannelAwarenessSection", () => {
-  test("includes channel awareness heading", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("## Channel Awareness & Trust Gating");
-  });
-
-  test("includes channel-specific rules", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("dashboard_capable");
-    expect(section).toContain("supports_dynamic_ui");
-    expect(section).toContain("supports_voice_input");
-  });
-
-  test("includes trust gating rules for permission asks", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("firstConversationComplete");
-    expect(section).toContain("Permission ask trust gating");
-    expect(section).toContain(
-      "Do NOT proactively ask for elevated permissions",
-    );
-  });
-
-  test("gates microphone permissions on voice capability", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("Do not ask for microphone permissions");
-  });
-
-  test("gates computer-control on dashboard channel", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).toContain("computer-control permissions on non-dashboard");
-  });
-
-  test("does NOT include group chat etiquette (gated per-turn instead)", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).not.toContain("Group chat etiquette");
-    expect(section).not.toContain("Stay silent when");
-  });
-
-  test("does NOT include Discord references (not a supported channel)", () => {
-    const section = buildChannelAwarenessSection();
-    expect(section).not.toContain("Discord");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Trust-gating behavior: channel constraints for permission asks
 // ---------------------------------------------------------------------------
 
 describe("trust-gating via channel capabilities", () => {
-  test("vellum channel with macos interface does not add constraint rules", () => {
+  test("vellum channel with macos interface skips injection (happy path)", () => {
     const caps = resolveChannelCapabilities("vellum", "macos");
     const message: Message = {
       role: "user",
@@ -510,10 +488,9 @@ describe("trust-gating via channel capabilities", () => {
     };
 
     const result = injectChannelCapabilityContext(message, caps);
-    const injected = (result.content[0] as { type: "text"; text: string }).text;
 
-    expect(injected).not.toContain("CHANNEL CONSTRAINTS");
-    expect(injected).toContain("dashboard_capable: true");
+    // Happy path: message returned unchanged
+    expect(result).toBe(message);
   });
 
   test("non-dashboard channel adds constraint rules preventing UI references", () => {
@@ -554,6 +531,50 @@ describe("trust-gating via channel capabilities", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// injectChannelCommandContext
+// ---------------------------------------------------------------------------
+
+describe("injectChannelCommandContext", () => {
+  const baseUserMessage: Message = {
+    role: "user",
+    content: [{ type: "text", text: "Hello" }],
+  };
+
+  test("injects start command instructions when type is start", () => {
+    const result = injectChannelCommandContext(baseUserMessage, {
+      type: "start",
+    });
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("command_type: start");
+    expect(text).toContain("warm, brief greeting");
+    expect(text).toContain("Treat /start as a hello");
+    expect(text).toContain("Do NOT reset conversation");
+  });
+
+  test("includes language code and payload when provided", () => {
+    const result = injectChannelCommandContext(baseUserMessage, {
+      type: "start",
+      payload: "ref123",
+      languageCode: "es",
+    });
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("payload: ref123");
+    expect(text).toContain("language_code: es");
+    expect(text).toContain("warm, brief greeting");
+  });
+
+  test("does NOT inject start instructions for non-start commands", () => {
+    const result = injectChannelCommandContext(baseUserMessage, {
+      type: "help",
+    });
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    expect(text).toContain("command_type: help");
+    expect(text).not.toContain("warm, brief greeting");
+    expect(text).not.toContain("Treat /start as a hello");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // injectTemporalContext
 // ---------------------------------------------------------------------------
@@ -768,9 +789,13 @@ describe("injectInboundActorContext", () => {
     expect(text).toContain("trust_class: guardian");
     expect(text).toContain("source_channel: phone");
     expect(text).toContain("canonical_actor_identity: guardian-user-1");
+    // Display names differ from canonical, so they should appear
+    expect(text).toContain("actor_identifier: +15550001111");
     expect(text).toContain("actor_display_name: Guardian Name");
     expect(text).toContain("actor_sender_display_name: Guardian Name");
     expect(text).toContain("actor_member_display_name: Guardian Name");
+    // guardian_identity matches canonical, so it should be omitted
+    expect(text).not.toContain("guardian_identity:");
     expect(text).toContain("</inbound_actor_context>");
   });
 
@@ -798,6 +823,30 @@ describe("injectInboundActorContext", () => {
     );
   });
 
+  test("omits name_preference_note when member name matches canonical and is suppressed", () => {
+    const ctx: InboundActorContext = {
+      sourceChannel: "telegram",
+      canonicalActorIdentity: "Jeff",
+      actorIdentifier: "@jeff_handle",
+      actorDisplayName: "Jeff",
+      actorSenderDisplayName: "Jeffrey",
+      actorMemberDisplayName: "Jeff",
+      trustClass: "trusted_contact",
+      guardianIdentity: "guardian-user-1",
+      memberStatus: "active",
+      memberPolicy: "allow",
+    };
+
+    const result = injectInboundActorContext(baseUserMessage, ctx);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    // actor_member_display_name matches canonical → omitted by differs() guard
+    expect(text).not.toContain("actor_member_display_name:");
+    // actor_sender_display_name differs from canonical → emitted
+    expect(text).toContain("actor_sender_display_name: Jeffrey");
+    // name_preference_note must NOT appear since actor_member_display_name was omitted
+    expect(text).not.toContain("name_preference_note:");
+  });
+
   test("sanitizes inline actor context values to prevent line injection", () => {
     const ctx: InboundActorContext = {
       sourceChannel: "telegram",
@@ -903,6 +952,38 @@ describe("injectInboundActorContext", () => {
     expect(text).not.toContain("non-guardian account");
   });
 
+  test("omits redundant fields when they match canonical_actor_identity", () => {
+    const uuid = "vellum-principal-b77e94f5-67c0-4599-8baa-871b925b3da8";
+    const ctx: InboundActorContext = {
+      sourceChannel: "vellum",
+      canonicalActorIdentity: uuid,
+      actorIdentifier: uuid,
+      actorDisplayName: uuid,
+      actorSenderDisplayName: undefined,
+      actorMemberDisplayName: uuid,
+      trustClass: "guardian",
+      guardianIdentity: uuid,
+      memberStatus: "active",
+      memberPolicy: "allow",
+      contactNotes: "guardian",
+    };
+
+    const result = injectInboundActorContext(baseUserMessage, ctx);
+    const text = (result.content[0] as { type: "text"; text: string }).text;
+    // Only essential fields should remain
+    expect(text).toContain("source_channel: vellum");
+    expect(text).toContain(`canonical_actor_identity: ${uuid}`);
+    expect(text).toContain("trust_class: guardian");
+    // Redundant fields should be omitted
+    expect(text).not.toContain("actor_identifier:");
+    expect(text).not.toContain("actor_display_name:");
+    expect(text).not.toContain("actor_sender_display_name:");
+    expect(text).not.toContain("actor_member_display_name:");
+    expect(text).not.toContain("guardian_identity:");
+    // contact_notes: "guardian" matches trust_class, should be omitted
+    expect(text).not.toContain("contact_notes:");
+  });
+
   test("omits member_status and member_policy when not provided", () => {
     const ctx: InboundActorContext = {
       sourceChannel: "phone",
@@ -969,46 +1050,44 @@ describe("applyRuntimeInjections with inboundActorContext", () => {
 });
 
 // ---------------------------------------------------------------------------
-// buildChannelTurnContextBlock
+// buildTurnContextBlock (channel-only)
 // ---------------------------------------------------------------------------
 
-describe("buildChannelTurnContextBlock", () => {
-  test("formats block with all three channel fields", () => {
-    const block = buildChannelTurnContextBlock({
+describe("buildTurnContextBlock (channel-only)", () => {
+  test("collapses to single field when all channels match", () => {
+    const block = buildTurnContextBlock({
       turnContext: {
         userMessageChannel: "telegram",
         assistantMessageChannel: "telegram",
       },
       conversationOriginChannel: "telegram",
-    });
+    }, undefined);
     expect(block).toBe(
-      "<channel_turn_context>\n" +
-        "user_message_channel: telegram\n" +
-        "assistant_message_channel: telegram\n" +
-        "conversation_origin_channel: telegram\n" +
-        "</channel_turn_context>",
+      "<turn_context>\n" +
+        "channel: telegram\n" +
+        "</turn_context>",
     );
   });
 
   test('uses "unknown" when conversationOriginChannel is null', () => {
-    const block = buildChannelTurnContextBlock({
+    const block = buildTurnContextBlock({
       turnContext: {
         userMessageChannel: "vellum",
         assistantMessageChannel: "vellum",
       },
       conversationOriginChannel: null,
-    });
+    }, undefined);
     expect(block).toContain("conversation_origin_channel: unknown");
   });
 
   test("handles mixed channels", () => {
-    const block = buildChannelTurnContextBlock({
+    const block = buildTurnContextBlock({
       turnContext: {
         userMessageChannel: "telegram",
         assistantMessageChannel: "vellum",
       },
       conversationOriginChannel: "vellum",
-    });
+    }, undefined);
     expect(block).toContain("user_message_channel: telegram");
     expect(block).toContain("assistant_message_channel: vellum");
     expect(block).toContain("conversation_origin_channel: vellum");
@@ -1016,10 +1095,10 @@ describe("buildChannelTurnContextBlock", () => {
 });
 
 // ---------------------------------------------------------------------------
-// injectChannelTurnContext
+// injectTurnContext (channel-only)
 // ---------------------------------------------------------------------------
 
-describe("injectChannelTurnContext", () => {
+describe("injectTurnContext (channel-only)", () => {
   const baseUserMessage: Message = {
     role: "user",
     content: [{ type: "text", text: "Hello from telegram" }],
@@ -1033,14 +1112,14 @@ describe("injectChannelTurnContext", () => {
       },
       conversationOriginChannel: "telegram",
     };
-    const result = injectChannelTurnContext(baseUserMessage, params);
+    const result = injectTurnContext(baseUserMessage, params, undefined);
     expect(result.content.length).toBe(2);
     const injected = result.content[0];
     expect(injected.type).toBe("text");
     const text = (injected as { type: "text"; text: string }).text;
-    expect(text).toContain("<channel_turn_context>");
-    expect(text).toContain("user_message_channel: telegram");
-    expect(text).toContain("</channel_turn_context>");
+    expect(text).toContain("<turn_context>");
+    expect(text).toContain("channel: telegram");
+    expect(text).toContain("</turn_context>");
   });
 
   test("preserves original message content", () => {
@@ -1051,7 +1130,7 @@ describe("injectChannelTurnContext", () => {
       },
       conversationOriginChannel: "vellum",
     };
-    const result = injectChannelTurnContext(baseUserMessage, params);
+    const result = injectTurnContext(baseUserMessage, params, undefined);
     const lastBlock = result.content[result.content.length - 1];
     expect((lastBlock as { type: "text"; text: string }).text).toBe(
       "Hello from telegram",
@@ -1071,7 +1150,7 @@ describe("stripChannelTurnContext", () => {
         content: [
           {
             type: "text",
-            text: "<channel_turn_context>\nuser_message_channel: telegram\n</channel_turn_context>",
+            text: "<turn_context>\nuser_message_channel: telegram\n</turn_context>",
           },
           { type: "text", text: "Hello" },
         ],
@@ -1099,7 +1178,7 @@ describe("stripChannelTurnContext", () => {
         content: [
           {
             type: "text",
-            text: "<channel_turn_context>\nuser_message_channel: macos\n</channel_turn_context>",
+            text: "<turn_context>\nuser_message_channel: macos\n</turn_context>",
           },
         ],
       },
@@ -1152,7 +1231,7 @@ describe("applyRuntimeInjections with channelTurnContext", () => {
     expect(result[0].content.length).toBe(2);
     const injected = result[0].content[0];
     expect((injected as { type: "text"; text: string }).text).toContain(
-      "<channel_turn_context>",
+      "<turn_context>",
     );
   });
 
@@ -1173,73 +1252,6 @@ describe("applyRuntimeInjections with channelTurnContext", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// sanitizePttActivationKey
-// ---------------------------------------------------------------------------
-
-describe("sanitizePttActivationKey", () => {
-  test("returns undefined for null/undefined input", () => {
-    expect(sanitizePttActivationKey(null)).toBeUndefined();
-    expect(sanitizePttActivationKey(undefined)).toBeUndefined();
-  });
-
-  test("passes through valid JSON PTTActivator payloads", () => {
-    const modifierOnly = JSON.stringify({
-      kind: "modifierOnly",
-      modifierFlags: 8388608,
-    });
-    expect(sanitizePttActivationKey(modifierOnly)).toBe(modifierOnly);
-    const keyPayload = JSON.stringify({ kind: "key", keyCode: 49 });
-    expect(sanitizePttActivationKey(keyPayload)).toBe(keyPayload);
-    const nonePayload = JSON.stringify({ kind: "none" });
-    expect(sanitizePttActivationKey(nonePayload)).toBe(nonePayload);
-  });
-
-  test("returns undefined for invalid keys", () => {
-    expect(
-      sanitizePttActivationKey("malicious\nprompt injection"),
-    ).toBeUndefined();
-    expect(sanitizePttActivationKey("arbitrary_value")).toBeUndefined();
-    expect(sanitizePttActivationKey("")).toBeUndefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveChannelCapabilities sanitizes pttActivationKey
-// ---------------------------------------------------------------------------
-
-describe("resolveChannelCapabilities with PTT metadata", () => {
-  test("sanitizes valid JSON PTTActivator pttActivationKey", () => {
-    const key = JSON.stringify({
-      kind: "modifierOnly",
-      modifierFlags: 8388608,
-    });
-    const caps = resolveChannelCapabilities("macos", "macos", {
-      pttActivationKey: key,
-    });
-    expect(caps.pttActivationKey).toBe(key);
-  });
-
-  test("sanitizes invalid pttActivationKey to undefined", () => {
-    const caps = resolveChannelCapabilities("macos", "macos", {
-      pttActivationKey: "evil\nprompt",
-    });
-    expect(caps.pttActivationKey).toBeUndefined();
-  });
-
-  test("passes through microphonePermissionGranted", () => {
-    const key = JSON.stringify({
-      kind: "modifierOnly",
-      modifierFlags: 8388608,
-    });
-    const caps = resolveChannelCapabilities("macos", "macos", {
-      pttActivationKey: key,
-      microphonePermissionGranted: true,
-    });
-    expect(caps.microphonePermissionGranted).toBe(true);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // applyRuntimeInjections — injection mode
 // ---------------------------------------------------------------------------
@@ -1299,8 +1311,8 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<channel_command_context>");
     expect(allText).toContain("<active_workspace>");
     expect(allText).toContain("<channel_capabilities>");
-    expect(allText).toContain("<channel_turn_context>");
-    expect(allText).toContain("<interface_turn_context>");
+    expect(allText).toContain("<turn_context>");
+    expect(allText).toContain("<turn_context>");
     expect(allText).toContain("<inbound_actor_context>");
     expect(allText).toContain("<non_interactive_context>");
   });
@@ -1349,8 +1361,8 @@ describe("applyRuntimeInjections — injection mode", () => {
       .join("\n");
 
     // Kept in minimal mode
-    expect(allText).toContain("<channel_turn_context>");
-    expect(allText).toContain("<interface_turn_context>");
+    expect(allText).toContain("<turn_context>");
+    expect(allText).toContain("<turn_context>");
     expect(allText).toContain("<inbound_actor_context>");
     expect(allText).toContain("<non_interactive_context>");
     expect(allText).toContain("<channel_capabilities>");

package/src/__tests__/{session-runtime-workspace.test.ts → conversation-runtime-workspace.test.ts}

@@ -4,7 +4,7 @@ import {
   applyRuntimeInjections,
   injectWorkspaceTopLevelContext,
   stripWorkspaceTopLevelContext,
-} from "../daemon/session-runtime-assembly.js";
+} from "../daemon/conversation-runtime-assembly.js";
 import type { Message } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------