@vellumai/assistant 0.10.12 → 0.11.0-staging.1

package/src/__tests__/ask-question-resolver.test.ts

@@ -0,0 +1,207 @@
+/**
+ * Tests for the ask_question branch of the `pending_question` guardian-request
+ * resolver (`guardian-request-resolvers.ts`): a request without a
+ * `callSessionId` resolves the parked in-memory `question` interaction via the
+ * shared `resolvePendingQuestion` core, mapping the decision's answer-token /
+ * free text / deny action onto a batch submission.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import type {
+  ActorContext,
+  ResolverContext,
+  ResolverDecision,
+} from "../approvals/guardian-request-resolvers.js";
+import { getResolver } from "../approvals/guardian-request-resolvers.js";
+import type { GuardianRequestWire } from "../channels/gateway-guardian-requests.js";
+import type { QuestionPromptResult } from "../permissions/question-prompter.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
+
+const resolver = getResolver("pending_question");
+
+const actor: ActorContext = {
+  actorPrincipalId: "prin-guardian",
+  actorExternalUserId: "tg-guardian",
+  channel: "telegram",
+  guardianPrincipalId: "prin-guardian",
+};
+
+function makeRequest(
+  overrides: Partial<GuardianRequestWire> = {},
+): GuardianRequestWire {
+  return {
+    id: "req-q1",
+    kind: "pending_question",
+    sourceType: "channel",
+    sourceChannel: "telegram",
+    sourceConversationId: "conv-1",
+    requesterExternalUserId: "tg-guardian",
+    requesterChatId: "chat-1",
+    guardianExternalUserId: "tg-guardian",
+    guardianPrincipalId: "prin-guardian",
+    callSessionId: null,
+    pendingQuestionId: null,
+    questionText: "Which fruit?",
+    requestCode: "ABC123",
+    toolName: null,
+    inputDigest: null,
+    commandPreview: null,
+    riskLevel: null,
+    activityText: null,
+    executionTarget: null,
+    requesterSignals: null,
+    requestTrigger: null,
+    status: "approved",
+    answerText: null,
+    decidedByExternalUserId: null,
+    decidedByPrincipalId: null,
+    followupState: null,
+    expiresAt: null,
+    createdAt: 0,
+    updatedAt: 0,
+    ...overrides,
+  };
+}
+
+function makeContext(
+  decision: ResolverDecision,
+  requestOverrides: Partial<GuardianRequestWire> = {},
+): ResolverContext {
+  return { request: makeRequest(requestOverrides), decision, actor };
+}
+
+/** Register a parked single-question interaction like QuestionPrompter does. */
+function registerQuestion(
+  requestId: string,
+  options: string[],
+  rpcResolve: (value: unknown) => void = () => {},
+): void {
+  pendingInteractions.register(requestId, {
+    conversationId: "conv-1",
+    kind: "question",
+    rpcResolve,
+    metadata: { orderedIds: ["q1"], optionsById: { q1: options } },
+    questionDetails: {
+      entries: [
+        {
+          id: "q1",
+          question: "Which fruit?",
+          options: options.map((id) => ({ id, label: id })),
+        },
+      ],
+    },
+  });
+}
+
+beforeEach(() => pendingInteractions.clear());
+afterEach(() => pendingInteractions.clear());
+
+describe("pending_question resolver — ask_question branch", () => {
+  test("an answer-option token resolves the interaction with that option", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion("req-q1", ["apple", "banana"], (v) =>
+      resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "answer_1" }),
+    );
+
+    expect(result).toEqual({ ok: true, applied: true });
+    expect(resolved[0]?.entries).toEqual([
+      { questionId: "q1", decision: "option", optionId: "banana" },
+    ]);
+    expect(pendingInteractions.get("req-q1")).toBeUndefined();
+  });
+
+  test("the skip token resolves the interaction as skipped", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion("req-q1", ["apple", "banana"], (v) =>
+      resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "reject", userText: "answer_skip" }),
+    );
+
+    expect(result).toEqual({ ok: true, applied: true });
+    expect(resolved[0]?.entries).toEqual([
+      { questionId: "q1", decision: "skipped" },
+    ]);
+  });
+
+  test("free text resolves as a free_text answer", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion("req-q1", ["apple", "banana"], (v) =>
+      resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "a ripe mango" }),
+    );
+
+    expect(result).toEqual({ ok: true, applied: true });
+    expect(resolved[0]?.entries).toEqual([
+      { questionId: "q1", decision: "free_text", text: "a ripe mango" },
+    ]);
+  });
+
+  test("a deny decision with no text skips the question", async () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion("req-q1", ["apple", "banana"], (v) =>
+      resolved.push(v as QuestionPromptResult),
+    );
+
+    const result = await resolver!.resolve(makeContext({ action: "reject" }));
+
+    expect(result).toEqual({ ok: true, applied: true });
+    expect(resolved[0]?.entries).toEqual([
+      { questionId: "q1", decision: "skipped" },
+    ]);
+  });
+
+  test("an out-of-range option index fails without consuming the interaction", async () => {
+    registerQuestion("req-q1", ["apple", "banana"]);
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "answer_9" }),
+    );
+
+    expect(result).toEqual({
+      ok: false,
+      reason: "question_option_index_out_of_range",
+    });
+    expect(pendingInteractions.get("req-q1")).toBeDefined();
+  });
+
+  test("a missing interaction reports no_pending_question_interaction", async () => {
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "answer_0" }),
+    );
+
+    expect(result).toEqual({
+      ok: false,
+      reason: "no_pending_question_interaction",
+    });
+  });
+
+  test("a multi-question interaction is refused (cards are single-question)", async () => {
+    pendingInteractions.register("req-q1", {
+      conversationId: "conv-1",
+      kind: "question",
+      rpcResolve: () => {},
+      metadata: {
+        orderedIds: ["q1", "q2"],
+        optionsById: { q1: ["a"], q2: ["b"] },
+      },
+    });
+
+    const result = await resolver!.resolve(
+      makeContext({ action: "approve_once", userText: "answer_0" }),
+    );
+
+    expect(result).toEqual({ ok: false, reason: "question_batch_not_single" });
+    expect(pendingInteractions.get("req-q1")).toBeDefined();
+  });
+});

