@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/__tests__/llm-request-log-source-clickhouse.test.ts

@@ -134,7 +134,9 @@ describe("ClickHouseLlmRequestLogSource", () => {
     const call = recorder[0]!;
     const parsed = new URL(call.url);
     expect(parsed.searchParams.get("database")).toBe("default");
-    expect(parsed.searchParams.get("param_assistant_id")).toBe("asst-fixture-001");
+    expect(parsed.searchParams.get("param_assistant_id")).toBe(
+      "asst-fixture-001",
+    );
     expect(parsed.searchParams.get("param_log_id")).toBe("log-1");
     expect(call.init?.method).toBe("POST");
     const auth = (call.init?.headers as Record<string, string>).Authorization;
@@ -224,6 +226,90 @@ describe("ClickHouseLlmRequestLogSource", () => {
     expect(body).not.toContain(`'msg-b'`);
   });
 
+  test("getRequestLogMetaById returns metadata without selecting either payload column", async () => {
+    // GIVEN a stored row in ClickHouse
+    const recorder: FakeFetchCall[] = [];
+    const metaRow = {
+      id: "log-1",
+      conversation_id: "conv-1",
+      message_id: "msg-1",
+      provider: "anthropic",
+      created_at: "1778465138786",
+      agent_loop_exit_reason: "no_tool_calls",
+      call_site: "compactionAgent",
+    };
+    const src = makeSource({
+      body: JSON.stringify(metaRow) + "\n",
+      recorder,
+    });
+
+    // WHEN looking it up by id
+    const row = await src.getRequestLogMetaById("log-1");
+
+    // THEN the metadata comes back without payload fields
+    expect(row).toEqual({
+      id: "log-1",
+      conversationId: "conv-1",
+      messageId: "msg-1",
+      provider: "anthropic",
+      createdAt: 1778465138786,
+      agentLoopExitReason: "no_tool_calls",
+      callSite: "compactionAgent",
+    });
+    // AND the query never selects the payload columns (a single request
+    // payload can be a full context window)
+    const body = String(recorder[0]!.init?.body ?? "");
+    expect(body).not.toContain("request_payload");
+    expect(body).not.toContain("response_payload");
+  });
+
+  test("getCompactionLogsBetween computes message count in SQL and skips the request payload", async () => {
+    // GIVEN compaction rows whose message count ClickHouse computed via
+    // JSONLength (Int64 arrives as a quoted string under JSONEachRow)
+    const recorder: FakeFetchCall[] = [];
+    const compactionRow = {
+      id: "log-1",
+      conversation_id: "conv-1",
+      message_id: "",
+      provider: "anthropic",
+      response_payload: '{"bar":2}',
+      request_message_count: "42",
+      created_at: "1778465138786",
+      agent_loop_exit_reason: "",
+      call_site: "compactionAgent",
+    };
+    const src = makeSource({
+      body:
+        JSON.stringify(compactionRow) +
+        "\n" +
+        JSON.stringify({
+          ...compactionRow,
+          id: "log-2",
+          request_message_count: null,
+        }) +
+        "\n",
+      recorder,
+    });
+
+    // WHEN querying the trail window
+    const rows = await src.getCompactionLogsBetween("conv-1", 100, 500);
+
+    // THEN each row carries the numeric message count (null when the
+    // payload had no known message array) and no request payload
+    expect(rows).toHaveLength(2);
+    expect(rows[0]!.requestMessageCount).toBe(42);
+    expect(rows[1]!.requestMessageCount).toBeNull();
+    expect(rows[0]!.responsePayload).toBe('{"bar":2}');
+    expect("requestPayload" in rows[0]!).toBe(false);
+    // AND the SQL only touches request_payload inside JSONLength —
+    // it is never selected as a column
+    const body = String(recorder[0]!.init?.body ?? "");
+    expect(body).toContain("JSONLength(request_payload");
+    expect(body.match(/request_payload/g)).toHaveLength(
+      body.match(/JSONLength\(request_payload/g)!.length,
+    );
+  });
+
   test("missing clickhouse:url credential surfaces a clear error", async () => {
     const src = new ClickHouseLlmRequestLogSource(DEFAULT_CONFIG, {
       resolveUrl: async () => null,

package/src/__tests__/llm-resolver.test.ts

@@ -341,6 +341,97 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.verbosity).toBe("low");
   });
 
+  test("forceOverrideProfile floats the override profile above site profile and callsite fields for non-main call sites", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        active: { verbosity: "low" },
+        sitep: { effort: "none", speed: "fast" },
+        forced: {
+          model: "claude-haiku-4-5",
+          effort: "high",
+          thinking: { enabled: false },
+        },
+      },
+      callSites: {
+        memoryExtraction: { profile: "sitep", maxTokens: 1000 },
+      },
+      activeProfile: "active",
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm, {
+      overrideProfile: "forced",
+      forceOverrideProfile: true,
+    });
+    // Forced override wins over both the site profile and the call-site
+    // override fields it touches.
+    expect(resolved.model).toBe("claude-haiku-4-5");
+    expect(resolved.effort).toBe("high");
+    expect(resolved.thinking.enabled).toBe(false);
+    // Call-site layers still win where the forced profile is silent.
+    expect(resolved.maxTokens).toBe(1000);
+    expect(resolved.speed).toBe("fast");
+    // Active profile still applies under everything.
+    expect(resolved.verbosity).toBe("low");
+  });
+
+  test("forceOverrideProfile absent leaves the override below callsite fields (unchanged precedence)", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        forced: { effort: "high" },
+      },
+      callSites: {
+        memoryExtraction: { effort: "none" },
+      },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm, {
+      overrideProfile: "forced",
+    });
+    expect(resolved.effort).toBe("none");
+  });
+
+  test("forceOverrideProfile with a missing profile reference falls through to unchanged precedence", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        sitep: { effort: "low", model: "claude-haiku-4-5" },
+      },
+      callSites: {
+        memoryExtraction: { profile: "sitep" },
+      },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm, {
+      overrideProfile: "nonexistent",
+      forceOverrideProfile: true,
+    });
+    // The missing reference is inert: site profile still wins.
+    expect(resolved.effort).toBe("low");
+    expect(resolved.model).toBe("claude-haiku-4-5");
+  });
+
+  test("forceOverrideProfile is a no-op for mainAgent (override already resolves on top)", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        active: { effort: "low" },
+        override: { effort: "high" },
+      },
+      callSites: {
+        mainAgent: { effort: "none" },
+      },
+      activeProfile: "active",
+    });
+    const withForce = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "override",
+      forceOverrideProfile: true,
+    });
+    const withoutForce = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "override",
+    });
+    expect(withForce).toEqual(withoutForce);
+    expect(withForce.effort).toBe("high");
+  });
+
   test("overrideProfile absent leaves prior behavior intact", () => {
     // No `opts` argument at all — the resolver must behave exactly as it did
     // before this PR for configs without activeProfile/overrideProfile.
@@ -579,6 +670,30 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.effort).toBe("medium");
   });
 
