@vellumai/assistant 0.5.16 → 0.6.0

package/src/__tests__/config-set-platform-guard.test.ts

@@ -0,0 +1,302 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+let mockPlatformClientCreate: () => Promise<Record<
+  string,
+  unknown
+> | null> = async () => null;
+
+let mockLoadRawConfig: () => Record<string, unknown> = () => ({});
+const mockSaveRawConfigCalls: Array<Record<string, unknown>> = [];
+const mockSetNestedValueCalls: Array<{
+  obj: Record<string, unknown>;
+  key: string;
+  value: unknown;
+}> = [];
+let mockGetNestedValue: (
+  obj: Record<string, unknown>,
+  key: string,
+) => unknown = () => undefined;
+
+// ---------------------------------------------------------------------------
+// Mocks — platform/client (controls requirePlatformConnection)
+// ---------------------------------------------------------------------------
+
+mock.module("../platform/client.js", () => ({
+  VellumPlatformClient: {
+    create: () => mockPlatformClientCreate(),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Mocks — config/loader
+// ---------------------------------------------------------------------------
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ services: {} }),
+  loadConfig: () => ({ services: {} }),
+  saveConfig: () => {},
+  invalidateConfigCache: () => {},
+  loadRawConfig: () => mockLoadRawConfig(),
+  saveRawConfig: (raw: Record<string, unknown>) => {
+    mockSaveRawConfigCalls.push(raw);
+  },
+  applyNestedDefaults: (c: unknown) => c,
+  deepMergeMissing: (a: unknown) => a,
+  deepMergeOverwrite: (a: unknown) => a,
+  mergeDefaultWorkspaceConfig: () => {},
+  getNestedValue: (obj: Record<string, unknown>, key: string) =>
+    mockGetNestedValue(obj, key),
+  setNestedValue: (obj: Record<string, unknown>, key: string, value: unknown) =>
+    mockSetNestedValueCalls.push({ obj, key, value }),
+  API_KEY_PROVIDERS: [
+    "anthropic",
+    "openai",
+    "gemini",
+    "ollama",
+    "fireworks",
+    "openrouter",
+    "brave",
+    "perplexity",
+  ],
+}));
+
+// ---------------------------------------------------------------------------
+// Mocks — util/logger (suppress log output)
+// ---------------------------------------------------------------------------
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+  getCliLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+}));
+
+// ---------------------------------------------------------------------------
+// Mocks — oauth/oauth-store (transitive dep of oauth/shared.ts)
+// ---------------------------------------------------------------------------
+
+mock.module("../oauth/oauth-store.js", () => ({
+  disconnectOAuthProvider: async () => "not-found" as const,
+  getConnection: () => undefined,
+  getConnectionByProvider: () => undefined,
+  listConnections: () => [],
+  deleteConnection: () => false,
+  upsertApp: async () => ({}),
+  getApp: () => undefined,
+  getAppByProviderAndClientId: () => undefined,
+  getMostRecentAppByProvider: () => undefined,
+  listApps: () => [],
+  deleteApp: async () => false,
+  getProvider: () => undefined,
+  listProviders: () => [],
+  registerProvider: () => ({}),
+  updateProvider: () => undefined,
+  deleteProvider: () => false,
+  seedProviders: () => {},
+  getActiveConnection: () => undefined,
+  listActiveConnectionsByProvider: () => [],
+  createConnection: () => ({}),
+  isProviderConnected: () => false,
+  updateConnection: () => ({}),
+}));
+
+// ---------------------------------------------------------------------------
+// Import the module under test (after mocks are registered)
+// ---------------------------------------------------------------------------
+
+const { registerConfigCommand } = await import("../cli/commands/config.js");
+
+// ---------------------------------------------------------------------------
+// Test helper
+// ---------------------------------------------------------------------------
+
+async function runCli(
+  args: string[],
+): Promise<{ exitCode: number; stdout: string }> {
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const stdoutChunks: string[] = [];
+
+  process.stdout.write = ((chunk: unknown) => {
+    stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+
+  process.stderr.write = (() => true) as typeof process.stderr.write;
+
+  process.exitCode = 0;
+
+  try {
+    const program = new Command();
+    program.option("--json", "JSON output");
+    program.exitOverride();
+    program.configureOutput({
+      writeErr: () => {},
+      writeOut: (str: string) => stdoutChunks.push(str),
+    });
+    registerConfigCommand(program);
+    await program.parseAsync(args);
+  } catch {
+    if (process.exitCode === 0) process.exitCode = 1;
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  }
+
+  const exitCode = process.exitCode ?? 0;
+  process.exitCode = 0;
+
+  return {
+    exitCode,
+    stdout: stdoutChunks.join(""),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("config set — platform connection guard for service mode paths", () => {
+  beforeEach(() => {
+    // Default: not connected to platform
+    mockPlatformClientCreate = async () => null;
+    mockLoadRawConfig = () => ({});
+    mockSaveRawConfigCalls.length = 0;
+    mockSetNestedValueCalls.length = 0;
+    mockGetNestedValue = () => undefined;
+  });
+
+  test("config set services.inference.mode managed — fails when not connected", async () => {
+    const { exitCode, stdout } = await runCli([
+      "node",
+      "assistant",
+      "--json",
+      "config",
+      "set",
+      "services.inference.mode",
+      "managed",
+    ]);
+
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("vellum platform connect");
+    expect(parsed.error).toContain("Not connected");
+    // Config should NOT have been written
+    expect(mockSaveRawConfigCalls).toHaveLength(0);
+    expect(mockSetNestedValueCalls).toHaveLength(0);
+  });
+
+  test("config set services.image-generation.mode your-own — succeeds without platform connection", async () => {
+    const { exitCode } = await runCli([
+      "node",
+      "assistant",
+      "--json",
+      "config",
+      "set",
+      "services.image-generation.mode",
+      "your-own",
+    ]);
+
+    expect(exitCode).toBe(0);
+    // Config should have been written — setting to "your-own" doesn't need platform
+    expect(mockSetNestedValueCalls).toHaveLength(1);
+    expect(mockSetNestedValueCalls[0]!.key).toBe(
+      "services.image-generation.mode",
+    );
+    expect(mockSetNestedValueCalls[0]!.value).toBe("your-own");
+    expect(mockSaveRawConfigCalls).toHaveLength(1);
+  });
+
+  test("config set calls.enabled true — succeeds without platform connection", async () => {
+    const { exitCode } = await runCli([
+      "node",
+      "assistant",
+      "config",
+      "set",
+      "calls.enabled",
+      "true",
+    ]);
+
+    expect(exitCode).toBe(0);
+    // Config should have been written
+    expect(mockSetNestedValueCalls).toHaveLength(1);
+    expect(mockSetNestedValueCalls[0]!.key).toBe("calls.enabled");
+    expect(mockSetNestedValueCalls[0]!.value).toBe(true);
+    expect(mockSaveRawConfigCalls).toHaveLength(1);
+  });
+
+  test("config get services.inference.mode — works without platform connection", async () => {
+    mockGetNestedValue = (_obj, key) => {
+      if (key === "services.inference.mode") return "your-own";
+      return undefined;
+    };
+
+    const { exitCode } = await runCli([
+      "node",
+      "assistant",
+      "config",
+      "get",
+      "services.inference.mode",
+    ]);
+
+    expect(exitCode).toBe(0);
+    // No writes should have occurred
+    expect(mockSaveRawConfigCalls).toHaveLength(0);
+    expect(mockSetNestedValueCalls).toHaveLength(0);
+  });
+
+  test("config set services.web-search.mode managed — fails when not connected", async () => {
+    const { exitCode, stdout } = await runCli([
+      "node",
+      "assistant",
+      "--json",
+      "config",
+      "set",
+      "services.web-search.mode",
+      "managed",
+    ]);
+
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("vellum platform connect");
+    expect(mockSaveRawConfigCalls).toHaveLength(0);
+  });
+
+  test("config set services.inference.mode managed — succeeds when connected", async () => {
+    mockPlatformClientCreate = async () => ({
+      platformAssistantId: "asst-123",
+      fetch: async () => new Response(),
+    });
+
+    const { exitCode } = await runCli([
+      "node",
+      "assistant",
+      "config",
+      "set",
+      "services.inference.mode",
+      "managed",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(mockSetNestedValueCalls).toHaveLength(1);
+    expect(mockSetNestedValueCalls[0]!.key).toBe("services.inference.mode");
+    expect(mockSetNestedValueCalls[0]!.value).toBe("managed");
+    expect(mockSaveRawConfigCalls).toHaveLength(1);
+  });
+});

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -8,7 +8,7 @@
  * 4. Missing guardian binding causes a skip
  */
 
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -76,7 +76,7 @@ import {
   generateCanonicalRequestCode,
   listCanonicalGuardianDeliveries,
 } from "../memory/canonical-guardian-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { bridgeConfirmationRequestToGuardian } from "../runtime/confirmation-request-guardian-bridge.js";
 
 initializeDb();
@@ -87,10 +87,6 @@ function resetTables(): void {
   db.run("DELETE FROM canonical_guardian_requests");
 }
 
-afterAll(() => {
-  resetDb();
-});
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/src/__tests__/contacts-tools.test.ts

@@ -137,6 +137,37 @@ describe("contact_upsert tool", () => {
     expect(result.content).toContain("slack: @bob");
   });
 
+  test("ignores external identity bindings supplied through tool input", async () => {
+    const result = await executeContactUpsert(
+      {
+        display_name: "Eve",
+        channels: [
+          {
+            type: "slack",
+            address: "@eve",
+            external_user_id: "UATTACKER",
+            external_chat_id: "DATTACKER",
+          },
+        ],
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+
+    const row = getRawDb()
+      .query(
+        "SELECT external_user_id, external_chat_id FROM contact_channels WHERE type = 'slack' AND address = '@eve'",
+      )
+      .get() as {
+      external_user_id: string | null;
+      external_chat_id: string | null;
+    };
+
+    expect(row.external_user_id).toBeNull();
+    expect(row.external_chat_id).toBeNull();
+  });
+
   test("updates an existing contact by ID", async () => {
     const createResult = await executeContactUpsert(
       { display_name: "Charlie" },

package/src/__tests__/context-overflow-reducer.test.ts

@@ -467,6 +467,92 @@ describe("context-overflow-reducer", () => {
     });
   });
 
+  describe("budget-aware media stubbing", () => {
+    test("media stubbing tier retains images within budget", async () => {
+      // Create messages with multiple image-only user messages (5 images in the
+      // latest user message). With budget-aware retention, the reducer should
+      // keep more than the old hardcoded limit of 3 when targetTokens is high.
+      const makeImageBlock = () => ({
+        type: "image" as const,
+        source: {
+          type: "base64" as const,
+          media_type: "image/png" as const,
+          // Small base64 payload so each image doesn't cost many tokens
+          data: "A".repeat(1_000),
+        },
+      });
+
+      const messages: Message[] = [
+        msg("user", "Here are some old images"),
+        {
+          role: "user",
+          content: [makeImageBlock(), makeImageBlock()],
+        },
+        msg("assistant", "I see the old images."),
+        msg("user", "And some more old images"),
+        {
+          role: "user",
+          content: [makeImageBlock()],
+        },
+        msg("assistant", "Got those too."),
+        // Latest user message with 5 images — should retain more than 3
+        {
+          role: "user",
+          content: [
+            makeImageBlock(),
+            makeImageBlock(),
+            makeImageBlock(),
+            makeImageBlock(),
+            makeImageBlock(),
+          ],
+        },
+      ];
+
+      // Set targetTokens very high so all images in the latest message fit
+      const config = makeConfig({
+        targetTokens: 500_000,
+      });
+      const compactFn = makeNoOpCompactFn();
+
+      // Run through forced_compaction and tool_result_truncation first
+      const step1 = await reduceContextOverflow(
+        messages,
+        config,
+        undefined,
+        compactFn,
+      );
+      expect(step1.tier).toBe("forced_compaction");
+
+      const step2 = await reduceContextOverflow(
+        step1.messages,
+        config,
+        step1.state,
+        compactFn,
+      );
+      expect(step2.tier).toBe("tool_result_truncation");
+
+      // Now apply media stubbing
+      const step3 = await reduceContextOverflow(
+        step2.messages,
+        config,
+        step2.state,
+        compactFn,
+      );
+      expect(step3.tier).toBe("media_stubbing");
+
+      // Count remaining image blocks in the latest user message
+      const latestUserMsg = step3.messages[step3.messages.length - 1];
+      expect(latestUserMsg.role).toBe("user");
+      const remainingImages = latestUserMsg.content.filter(
+        (b) => b.type === "image",
+      );
+
+      // With budget-aware retention and a high target, all 5 images should be
+      // retained — more than the old hardcoded limit of 3.
+      expect(remainingImages.length).toBeGreaterThan(3);
+    });
+  });
+
   describe("createInitialReducerState", () => {
     test("returns a clean state with no applied tiers", () => {
       const state = createInitialReducerState();

package/src/__tests__/context-token-estimator.test.ts

@@ -9,6 +9,27 @@ import {
 } from "../context/token-estimator.js";
 import type { Message } from "../providers/types.js";
 
+/** Build a minimal valid PNG header with the given dimensions, returned as base64. */
+function makePngBase64(width: number, height: number): string {
+  const header = Buffer.alloc(24);
+  header[0] = 0x89;
+  header[1] = 0x50;
+  header[2] = 0x4e;
+  header[3] = 0x47;
+  header[4] = 0x0d;
+  header[5] = 0x0a;
+  header[6] = 0x1a;
+  header[7] = 0x0a;
+  header.writeUInt32BE(13, 8);
+  header[12] = 0x49;
+  header[13] = 0x48;
+  header[14] = 0x44;
+  header[15] = 0x52;
+  header.writeUInt32BE(width, 16);
+  header.writeUInt32BE(height, 20);
+  return header.toString("base64");
+}
+
 describe("token estimator", () => {
   test("estimates text tokens from character length", () => {
     expect(estimateTextTokens("")).toBe(0);
@@ -48,7 +69,7 @@ describe("token estimator", () => {
           data: "a".repeat(100),
         },
       }),
-    ).toBeGreaterThan(500);
+    ).toBeGreaterThan(0);
   });
 
   test("estimates message and prompt totals", () => {
@@ -264,9 +285,11 @@ describe("token estimator", () => {
       { providerName: "anthropic" },
     );
 
-    // 1920x1080 scaled to fit 1568x1568: scale = 1568/1920 = 0.8167
+    // 1920x1080 scaled to fit 1568px bounding box: dimScale = 1568/1920 = 0.8167
     // scaledWidth = round(1920 * 0.8167) = 1568, scaledHeight = round(1080 * 0.8167) = 882
-    // tokens = ceil(1568 * 882 / 750) = ceil(1843.968) = ~1844
+    // pixels = 1568 * 882 = 1,382,976 > 1,200,000 → mpScale = sqrt(1200000/1382976) = 0.9315
+    // scaledWidth = round(1568 * 0.9315) = 1461, scaledHeight = round(882 * 0.9315) = 822
+    // tokens = ceil(1461 * 822 / 750) = ceil(1601.26) = ~1,602
     // With IMAGE_BLOCK_OVERHEAD_TOKENS and media_type overhead, still well under 5000
     expect(anthropicTokens).toBeLessThan(5_000);
 
@@ -299,13 +322,10 @@ describe("token estimator", () => {
       { providerName: "anthropic" },
     );
 
-    // Should fall back to ANTHROPIC_IMAGE_MAX_TOKENS (~3,277)
-    // The total will include IMAGE_BLOCK_OVERHEAD_TOKENS + media_type overhead,
-    // but the max is applied at the outer Math.max(IMAGE_BLOCK_TOKENS, ...) level
-    // ANTHROPIC_IMAGE_MAX_TOKENS = ceil(1568*1568/750) = 3277
-    // Total = max(1024, 16 + ceil(9/4) + 3277) = max(1024, 3296) = 3296
-    expect(tokens).toBeGreaterThanOrEqual(3_277);
-    expect(tokens).toBeLessThan(4_000);
+    // Should fall back to ANTHROPIC_IMAGE_MAX_TOKENS (1,600)
+    // Total = 16 (block overhead) + ceil(9/4) (media_type) + 1600 = 1619
+    expect(tokens).toBeGreaterThanOrEqual(1_600);
+    expect(tokens).toBeLessThan(2_000);
   });
 
   test("Anthropic image tokens are the same for same-dimension images regardless of payload size", () => {
@@ -356,4 +376,149 @@ describe("token estimator", () => {
     // For Anthropic, same dimensions should produce the same estimate
     expect(largeTokens).toBe(smallTokens);
   });
+
+  test("applies megapixel cap for square images on Anthropic", () => {
+    // Build a minimal valid PNG header encoding 2000x2000 dimensions.
+    const pngHeader = Buffer.alloc(24);
+    // PNG signature
+    pngHeader[0] = 0x89;
+    pngHeader[1] = 0x50;
+    pngHeader[2] = 0x4e;
+    pngHeader[3] = 0x47;
+    pngHeader[4] = 0x0d;
+    pngHeader[5] = 0x0a;
+    pngHeader[6] = 0x1a;
+    pngHeader[7] = 0x0a;
+    // IHDR chunk length (13 bytes)
+    pngHeader.writeUInt32BE(13, 8);
+    // "IHDR"
+    pngHeader[12] = 0x49;
+    pngHeader[13] = 0x48;
+    pngHeader[14] = 0x44;
+    pngHeader[15] = 0x52;
+    // Width: 2000
+    pngHeader.writeUInt32BE(2000, 16);
+    // Height: 2000
+    pngHeader.writeUInt32BE(2000, 20);
+
+    const base64Data = pngHeader.toString("base64");
+
+    const tokens = estimateContentBlockTokens(
+      {
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data: base64Data },
+      },
+      { providerName: "anthropic" },
+    );
+
+    // 2000x2000 → dimScale = 1568/2000 = 0.784 → 1568x1568 = 2,458,624 pixels
+    // 2,458,624 > 1,200,000 → mpScale = sqrt(1200000/2458624) ≈ 0.6987
+    // scaledWidth = round(1568 * 0.6987) = 1096, scaledHeight = round(1568 * 0.6987) = 1096
+    // tokens = ceil(1096 * 1096 / 750) = ceil(1601.6) ≈ 1602
+    // Without megapixel cap would have been ceil(1568 * 1568 / 750) ≈ 3277
+    expect(tokens).toBeLessThanOrEqual(1_700);
+  });
+
+  test("small Anthropic images are not inflated to 1024 tokens", () => {
+    // 200x200 image: ceil(200*200/750) = ceil(53.33) = 54 tokens
+    const tokens = estimateContentBlockTokens(
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/png",
+          data: makePngBase64(200, 200),
+        },
+      },
+      { providerName: "anthropic" },
+    );
+
+    // 54 (dimension-based) + 16 (block overhead) + 3 (media type) = 73
+    expect(tokens).toBeLessThan(100);
+    expect(tokens).toBeGreaterThan(50);
+  });
+
+  test("thumbnail Anthropic images estimate accurately", () => {
+    // 150x150 image: ceil(150*150/750) = ceil(30) = 30 tokens
+    const tokens = estimateContentBlockTokens(
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/png",
+          data: makePngBase64(150, 150),
+        },
+      },
+      { providerName: "anthropic" },
+    );
+
+    // 30 + 16 + 3 = 49
+    expect(tokens).toBeLessThan(70);
+    expect(tokens).toBeGreaterThan(30);
+  });
+
+  test("many small Anthropic images do not trigger phantom token inflation", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: Array.from({ length: 100 }, () => ({
+          type: "image" as const,
+          source: {
+            type: "base64" as const,
+            media_type: "image/png",
+            data: makePngBase64(200, 200),
+          },
+        })),
+      },
+    ];
+
+    const total = estimateMessagesTokens(messages, { providerName: "anthropic" });
+
+    // Each image: ~73 tokens. 100 images + message overhead ≈ 7,304
+    // Old behavior: 100 * ~1,043 = ~104,300 (14x overestimate)
+    expect(total).toBeLessThan(10_000);
+  });
+
+  test("matches Anthropic's published table for common aspect ratios", () => {
+    // These are the max sizes that should NOT be further scaled (at or below the megapixel cap).
+    // 1:1 → 1092x1092 (~1,590 tokens)
+    const squareTokens = estimateContentBlockTokens(
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/png",
+          data: makePngBase64(1092, 1092),
+        },
+      },
+      { providerName: "anthropic" },
+    );
+
+    // 1:2 → 784x1568 (~1,639 tokens)
+    const tallTokens = estimateContentBlockTokens(
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/png",
+          data: makePngBase64(784, 1568),
+        },
+      },
+      { providerName: "anthropic" },
+    );
+
+    // 1092x1092 = 1,192,464 pixels < 1,200,000 → no megapixel scaling needed.
+    // tokens = ceil(1092 * 1092 / 750) = ceil(1589.95) ≈ 1590
+    // With overhead: 16 + 3 + 1590 = 1609
+    expect(squareTokens).toBeGreaterThan(1_400);
+    expect(squareTokens).toBeLessThan(1_800);
+
+    // 784*1568 = 1,229,312 > 1,200,000 → slight scaling applies
+    // mpScale = sqrt(1200000/1229312) ≈ 0.9881
+    // scaledWidth = round(784 * 0.9881) = 775, scaledHeight = round(1568 * 0.9881) = 1549
+    // tokens = ceil(775 * 1549 / 750) = ceil(1600.6) ≈ 1601
+    // With overhead: 16 + 3 + 1601 = 1620
+    expect(tallTokens).toBeGreaterThan(1_400);
+    expect(tallTokens).toBeLessThan(1_800);
+  });
 });

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -457,6 +457,15 @@ function makeCtx(
       assistantMessageChannel: "vellum" as const,
     }),
 
+    graphMemory: {
+      onCompacted: () => {},
+      prepareMemory: async () => ({ runMessages: [], injectedTokens: 0, latencyMs: 0, mode: "none" as const }),
+      reinjectCachedMemory: (messages: Message[]) => ({
+        runMessages: messages,
+        injectedTokens: 0,
+      }),
+    } as unknown as AgentLoopConversationContext["graphMemory"],
+
     ...overrides,
   } as AgentLoopConversationContext;
 }