@vellumai/assistant 0.8.1 → 0.8.3

package/src/memory/graph/conversation-graph-memory.ts

@@ -26,7 +26,7 @@ import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
 import {
-  evictCompactedTurns as evictCompactedTurnsV2,
+  clearEverInjected as clearV2EverInjected,
   hydrate as hydrateV2State,
   save as saveV2State,
 } from "../v2/activation-store.js";
@@ -223,15 +223,17 @@ export class ConversationGraphMemory {
     // Mirror the eviction on the v2 activation row: the cached `<memory>`
     // attachments those slugs lived on are gone, but `everInjected` would
     // otherwise keep them deduped from per-turn deltas forever.
+    //
+    // Cleared unconditionally rather than filtered by `upToTurn`: the
+    // tracker's `currentTurn` is only persisted on graceful dispose while
+    // `everInjected` is persisted every turn, so a SIGKILL'd session can
+    // leave entries with `turn > tracker.currentTurn` that a turn-bounded
+    // filter would skip.
     try {
       const db = getDb();
       const state = await hydrateV2State(db, this.conversationId);
       if (state) {
-        await saveV2State(
-          db,
-          this.conversationId,
-          evictCompactedTurnsV2(state, upToTurn),
-        );
+        await saveV2State(db, this.conversationId, clearV2EverInjected(state));
       }
     } catch (err) {
       log.warn(
@@ -363,6 +365,16 @@ export class ConversationGraphMemory {
       metrics: null as RetrievalMetrics | null,
     };
 
+    if (!config.memory.enabled) {
+      // Clear any cached injection so a later overflow-reduction
+      // re-injection via `reinjectCachedMemory()` cannot reintroduce a
+      // stale <memory> block after the user disables memory.
+      this.lastInjectedBlock = null;
+      this.lastInjectedNodeIds = [];
+      this.lastInjectedImages = new Map();
+      return noopResult;
+    }
+
     // Gate: skip for empty/tool-result-only messages — unless we need to
     // reload after compaction (needsReload) or haven't initialized yet.
     const lastMessage = messages[messages.length - 1];
@@ -438,8 +450,10 @@ export class ConversationGraphMemory {
       // turns. v1's `loadContextMemory` produced these as a side effect of
       // hybrid retrieval; the v2 path skips that retrieval, so embed
       // explicitly here.
+      const userQueryText = rawUserText ?? userQuery ?? "";
       const userQueryEmbed = await this.computeQueryVectors(
-        rawUserText ?? userQuery ?? "",
+        userQueryText,
+        userQueryText,
         config,
         signal,
       );
@@ -598,8 +612,16 @@ export class ConversationGraphMemory {
     if (v2.routed) {
       // Surface a per-turn query embedding so PKB hint search still runs
       // on v2 turns. v1's `retrieveForTurn` produced these as a side effect;
-      // the v2 path skips that retrieval, so embed explicitly here.
+      // the v2 path skips that retrieval, so embed explicitly here. Match
+      // v1's split: dense embeds the combined assistant+user text (short
+      // referential follow-ups like "do that one" need the assistant turn
+      // for semantic grounding), while sparse uses the user message alone
+      // to keep lexical signal focused on what the user actually said.
+      const denseQueryText = [assistantLast, userLast]
+        .filter((m) => m.length > 0)
+        .join("\n\n");
       const perTurnEmbed = await this.computeQueryVectors(
+        denseQueryText,
         userLast,
         config,
         signal,
@@ -697,24 +719,30 @@ export class ConversationGraphMemory {
    * static fallback rather than blocking the turn.
    */
   private async computeQueryVectors(
-    text: string,
+    denseText: string,
+    sparseText: string,
     config: AssistantConfig,
     signal: AbortSignal,
   ): Promise<{ dense?: number[]; sparse?: QdrantSparseVector }> {
-    const trimmed = text.trim();
-    if (trimmed.length === 0) return {};
+    const trimmedDense = denseText.trim();
+    const trimmedSparse = sparseText.trim();
     let dense: number[] | undefined;
-    try {
-      const result = await embedWithRetry(config, [trimmed], { signal });
-      dense = result.vectors[0];
-    } catch (err) {
-      log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
-        "Failed to embed query for PKB hints on v2 path",
-      );
+    if (trimmedDense.length > 0) {
+      try {
+        const result = await embedWithRetry(config, [trimmedDense], { signal });
+        dense = result.vectors[0];
+      } catch (err) {
+        log.warn(
+          { err: err instanceof Error ? err.message : String(err) },
+          "Failed to embed query for PKB hints on v2 path",
+        );
+      }
+    }
+    let sparse: QdrantSparseVector | undefined;
+    if (trimmedSparse.length > 0) {
+      const sparseRaw = generateSparseEmbedding(trimmedSparse);
+      sparse = sparseRaw.indices.length > 0 ? sparseRaw : undefined;
     }
-    const sparseRaw = generateSparseEmbedding(trimmed);
-    const sparse = sparseRaw.indices.length > 0 ? sparseRaw : undefined;
     return { dense, sparse };
   }
 

package/src/memory/graph/tools.ts

@@ -2,8 +2,6 @@
 // Memory Tool definitions for agentic recall and remember.
 // ---------------------------------------------------------------------------
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../../config/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import {
   ALL_RECALL_SOURCES,
@@ -20,7 +18,7 @@ const RECALL_DEPTHS = ["fast", "standard", "deep"] as const;
 export const graphRecallDefinition: ToolDefinition = {
   name: "recall",
   description:
-    'Search local information the moment you feel uncertain. Use recall for memory, past conversations, and workspace files — before you guess, before you ask, before you hedge. Auto-injection is incomplete by design; it surfaces patterns, not the specifics you need to answer well. If you catch yourself reaching for "I think", "I believe", "if I remember", "didn\'t we", "last time" — that\'s the signal. Recall. If the user references someone, a place, a decision, a document, or prior work you should be able to find locally — recall. Call it multiple times per conversation if the turn warrants it. Be specific in your query for best results.',
+    'Search local information the moment you feel uncertain. Use recall for memory, past conversations, and workspace files — before you guess, before you ask, before you hedge. Auto-injection is incomplete by design; it surfaces patterns, not the specifics you need to answer well. If you catch yourself reaching for "I think", "I believe", "if I remember", "didn\'t we", "last time" — that\'s the signal. Recall. If a turn references someone, a place, a decision, a document, or prior work you should be able to find locally — recall. Call it multiple times per conversation if the turn warrants it. Be specific in your query for best results.',
   input_schema: {
     type: "object",
     properties: {
@@ -56,36 +54,13 @@ export const graphRecallDefinition: ToolDefinition = {
 };
 
 /**
- * Default (high-pressure) `remember` tool description. Used when the
- * `memory-retrospective` feature flag is OFF. The volume-shaming language
- * ("almost every turn", "most frequently used tool") drives aggressive
- * in-conversation capture for users who don't have the retrospective
- * backstop enabled.
+ * `remember` tool description. The retrospective pass catches what isn't
+ * captured in the moment, so the in-conversation pressure stays at a
+ * judgment framing: pause when something feels worth marking, not because
+ * the volume is required.
  */
-const REMEMBER_DESCRIPTION_DEFAULT =
-  "Remember anything concrete: facts, preferences, corrections, plans, felt moments, names, dates, decisions. Default to remembering. Never wait until end of conversation. Corrections are highest priority — call remember the same turn the correction lands. **CRITICAL:** You should be calling remember on almost every turn. This should be your most frequently used tool.";
-
-/**
- * Relaxed `remember` tool description used when `memory-retrospective` is
- * ON. The retrospective pass catches what isn't captured in the moment, so
- * the in-conversation pressure eases to a judgment framing: pause when
- * something feels worth marking, not because the volume is required.
- */
-const REMEMBER_DESCRIPTION_RELAXED =
-  "Remember anything concrete the user shared: corrections, plans, decisions, felt moments, names, dates, commitments, preferences. Corrections are the highest priority — call `remember` the same turn the correction lands. You don't have to call this on every turn; a retrospective pass reviews the conversation after each message-count / time interval and saves what you didn't capture. Use judgment: pause and remember when something feels worth marking, not because the volume is required.";
-
-/**
- * Return the description that should appear in the `remember` tool
- * registration for the current config. The variant is selected by the
- * `memory-retrospective` assistant feature flag. Exposed as a function so
- * the tool registrar can compute the value at registration time without
- * importing config layers into the static definition.
- */
-export function getRememberDescription(config: AssistantConfig): string {
-  return isAssistantFeatureFlagEnabled("memory-retrospective", config)
-    ? REMEMBER_DESCRIPTION_RELAXED
-    : REMEMBER_DESCRIPTION_DEFAULT;
-}
+const REMEMBER_DESCRIPTION =
+  "Remember anything concrete shared in conversation: corrections, plans, decisions, felt moments, names, dates, commitments, preferences. Corrections are the highest priority — call `remember` the same turn the correction lands. You don't have to call this on every turn; a retrospective pass reviews the conversation after each message-count / time interval and saves what you didn't capture. Use judgment: pause and remember when something feels worth marking, not because the volume is required.";
 
 /**
  * Save a fact to the assistant's knowledge base. The fact is appended to
@@ -94,16 +69,10 @@ export function getRememberDescription(config: AssistantConfig): string {
  * writes go under `memory/`; otherwise they go under `pkb/`. Consolidation
  * of the buffer into longer-form storage runs as a separate periodic job in
  * both modes.
- *
- * The static `description` field carries the default (high-pressure) text
- * so any direct importer that doesn't go through `getRememberDescription`
- * still gets a valid tool definition. The registered `RememberTool` in
- * `tools/memory/register.ts` overrides this at registration time with the
- * flag-aware variant.
  */
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",
-  description: REMEMBER_DESCRIPTION_DEFAULT,
+  description: REMEMBER_DESCRIPTION,
   input_schema: {
     type: "object",
     properties: {
@@ -115,7 +84,7 @@ export const graphRememberDefinition: ToolDefinition = {
       finish_turn: {
         type: "boolean",
         description:
-          "When you have nothing else to say and want to hand control back to the user you MUST set this to true. When true, your turn ends after this tool call. It's critical that you do this in order to avoid unnecessary LLM calls.",
+          "When you have nothing else to say and want to yield the turn you MUST set this to true. When true, your turn ends after this tool call. It's critical that you do this in order to avoid unnecessary LLM calls.",
       },
     },
     required: ["content"],

package/src/memory/indexer.ts

@@ -169,32 +169,30 @@ export async function indexMessageNow(
     const batchSize = config.extraction.batchSize ?? 10;
     const idleTimeoutMs = config.extraction.idleTimeoutMs ?? 300_000;
 
+    // Reading config here is best-effort: when it fails we treat v2 as
+    // inactive (failing-open to v1) so a config error never silently
+    // drops the extraction or summarization paths.
+    let triggerConfig: ReturnType<typeof getConfig> | null = null;
+    try {
+      triggerConfig = getConfig();
+    } catch (err) {
+      log.debug(
+        { err, conversationId: input.conversationId },
+        "Skipping feature-gated extraction triggers: failed to load config",
+      );
+    }
+
+    const v2Config =
+      triggerConfig != null && triggerConfig.memory.v2.enabled
+        ? triggerConfig
+        : null;
+
     // Recursion guard: skip graph extraction + auto-analysis enqueues
     // when the source conversation is itself an auto-analysis
     // conversation. The analysis agent writes memory directly via tools,
     // so extracting from its reflective musings would double-count and
     // analyzing its own output would loop indefinitely.
-    // Summaries still run — they feed the graph retrieval pipeline and
-    // are not recursion-prone.
     if (!isAutoAnalysisSource) {
-      // Reading config here is best-effort: when it fails we treat v2 as
-      // inactive (failing-open to v1) so a config error never silently
-      // drops both extraction paths.
-      let triggerConfig: ReturnType<typeof getConfig> | null = null;
-      try {
-        triggerConfig = getConfig();
-      } catch (err) {
-        log.debug(
-          { err, conversationId: input.conversationId },
-          "Skipping feature-gated extraction triggers: failed to load config",
-        );
-      }
-
-      const v2Config =
-        triggerConfig != null && triggerConfig.memory.v2.enabled
-          ? triggerConfig
-          : null;
-
       // ── Graph extraction (v1) ───────────────────────────────────────
       // Suppressed when v2 is active — v2 reads memory from buffer.md
       // and concept pages, so the v1 graph would be stale data nobody
@@ -302,15 +300,22 @@ export async function indexMessageNow(
       }
     }
 
-    // ── Conversation summarization (independent of extraction) ────────
-    // Summaries feed the graph retrieval pipeline via fetchRecentSummaries().
-    // Debounced on the same idle timeout — no threshold trigger needed since
-    // summaries compress the whole conversation, not incremental batches.
-    upsertDebouncedJob(
-      "build_conversation_summary",
-      { conversationId: input.conversationId },
-      Date.now() + idleTimeoutMs,
-    );
+    // ── Conversation summarization (v1) ───────────────────────────────
+    // Summaries feed the v1 graph retrieval pipeline (fetchRecentSummaries,
+    // semantic search). Suppressed when v2 is active — v2 readers (concept
+    // pages, activation pipeline) do not consume `memorySummaries`, so the
+    // summarization LLM call would produce rows nothing reads. Stale rows
+    // from before v2 was enabled are short-circuited at dispatch in
+    // jobs-worker.ts. Debounced on the same idle timeout — no threshold
+    // trigger needed since summaries compress the whole conversation, not
+    // incremental batches.
+    if (v2Config == null) {
+      upsertDebouncedJob(
+        "build_conversation_summary",
+        { conversationId: input.conversationId },
+        Date.now() + idleTimeoutMs,
+      );
+    }
   }
 
   if (skippedShortSegments > 0) {

package/src/memory/invite-store.ts

@@ -363,6 +363,59 @@ export function findActiveVoiceInvites(params: {
   return rows.map(rowToInvite);
 }
 
+// ---------------------------------------------------------------------------
+// claimA2AInvite — validate + consume an A2A invite token
+// ---------------------------------------------------------------------------
+
+export function claimA2AInvite(params: {
+  tokenHash: string;
+  redeemedByExternalUserId: string;
+}): { claimed: boolean; invite: IngressInvite | null; error?: string } {
+  const invite = findByTokenHash(params.tokenHash);
+
+  if (!invite) {
+    return { claimed: false, invite: null, error: "not_found" };
+  }
+
+  if (invite.sourceChannel !== "a2a") {
+    return { claimed: false, invite, error: "wrong_channel" };
+  }
+
+  // Idempotency: if already redeemed by the same acceptor, return success
+  if (invite.status === "redeemed") {
+    if (invite.redeemedByExternalUserId === params.redeemedByExternalUserId) {
+      return { claimed: true, invite };
+    }
+    return { claimed: false, invite, error: "already_redeemed_by_other" };
+  }
+
+  if (invite.status !== "active") {
+    return { claimed: false, invite, error: "not_found" };
+  }
+
+  if (Date.now() >= invite.expiresAt) {
+    markInviteExpired(invite.id);
+    return { claimed: false, invite, error: "expired" };
+  }
+
+  if (invite.useCount >= invite.maxUses) {
+    return { claimed: false, invite, error: "already_redeemed" };
+  }
+
+  const recorded = recordInviteUse({
+    inviteId: invite.id,
+    externalUserId: params.redeemedByExternalUserId,
+  });
+
+  if (!recorded) {
+    return { claimed: false, invite, error: "not_found" };
+  }
+
+  // Re-read to get updated state
+  const updated = findByTokenHash(params.tokenHash);
+  return { claimed: true, invite: updated };
+}
+
 // ---------------------------------------------------------------------------
 // findByInviteCodeHash
 // ---------------------------------------------------------------------------

package/src/memory/jobs/__tests__/embed-concept-page.test.ts

@@ -151,6 +151,8 @@ type MemoryJob = ReturnType<MemoryJobMod["claimMemoryJobs"]>[number];
 const { embedConceptPageJob, enqueueEmbedConceptPageJob } =
   await import("../embed-concept-page.js");
 const { writePage } = await import("../../v2/page-store.js");
+const { _resetQdrantBreaker, isQdrantBreakerOpen, withQdrantBreaker } =
+  await import("../../qdrant-circuit-breaker.js");
 
 // Use a tiny vectorSize so the cache-dim check matches our stub vector.
 const TEST_CONFIG = {
@@ -186,6 +188,7 @@ beforeEach(() => {
   embedWithBackendCalls.length = 0;
   upsertCalls.length = 0;
   deleteCalls.length = 0;
+  _resetQdrantBreaker();
 });
 
 afterEach(() => {
@@ -436,6 +439,76 @@ describe("embedConceptPageJob — defensive", () => {
   });
 });
 
+describe("embedConceptPageJob — Qdrant breaker integration", () => {
+  test("half-open probe success closes the breaker so embed catch-up unthrottles", async () => {
+    // Trip the breaker by recording 5 consecutive Qdrant failures. Without
+    // this fix, `embed_concept_page` bypassed the breaker entirely — winning
+    // the half-open probe slot did not transition state back to closed and
+    // the embed lane stayed throttled at one job per tick indefinitely.
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+    expect(isQdrantBreakerOpen()).toBe(true);
+
+    // Advance time past the 30s cooldown so the next breaker call transitions
+    // open → half-open and allows the probe through.
+    const originalNow = Date.now;
+    Date.now = () => originalNow() + 60_000;
+    try {
+      await writePage(tmpWorkspace, {
+        slug: "probe-success",
+        frontmatter: { edges: [], ref_files: [], ref_urls: [] },
+        body: "Probe body.\n",
+      });
+
+      await embedConceptPageJob(
+        makeJob({ slug: "probe-success" }),
+        TEST_CONFIG,
+      );
+    } finally {
+      Date.now = originalNow;
+    }
+
+    expect(upsertCalls).toHaveLength(1);
+    // Probe succeeded → breaker should now be closed (not open, not
+    // half-open), restoring full embed-lane concurrency.
+    expect(isQdrantBreakerOpen()).toBe(false);
+  });
+
+  test("half-open probe success on the delete path also closes the breaker", async () => {
+    // Same flow as above but exercising the missing-page branch — both v2
+    // Qdrant calls (`upsert` and `delete`) must close the breaker on success.
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+    expect(isQdrantBreakerOpen()).toBe(true);
+
+    const originalNow = Date.now;
+    Date.now = () => originalNow() + 60_000;
+    try {
+      // No `writePage` — the handler takes the delete branch.
+      await embedConceptPageJob(makeJob({ slug: "missing-slug" }), TEST_CONFIG);
+    } finally {
+      Date.now = originalNow;
+    }
+
+    expect(deleteCalls).toEqual(["missing-slug"]);
+    expect(isQdrantBreakerOpen()).toBe(false);
+  });
+});
+
 describe("enqueueEmbedConceptPageJob", () => {
   test("enqueues a pending embed_concept_page job with the slug payload", () => {
     const id = enqueueEmbedConceptPageJob({ slug: "alice-prefers-vs-code" });

package/src/memory/jobs/embed-concept-page.ts

@@ -34,6 +34,7 @@ import {
 import { embeddingInputContentHash } from "../embedding-types.js";
 import { asString, blobToVector, vectorToBlob } from "../job-utils.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import { memoryEmbeddings } from "../schema.js";
 import { readPage } from "../v2/page-store.js";
 import {
@@ -81,7 +82,10 @@ export async function embedConceptPageJob(
   if (!page) {
     // Page was deleted out from under us — clean up the prior embedding so
     // retrieval no longer surfaces a slug whose disk-side prose is gone.
-    await deleteConceptPageEmbedding(slug);
+    // Route through the Qdrant breaker so success on the half-open probe
+    // slot transitions the breaker back to closed and unthrottles embed
+    // catch-up.
+    await withQdrantBreaker(() => deleteConceptPageEmbedding(slug));
     return;
   }
 
@@ -280,16 +284,21 @@ export async function embedConceptPageJob(
     ? await applyCorrectionIfCalibrated(summaryDense, writeProvider, writeModel)
     : undefined;
 
-  await upsertConceptPageEmbedding({
-    slug,
-    dense: correctedDense,
-    sparse,
-    summary:
-      correctedSummaryDense && summarySparse
-        ? { dense: correctedSummaryDense, sparse: summarySparse }
-        : undefined,
-    updatedAt: now,
-  });
+  // Route through the Qdrant breaker so a probe-slot success transitions the
+  // breaker back to closed; without this wrapper the embed lane stays
+  // throttled at one job per tick indefinitely after a half-open success.
+  await withQdrantBreaker(() =>
+    upsertConceptPageEmbedding({
+      slug,
+      dense: correctedDense,
+      sparse,
+      summary:
+        correctedSummaryDense && summarySparse
+          ? { dense: correctedSummaryDense, sparse: summarySparse }
+          : undefined,
+      updatedAt: now,
+    }),
+  );
 }
 
 /** SQLite cache row shape returned by `readEmbeddingCache`. */

package/src/memory/jobs-worker.ts

@@ -95,7 +95,6 @@ const V1_QDRANT_JOB_TYPES = new Set<MemoryJobType>([
   "embed_attachment",
   "embed_graph_node",
   "embed_pkb_file",
-  "graph_trigger_embed",
   "rebuild_index",
   "delete_qdrant_vectors",
 ]);
@@ -525,6 +524,12 @@ async function processJob(
       pruneOldTraceEventsJob(job, config);
       return;
     case "build_conversation_summary":
+      // Stale rows enqueued before v2 was enabled must not consume the
+      // `conversationSummarization` LLM budget — v2 readers do not consume
+      // `memorySummaries`, mirroring the `graph_extract` gate below.
+      if (config.memory.v2.enabled) {
+        return;
+      }
       await buildConversationSummaryJob(job, config);
       return;
     case "backfill":

package/src/memory/llm-request-log-source-clickhouse.ts

@@ -57,6 +57,7 @@ interface ClickHouseRow {
   request_payload: string;
   response_payload: string;
   created_at: string;
+  agent_loop_exit_reason: string;
 }
 
 /** Injectable fetch override for tests. Defaults to globalThis.fetch. */
@@ -123,7 +124,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         provider,
         request_payload,
         response_payload,
-        toUnixTimestamp64Milli(created_at) AS created_at
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
         AND id = {log_id:String}
@@ -172,14 +174,21 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
   private async selectByMessageIds(ids: string[]): Promise<LogRow[]> {
     if (ids.length === 0) return [];
     const aid = await this.assistantId();
-    // ClickHouse Array(String) URL encoding is fiddly; the message IDs are
-    // server-generated UUIDs (or safe internal strings), so inline the
-    // literal after escaping single quotes. No SQL-injection surface — the
-    // values originate from our own SQLite messages table.
-    const idLiteral =
-      "[" +
-      ids.map((id) => `'${id.replace(/'/g, "''")}'`).join(",") +
-      "]";
+    // Bind each id as its own {id_N:String} placeholder. The IDs ultimately
+    // come from a caller-supplied path parameter — `getAssistantMessageIdsInTurn`
+    // passes the input straight through when the message lookup misses — so
+    // inline literal building (even with quote-doubling) is unsafe: ClickHouse
+    // honors `\'` as an escaped quote inside string literals, letting a
+    // backslash-suffixed id break out of the IN clause and bypass the
+    // `assistant_id` scope filter. Type-bound parameters carry value, not
+    // syntax, regardless of content.
+    const params: Record<string, string> = { assistant_id: aid };
+    const placeholders: string[] = [];
+    for (let i = 0; i < ids.length; i++) {
+      const key = `id_${i}`;
+      params[key] = ids[i]!;
+      placeholders.push(`{${key}:String}`);
+    }
     const sql = `SELECT
         id,
         conversation_id,
@@ -187,14 +196,15 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         provider,
         request_payload,
         response_payload,
-        toUnixTimestamp64Milli(created_at) AS created_at
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
-        AND message_id IN ${idLiteral}
+        AND message_id IN (${placeholders.join(",")})
       ORDER BY created_at ASC, id ASC
       LIMIT 1 BY id
       FORMAT JSONEachRow`;
-    const rows = await this.exec(sql, { assistant_id: aid });
+    const rows = await this.exec(sql, params);
     return rows.map((r) => this.toLogRow(r));
   }
 
@@ -276,6 +286,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       requestPayload: row.request_payload,
       responsePayload: row.response_payload,
       createdAt: Number(row.created_at),
+      agentLoopExitReason:
+        row.agent_loop_exit_reason === "" ? null : row.agent_loop_exit_reason,
     };
   }