+  test("workflowLeaf defaults to the cost-optimized profile", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: {
+          model: "claude-sonnet-4-7",
+          effort: "medium",
+        },
+        "cost-optimized": {
+          model: "claude-haiku-4-5-20251001",
+          effort: "low",
+        },
+      },
+    });
+
+    expect(resolveDefaultProfileKey("workflowLeaf", llm)).toBe(
+      "cost-optimized",
+    );
+    const resolved = resolveCallSiteConfig("workflowLeaf", llm);
+    expect(resolved.model).toBe("claude-haiku-4-5-20251001");
+    expect(resolved.effort).toBe("low");
+    expect(resolved.thinking.enabled).toBe(false);
+  });
+
   test("explicit callSites config overrides CALL_SITE_DEFAULTS", () => {
     const llm = LLMSchema.parse({
       default: fullDefault,

package/src/__tests__/managed-profile-guard.test.ts

@@ -66,6 +66,7 @@ mock.module("../config/loader.js", () => ({
     deepMergeForTest(target, overrides);
   },
   getConfig: () => rawConfig,
+  getDeploymentContextDefaults: () => ({}),
   invalidateConfigCache: () => {},
   withSuppressedConfigDiskWrites: async (fn: () => unknown) => fn(),
   withSuppressedConfigDiskWritesSync: (fn: () => unknown) => fn(),
@@ -321,7 +322,7 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
     const result = await patchRoute.handler({
       body: { llm: { profiles: { "custom-balanced": null } } },
     });
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("llm");
   });
 
   test("allows deletion of a user-defined profile via null", async () => {
@@ -329,14 +330,14 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
     const result = await patchRoute.handler({
       body: { llm: { profiles: { "my-custom": null } } },
     });
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("llm");
   });
 
   test("allows non-profile config patches", async () => {
     const result = await patchRoute.handler({
       body: { someOtherKey: "value" },
     });
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("llm");
   });
 
   test("clears stale Velay ownership when manually patching public base URL", async () => {
@@ -353,7 +354,7 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
       },
     });
 
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("ingress");
     expect(savedRaw).toEqual({
       ingress: {
         publicBaseUrl: "https://manual.example.test",
@@ -371,7 +372,7 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
         },
       },
     });
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("llm");
   });
 
   test("rejects nulling the entire profiles map", async () => {

package/src/__tests__/max-tokens-continue-hook.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Tests for the default `max-tokens-continue` plugin's hooks.
+ *
+ * Covers:
+ * - The `post-model-call` hook's decision for the canonical cases: a
+ *   main-agent turn truncated at the output token limit → continue, with the
+ *   truncated turn and the canonical continuation nudge appended to
+ *   `messages`; any other stop reason → stop; non-main-agent call sites →
+ *   stop; a provider rejection → stop; an entirely-stripped (empty) truncated
+ *   turn → stop.
+ * - The per-run budget is split across the two hooks: `post-model-call`
+ *   consumes one unit per continue (up to `MAX_TOKENS_AUTO_CONTINUES`) and
+ *   the `stop` hook clears the counter on the definitive terminal so the next
+ *   run starts with a full budget.
+ *
+ * The loop's actual side-effects (keeping the partial turn, per-run backstop,
+ * the continuation card on a terminal stop) live in `agent/loop.ts`. This
+ * file isolates the hook.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type {
+  PluginLogger,
+  PostModelCallContext,
+  StopContext,
+} from "../plugin-api/types.js";
+import {
+  hasMaxTokensContinueBudget,
+  MAX_TOKENS_AUTO_CONTINUES,
+  resetMaxTokensContinueStoreForTests,
+} from "../plugins/defaults/max-tokens-continue/continue-state-store.js";
+import postModelCall, {
+  MAX_TOKENS_CONTINUE_NUDGE_TEXT,
+} from "../plugins/defaults/max-tokens-continue/hooks/post-model-call.js";
+import stop from "../plugins/defaults/max-tokens-continue/hooks/stop.js";
+import type { ContentBlock } from "../providers/types.js";
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const noopLogger: PluginLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+};
+
+const truncatedText: ContentBlock = {
+  type: "text",
+  text: "Here is the start of a very long answer that got cut o",
+};
+
+function makeCtx(
+  overrides: Partial<PostModelCallContext> = {},
+): PostModelCallContext {
+  return {
+    conversationId: "conv-mtc",
+    callSite: "mainAgent",
+    content: [truncatedText],
+    messages: [{ role: "user", content: [{ type: "text", text: "build it" }] }],
+    stopReason: "max_tokens",
+    decision: "stop",
+    logger: noopLogger,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  resetMaxTokensContinueStoreForTests();
+});
+
+// ─── Decisions ───────────────────────────────────────────────────────────────
+
+describe("max-tokens-continue post-model-call hook", () => {
+  test("truncated main-agent turn → continue with the turn and nudge appended", async () => {
+    /**
+     * Tests that a max_tokens stop on a main-agent turn auto-continues.
+     */
+    // GIVEN a main-agent turn that stopped at the output token limit.
+    const ctx = makeCtx();
+    const priorLength = ctx.messages.length;
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN it asks the loop to continue.
+    expect(ctx.decision).toBe("continue");
+    // AND it appends the truncated assistant turn followed by the nudge.
+    expect(ctx.messages).toHaveLength(priorLength + 2);
+    expect(ctx.messages[priorLength]).toEqual({
+      role: "assistant",
+      content: [truncatedText],
+    });
+    expect(ctx.messages[priorLength + 1]).toEqual({
+      role: "user",
+      content: [{ type: "text", text: MAX_TOKENS_CONTINUE_NUDGE_TEXT }],
+    });
+  });
+
+  test("non-max-tokens stop reason → stop", async () => {
+    /**
+     * Tests that ordinary stop reasons are left alone.
+     */
+    // GIVEN a turn that ended normally.
+    const ctx = makeCtx({ stopReason: "end_turn" });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the decision stays stop and messages are untouched.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toHaveLength(1);
+  });
+
+  test("non-mainAgent call site → stop", async () => {
+    /**
+     * Tests that background/subagent calls are never auto-continued.
+     */
+    // GIVEN a truncated turn on a non-main-agent call site.
+    const ctx = makeCtx({ callSite: "recall" });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the decision stays stop.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toHaveLength(1);
+  });
+
+  test("provider rejection → stop", async () => {
+    /**
+     * Tests that a rejection outcome (no reply content) is ignored.
+     */
+    // GIVEN a provider rejection carrying an error.
+    const ctx = makeCtx({ error: new Error("boom"), content: [] });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the decision stays stop.
+    expect(ctx.decision).toBe("stop");
+  });
+
+  test("empty truncated content → stop", async () => {
+    /**
+     * Tests that a turn with nothing left after truncation-block stripping
+     * ends terminally rather than pushing an empty assistant message.
+     */
+    // GIVEN a max_tokens stop whose safe content is empty.
+    const ctx = makeCtx({ content: [] });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the decision stays stop and nothing is appended.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toHaveLength(1);
+  });
+
+  test("budget exhausts after MAX_TOKENS_AUTO_CONTINUES and stop hook resets it", async () => {
+    /**
+     * Tests the per-run continue budget and its reset on the terminal stop.
+     */
+    // GIVEN the budget is consumed by repeated truncated turns.
+    for (let i = 0; i < MAX_TOKENS_AUTO_CONTINUES; i++) {
+      const ctx = makeCtx();
+      await postModelCall(ctx);
+      expect(ctx.decision).toBe("continue");
+    }
+    expect(hasMaxTokensContinueBudget("conv-mtc")).toBe(false);
+
+    // WHEN one more truncated turn arrives.
+    const exhausted = makeCtx();
+    await postModelCall(exhausted);
+
+    // THEN the hook lets the turn end.
+    expect(exhausted.decision).toBe("stop");
+    expect(exhausted.messages).toHaveLength(1);
+
+    // AND the stop hook clears the budget so the next run continues afresh.
+    await stop({ conversationId: "conv-mtc" } as StopContext);
+    expect(hasMaxTokensContinueBudget("conv-mtc")).toBe(true);
+  });
+});