package/src/__tests__/assistant-event-hub-self-exclusion.test.ts

@@ -14,14 +14,14 @@
  */
 import { describe, expect, test } from "bun:test";
 
-import type { AssistantEvent } from "../runtime/assistant-event.js";
+import type { AssistantEventEnvelope } from "../api/index.js";
 import {
   AssistantEventHub,
   assistantEventHub,
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
 
-function makeSyncChangedEvent(originClientId?: string): AssistantEvent {
+function makeSyncChangedEvent(originClientId?: string): AssistantEventEnvelope {
   return {
     id: "evt_test_sync",
     conversationId: undefined,
@@ -37,9 +37,9 @@ function makeSyncChangedEvent(originClientId?: string): AssistantEvent {
 describe("AssistantEventHub — self-echo suppression (excludeClientId)", () => {
   test("skips the named client and delivers to every other client", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
-    const receivedC: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
+    const receivedC: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -82,8 +82,8 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
 
   test("delivers to every subscriber when excludeClientId is omitted", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -112,7 +112,7 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
 
   test("excludeClientId does not match process-type subscribers", async () => {
     const hub = new AssistantEventHub();
-    const receivedProcess: AssistantEvent[] = [];
+    const receivedProcess: AssistantEventEnvelope[] = [];
 
     // A process subscriber sits in the same hub as a client whose id
     // matches `excludeClientId`. It must never be suppressed because
@@ -134,8 +134,8 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
 
   test("excludeClientId composes with conversation-scoped subscribers", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -159,7 +159,7 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
     });
 
     // Scoped event for sess_x; both clients filter to sess_x; exclude A.
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       id: "evt_scoped",
       conversationId: "sess_x",
       emittedAt: "2026-05-03T00:00:00.000Z",
@@ -179,8 +179,8 @@ describe("AssistantEventHub — self-echo suppression (excludeClientId)", () =>
 
 describe("broadcastMessage — derives excludeClientId from sync_changed.originClientId", () => {
   test("skips the originating client when originClientId is present", async () => {
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     const subA = assistantEventHub.subscribe({
       type: "client",
@@ -221,8 +221,8 @@ describe("broadcastMessage — derives excludeClientId from sync_changed.originC
   });
 
   test("fans out to every client when originClientId is absent", async () => {
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     const subA = assistantEventHub.subscribe({
       type: "client",
@@ -260,7 +260,7 @@ describe("broadcastMessage — derives excludeClientId from sync_changed.originC
   });
 
   test("ignores an empty-string originClientId (treats as absent)", async () => {
-    const receivedA: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
 
     const subA = assistantEventHub.subscribe({
       type: "client",

package/src/__tests__/assistant-event-hub-targeted.test.ts

@@ -13,10 +13,12 @@
  */
 import { describe, expect, test } from "bun:test";
 
-import type { AssistantEvent } from "../runtime/assistant-event.js";
+import type { AssistantEventEnvelope } from "../api/index.js";
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
 
-function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
+function makeEvent(
+  overrides: Partial<AssistantEventEnvelope> = {},
+): AssistantEventEnvelope {
   return {
     id: "evt_test",
     conversationId: "sess_web",
@@ -35,8 +37,8 @@ function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
 describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
   test("delivers only to the named client, bypassing conversation filter", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     // client-a is subscribed to "sess_macos" — different from the event's "sess_web"
     hub.subscribe({
@@ -75,8 +77,8 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 
   test("does not deliver to a client with a different clientId", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -106,7 +108,7 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 
   test("targeted delivery with wrong capability does not deliver", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
 
     // client-a only has host_file capability, NOT host_bash
     hub.subscribe({
@@ -130,7 +132,7 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 
   test("targeted delivery with matching capability delivers", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",
@@ -152,7 +154,7 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 
   test("process-type subscriber is never matched by targetClientId", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -173,8 +175,8 @@ describe("AssistantEventHub — targeted delivery (targetClientId)", () => {
 describe("AssistantEventHub — untargeted capability targeting is unchanged", () => {
   test("targetCapability without targetClientId still applies conversation scoping", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "client",

package/src/__tests__/assistant-event-hub.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import type { AssistantEvent } from "../runtime/assistant-event.js";
+import type { AssistantEventEnvelope } from "../api/index.js";
 import {
   AssistantEventHub,
   broadcastMessage,
@@ -12,7 +12,9 @@ import {
 } from "../runtime/assistant-stream-state.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 
-function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
+function makeEvent(
+  overrides: Partial<AssistantEventEnvelope> = {},
+): AssistantEventEnvelope {
   return {
     id: "evt_test",
     conversationId: "sess_1",
@@ -31,7 +33,7 @@ function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
 describe("AssistantEventHub — fanout", () => {
   test("delivers event to a single matching subscriber", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -75,8 +77,8 @@ describe("AssistantEventHub — fanout", () => {
 
   test("conversationId filter further restricts delivery", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -101,7 +103,7 @@ describe("AssistantEventHub — fanout", () => {
 
   test("subscriber without conversationId filter receives all conversations", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -159,7 +161,7 @@ describe("AssistantEventHub — fanout", () => {
 describe("AssistantEventHub — unsubscribe cleanup", () => {
   test("dispose stops event delivery", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
 
     const s = hub.subscribe({
       type: "process",
@@ -234,8 +236,8 @@ describe("AssistantEventHub — unsubscribe cleanup", () => {
 
   test("disposing one subscription does not affect others", async () => {
     const hub = new AssistantEventHub();
-    const received1: AssistantEvent[] = [];
-    const received2: AssistantEvent[] = [];
+    const received1: AssistantEventEnvelope[] = [];
+    const received2: AssistantEventEnvelope[] = [];
 
     const s1 = hub.subscribe({
       type: "process",
@@ -341,7 +343,7 @@ describe("AssistantEventHub — exception isolation", () => {
 describe("AssistantEventHub — re-entrancy / snapshot isolation", () => {
   test("subscriber added during publish does not receive the in-flight event", async () => {
     const hub = new AssistantEventHub();
-    const lateReceived: AssistantEvent[] = [];
+    const lateReceived: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -363,7 +365,7 @@ describe("AssistantEventHub — re-entrancy / snapshot isolation", () => {
 
   test("subscriber that disposes itself mid-publish does not affect remaining subscribers", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
     let s: ReturnType<typeof hub.subscribe>;
 
     // eslint-disable-next-line prefer-const

package/src/__tests__/assistant-event.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import type { AssistantEvent } from "../runtime/assistant-event.js";
+import type { AssistantEventEnvelope } from "../api/index.js";
 import {
   formatSseFrame,
   formatSseHeartbeat,
@@ -8,9 +8,9 @@ import {
 
 // ── Type / shape tests ────────────────────────────────────────────────────────
 
-describe("AssistantEvent shape", () => {
+describe("AssistantEventEnvelope shape", () => {
   test("accepts a minimal valid event", () => {
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       id: "evt_001",
       emittedAt: "2026-02-18T21:20:00.000Z",
       message: {
@@ -27,7 +27,7 @@ describe("AssistantEvent shape", () => {
   });
 
   test("accepts a full event with conversationId", () => {
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       id: "evt_002",
       conversationId: "conv_456",
       emittedAt: "2026-02-18T21:20:00.000Z",
@@ -45,7 +45,7 @@ describe("AssistantEvent shape", () => {
 // ── SSE framing tests ─────────────────────────────────────────────────────────
 
 describe("formatSseFrame", () => {
-  const baseEvent: AssistantEvent = {
+  const baseEvent: AssistantEventEnvelope = {
     id: "evt_003",
     conversationId: "sess_xyz",
     emittedAt: "2026-02-18T00:00:00.000Z",
@@ -73,7 +73,7 @@ describe("formatSseFrame", () => {
     const dataLine = frame.split("\n").find((l) => l.startsWith("data: "))!;
     const parsed = JSON.parse(
       dataLine.slice("data: ".length),
-    ) as AssistantEvent;
+    ) as AssistantEventEnvelope;
 
     expect(parsed.id).toBe(baseEvent.id);
     expect(parsed.conversationId).toBe(baseEvent.conversationId);
@@ -82,13 +82,16 @@ describe("formatSseFrame", () => {
   });
 
   test("id line uses the event id verbatim", () => {
-    const event: AssistantEvent = { ...baseEvent, id: "unique-evt-id-xyz" };
+    const event: AssistantEventEnvelope = {
+      ...baseEvent,
+      id: "unique-evt-id-xyz",
+    };
     const frame = formatSseFrame(event);
     expect(frame).toContain("id: unique-evt-id-xyz\n");
   });
 
   test("strips newline characters from event.id to prevent SSE frame injection", () => {
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       ...baseEvent,
       id: 'foo\ndata: {"injected":true}',
     };
@@ -113,7 +116,7 @@ describe("formatSseFrame", () => {
   });
 
   test("seq lands in the JSON payload (envelope) when set, never in SSE id", () => {
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       ...baseEvent,
       id: "uuid-event-id",
       seq: 42,

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

@@ -7,7 +7,7 @@ import { describe, expect, test } from "bun:test";
  * Guard tests for assistant feature flags.
  *
  * 1. Key format validation: ensure production code uses the canonical
- *    simple kebab-case format (e.g., "browser", "voice-mode"), not the
+ *    simple kebab-case format (e.g., "browser", "contacts"), not the
  *    legacy `skills.<id>.enabled` format.
  *
  * 2. Declaration coverage: ensure all assistant-scope flag keys in the
@@ -123,7 +123,7 @@ describe("assistant feature flag guard", () => {
     if (violations.length > 0) {
       const message = [
         "Found production files using the legacy `skills.<id>.enabled` key format.",
-        'New code must use the canonical simple kebab-case format (e.g., "browser", "voice-mode").',
+        'New code must use the canonical simple kebab-case format (e.g., "browser", "contacts").',
         'See AGENTS.md "Assistant Feature Flags" for the convention.',
         "",
         "Violations:",
@@ -153,7 +153,7 @@ describe("assistant feature flag guard", () => {
     if (violations.length > 0) {
       const message = [
         "Found assistant-scope keys in the unified registry that do not match the canonical format.",
-        'Expected format: simple kebab-case (e.g., "browser", "voice-mode")',
+        'Expected format: simple kebab-case (e.g., "browser", "contacts")',
         "",
         "Violations:",
         ...violations.map((k) => `  - ${k}`),

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

@@ -2,7 +2,7 @@
  * Guard tests for assistant feature flag conventions:
  *
  * 1. Key format: all feature flag keys used in production code must use
- *    simple kebab-case format (e.g., "browser", "voice-mode"). Any remaining
+ *    simple kebab-case format (e.g., "browser", "contacts"). Any remaining
  *    `skills.<id>.enabled` usage outside of migration/backward-compat code is
  *    flagged — including template literal forms like `skills.${skillId}.enabled`.
  *

package/src/__tests__/assistant-id-boundary-guard.test.ts

@@ -312,64 +312,6 @@ describe("assistant ID boundary", () => {
   // surfaces invites callers to pass external IDs into daemon scoping.
   // -------------------------------------------------------------------------
 
-  test("message contract types do not contain assistantId for guardian requests", () => {
-    const contractPath = join(
-      import.meta.dir,
-      "..",
-      "daemon",
-      "message-types",
-      "integrations.ts",
-    );
-    const content = readFileSync(contractPath, "utf-8");
-
-    // Extract the interface blocks for the request types and verify
-    // none of them declare an assistantId property.
-    const requestTypeNames = ["ChannelVerificationSessionRequest"];
-
-    for (const typeName of requestTypeNames) {
-      // Find the interface/type block — match from the type name to the next
-      // closing brace at the same indentation level. We use a simple heuristic:
-      // find the line declaring the type, then scan forward to the closing '}'.
-      const typeIndex = content.indexOf(typeName);
-      expect(
-        typeIndex,
-        `Expected to find ${typeName} in message contract`,
-      ).toBeGreaterThan(-1);
-
-      // Extract from the type declaration to the next '}' line
-      const blockStart = content.indexOf("{", typeIndex);
-      if (blockStart === -1) continue;
-      let braceDepth = 0;
-      let blockEnd = blockStart;
-      for (let i = blockStart; i < content.length; i++) {
-        if (content[i] === "{") braceDepth++;
-        if (content[i] === "}") braceDepth--;
-        if (braceDepth === 0) {
-          blockEnd = i + 1;
-          break;
-        }
-      }
-      const block = content.slice(blockStart, blockEnd);
-
-      // The block should not contain an assistantId property declaration
-      // (matches "assistantId?" or "assistantId:" on a non-comment line)
-      const lines = block.split("\n");
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (
-          trimmed.startsWith("//") ||
-          trimmed.startsWith("*") ||
-          trimmed.startsWith("/*")
-        )
-          continue;
-        expect(
-          /\bassistantId\s*[?:]/.test(trimmed),
-          `${typeName} must not declare an assistantId property. Found: "${trimmed}"`,
-        ).toBe(false);
-      }
-    }
-  });
-
   test("guardian outbound param interfaces do not contain assistantId", () => {
     const actionsPath = join(
       import.meta.dir,