package/src/__tests__/media-generate-image.test.ts

@@ -322,7 +322,13 @@ describe("image-studio skill script wrapper", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Mock Gemini error: API failure");
     expect(result.content).toContain(
-      "Do not change service configuration (mode, provider, or model) to try to fix it",
+      "Failed model: gemini-3.1-flash-image-preview",
+    );
+    expect(result.content).toContain(
+      "Do not change service configuration (managed/your-own mode or default provider/model settings)",
+    );
+    expect(result.content).toContain(
+      "Retrying this call once with a different model parameter is allowed",
     );
   });
 
@@ -335,7 +341,10 @@ describe("image-studio skill script wrapper", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Mock OpenAI error: openai failure");
     expect(result.content).toContain(
-      "Do not change service configuration (mode, provider, or model) to try to fix it",
+      "Do not change service configuration (managed/your-own mode or default provider/model settings)",
+    );
+    expect(result.content).toContain(
+      "Retrying this call once with a different model parameter is allowed",
     );
   });
 
@@ -346,8 +355,9 @@ describe("image-studio skill script wrapper", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("No Gemini API key");
+    expect(result.content).toContain("Report this error to the user as-is");
     expect(result.content).toContain(
-      "Do not change service configuration (mode, provider, or model) to try to fix it",
+      "Do not change service configuration (managed/your-own mode or default provider/model settings)",
     );
   });
 
@@ -359,8 +369,9 @@ describe("image-studio skill script wrapper", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Managed proxy is not available");
+    expect(result.content).toContain("Report this error to the user as-is");
     expect(result.content).toContain(
-      "Do not change service configuration (mode, provider, or model) to try to fix it",
+      "Do not change service configuration (managed/your-own mode or default provider/model settings)",
     );
   });
 
@@ -463,11 +474,11 @@ describe("image-studio TOOLS.json manifest", () => {
     expect(props.mode.enum).toEqual(["generate", "edit"]);
     expect(props.source_paths.type).toBe("array");
     expect(props.attachment_ids).toBeUndefined();
-    expect(props.model.enum).toEqual([
-      "gemini-3.1-flash-image-preview",
-      "gemini-3-pro-image-preview",
-      "gpt-image-2",
-    ]);
+    // No enum by design: model accepts tier aliases or concrete IDs, and is
+    // validated at runtime against the registry so the schema never goes
+    // stale when models change.
+    expect(props.model.type).toBe("string");
+    expect(props.model.enum).toBeUndefined();
     expect(props.variants.type).toBe("number");
   });
 });

package/src/__tests__/mock-gateway-ipc.ts

@@ -82,6 +82,28 @@ const GET_FEATURE_FLAGS_DEFAULT: Record<string, boolean> = {
   __test_default__: false,
 };
 
+class FakeIpcCallError extends Error {
+  readonly statusCode?: number;
+  readonly errorCode?: string;
+  readonly errorDetails?: unknown;
+
+  constructor(
+    message: string,
+    fields: {
+      statusCode?: number;
+      errorCode?: string;
+      errorDetails?: unknown;
+    } = {},
+  ) {
+    super(message);
+    this.name = "IpcCallError";
+    if (fields.statusCode !== undefined) this.statusCode = fields.statusCode;
+    if (fields.errorCode !== undefined) this.errorCode = fields.errorCode;
+    if (fields.errorDetails !== undefined)
+      this.errorDetails = fields.errorDetails;
+  }
+}
+
 export function installGatewayIpcMock(): void {
   mock.module("@vellumai/gateway-client/ipc-client", () => ({
     ipcCall: async (
@@ -97,6 +119,7 @@ export function installGatewayIpcMock(): void {
       if (method === "get_feature_flags") return GET_FEATURE_FLAGS_DEFAULT;
       return undefined;
     },
+    IpcCallError: FakeIpcCallError,
     PersistentIpcClient: FakePersistentIpcClient,
   }));
 }

package/src/__tests__/model-intents.test.ts

@@ -20,7 +20,7 @@ describe("model intents", () => {
       "claude-haiku-4-5-20251001",
     );
     expect(resolveModelIntent("anthropic", "quality-optimized")).toBe(
-      "claude-fable-5",
+      "claude-opus-4-8",
     );
     expect(resolveModelIntent("anthropic", "vision-optimized")).toBe(
       "claude-opus-4-6",

package/src/__tests__/normalize-onboarding.test.ts

@@ -139,6 +139,32 @@ describe("normalizeOnboardingContext", () => {
     expect(result.preferredName).toBeUndefined();
   });
 
+  test("maps occupation through, trimmed", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "friendly",
+      occupation: "  Software Engineer  ",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.occupation).toBe("Software Engineer");
+  });
+
+  test("absent or blank occupation yields undefined", () => {
+    expect(
+      normalizeOnboardingContext({ tools: [], tasks: [], tone: "friendly" })
+        .occupation,
+    ).toBeUndefined();
+    expect(
+      normalizeOnboardingContext({
+        tools: [],
+        tasks: [],
+        tone: "friendly",
+        occupation: "   ",
+      }).occupation,
+    ).toBeUndefined();
+  });
+
   test("tone passes through", () => {
     const ctx: OnboardingContext = {
       tools: [],

package/src/__tests__/notification-decision-strategy.test.ts

@@ -15,8 +15,6 @@ import {
   hasAccessRequestInstructions,
   hasInviteFlowDirective,
   normalizeForDirectiveMatching,
-  sanitizeIdentityField,
-  sanitizeMessagePreview,
 } from "../notifications/access-request-copy.js";
 import type { ConversationCandidateSet } from "../notifications/conversation-candidates.js";
 import { composeFallbackCopy } from "../notifications/copy-composer.js";
@@ -24,6 +22,10 @@ import {
   enforceGuardianCallConversationAffinity,
   validateConversationActions,
 } from "../notifications/decision-engine.js";
+import {
+  sanitizeIdentityField,
+  sanitizeMessagePreview,
+} from "../notifications/notification-utils.js";
 import type { NotificationSignal } from "../notifications/signal.js";
 import type {
   NotificationChannel,

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

@@ -186,9 +186,18 @@ describe("TelegramAdapter", () => {
       contextPayload: {
         requestId: "req-abc-123",
         requestCode: "XYZW",
-        senderIdentifier: "Marina",
+        senderIdentifier: "TestUser",
         sourceChannel: "telegram",
       },
+      approvalContext: {
+        requestId: "req-abc-123",
+        actions: [
+          { id: "approve_once", label: "Approve once" },
+          { id: "reject", label: "Reject" },
+        ],
+        plainTextFallback:
+          'TestUser is requesting access to the assistant.\nReply "XYZW approve" to grant access or "XYZW reject" to deny.\nReply "open invite flow" to start Trusted Contacts invite flow.',
+      },
     });
 
     const result = await adapter.send(payload, makeDestination());
@@ -237,7 +246,7 @@ describe("TelegramAdapter", () => {
         body: "Someone is requesting access.",
       },
       contextPayload: {
-        senderIdentifier: "Marina",
+        senderIdentifier: "TestUser",
         sourceChannel: "telegram",
         // no requestId
       },
@@ -264,9 +273,18 @@ describe("TelegramAdapter", () => {
       contextPayload: {
         requestId: "req-abc-123",
         requestCode: "XYZW",
-        senderIdentifier: "Marina",
+        senderIdentifier: "TestUser",
         sourceChannel: "telegram",
       },
+      approvalContext: {
+        requestId: "req-abc-123",
+        actions: [
+          { id: "approve_once", label: "Approve once" },
+          { id: "reject", label: "Reject" },
+        ],
+        plainTextFallback:
+          'TestUser is requesting access to the assistant.\nReply "XYZW approve" to grant access or "XYZW reject" to deny.\nReply "open invite flow" to start Trusted Contacts invite flow.',
+      },
     });
 
     const result = await adapter.send(payload, makeDestination());