@vellumai/assistant 0.11.1-dev.202608041836.2a522b8 → 0.11.1-dev.202608042001.feb8dd6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-dev.202608041836.2a522b8",
+  "version": "0.11.1-dev.202608042001.feb8dd6",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/compactor-truncation-pairing.test.ts

@@ -0,0 +1,368 @@
+/**
+ * The compaction summary call's front truncation must never split a
+ * tool_use/tool_result pair, and the outbound request must be repaired
+ * before the provider call.
+ *
+ * The token-budget drop loop advances one message at a time, so without a
+ * boundary check its cut can drop an assistant `tool_use` while keeping its
+ * user `tool_result` in the retained portion. Providers that validate
+ * pairing (OpenAI Responses: "No tool call found for function call output
+ * with call_id ...") reject such a request, and the retry ladder reproduces
+ * the same rejection every pass. The cut must advance to a pair-safe user
+ * boundary, and `buildCompactionRequest` runs the deterministic history
+ * repair so even a malformed input history reaches the provider valid.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  getMessages: () => [],
+}));
+
+mock.module("../persistence/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+mock.module("../persistence/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+}));
+
+import { runAssistantDrivenCompaction } from "../context/compactor.js";
+import { estimatePromptTokens } from "../context/token-estimator.js";
+import type { ContentBlock, Message, Provider } from "../providers/types.js";
+
+const SUMMARY = "Earlier turns summarized in the assistant's own voice.";
+
+function turnTimestamp(turn: number): string {
+  const hour = String(10 + Math.floor(turn / 60)).padStart(2, "0");
+  const minute = String(turn % 60).padStart(2, "0");
+  return `2026-05-21 (Thursday) ${hour}:${minute}:00 -05:00 (America/Chicago)`;
+}
+
+function userTurn(turn: number, body: string): Message {
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `<turn_context>\ncurrent_time: ${turnTimestamp(
+          turn,
+        )}\n</turn_context>\n[U${turn}] ${body}`,
+      },
+    ],
+  };
+}
+
+function compactionResponse(tailTurn: number, preview: string): string {
+  return `<compaction_result>
+<summary>
+${SUMMARY}
+</summary>
+<key_state>
+- Nothing critical pending.
+</key_state>
+<tail_start timestamp="${turnTimestamp(tailTurn)}" preview="${preview}" />
+</compaction_result>`;
+}
+
+/**
+ * Fake provider enforcing the same pairing contract the OpenAI Responses
+ * serialization is subject to: a `tool_result` may only reference a
+ * `tool_use` emitted earlier in the same request (a `function_call_output`
+ * with no preceding matching `function_call` is a 400). Rejects with the
+ * provider's live error phrasing so a regression reproduces the real
+ * failure mode.
+ */
+function makeValidatingProvider(response: string): {
+  provider: Provider;
+  lastRequest: () => Message[] | null;
+} {
+  let captured: Message[] | null = null;
+  const provider: Provider = {
+    name: "mock-provider",
+    sendMessage: async (messages: Message[]) => {
+      const emittedToolUseIds = new Set<string>();
+      for (const msg of messages) {
+        for (const block of msg.content) {
+          if (msg.role === "assistant" && block.type === "tool_use") {
+            emittedToolUseIds.add(block.id);
+          }
+          if (block.type === "tool_result") {
+            // guard:allow-tool-result-only: the fake validates client-side pairing only
+            const toolUseId = (block as { tool_use_id: string }).tool_use_id;
+            if (!emittedToolUseIds.has(toolUseId)) {
+              throw new Error(
+                `No tool call found for function call output with call_id ${toolUseId}.`,
+              );
+            }
+          }
+        }
+      }
+      captured = messages;
+      return {
+        content: [{ type: "text", text: response }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return { provider, lastRequest: () => captured };
+}
+
+function estimate(messages: Message[]): number {
+  return estimatePromptTokens(messages, "system", {
+    providerName: "mock-provider",
+  });
+}
+
+/** Mirror of the compactor's pair-safe cut predicate for fixture guards. */
+function isCleanUserBoundary(message: Message | undefined): boolean {
+  return (
+    message != null &&
+    message.role === "user" &&
+    // guard:allow-tool-result-only: mirrors the compactor's boundary predicate
+    !message.content.some((block) => block.type === "tool_result")
+  );
+}
+
+/**
+ * Replay the token-budget drop loop without the pairing advance, to locate
+ * where the raw budget cut lands for a fixture.
+ */
+function naiveDropCount(messages: Message[], budgetTokens: number): number {
+  let dropCount = 0;
+  let estimated = estimate(messages);
+  while (estimated > budgetTokens && dropCount < messages.length - 1) {
+    dropCount++;
+    estimated = estimate(messages.slice(dropCount));
+  }
+  return dropCount;
+}
+
+function textOfMessage(message: Message | undefined): string {
+  return (message?.content ?? [])
+    .map((block) => ("text" in block ? (block.text as string) : ""))
+    .join("\n");
+}
+
+function requestText(messages: Message[]): string {
+  return messages.map(textOfMessage).join("\n");
+}
+
+describe("compaction summary call: pair-safe front truncation", () => {
+  // Rounds of [user text, assistant tool_use (heavy), user tool_result,
+  // assistant text]: the heavy tool_use messages dominate the estimate, so
+  // the raw budget loop settles right after dropping one of them, landing
+  // the cut on its orphaned tool_result (or the assistant text behind it),
+  // never on a clean user boundary.
+  function buildToolHeavyHistory(rounds: number, idPrefix: string): Message[] {
+    const messages: Message[] = [];
+    for (let i = 0; i < rounds; i++) {
+      messages.push(userTurn(i, "please inspect the next data batch"));
+      messages.push({
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: `${idPrefix}_${i}`,
+            name: "inspect_batch",
+            input: { payload: `batch ${i} `.repeat(600) },
+          },
+        ],
+      });
+      messages.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: `${idPrefix}_${i}`,
+            content: `inspection ${i} complete. `.repeat(8),
+          },
+        ],
+      });
+      messages.push({
+        role: "assistant",
+        content: [
+          { type: "text", text: `[A${i}] batch ${i} looks consistent.` },
+        ],
+      });
+    }
+    return messages;
+  }
+
+  /** tool_result blocks in `messages` with no tool_use anywhere in `messages`. */
+  function orphanedResultIds(messages: Message[]): string[] {
+    const toolUseIds = new Set<string>();
+    for (const msg of messages) {
+      for (const block of msg.content) {
+        if (msg.role === "assistant" && block.type === "tool_use") {
+          toolUseIds.add(block.id);
+        }
+      }
+    }
+    const orphans: string[] = [];
+    for (const msg of messages) {
+      for (const block of msg.content) {
+        if (block.type === "tool_result") {
+          // guard:allow-tool-result-only: counting client-side orphans
+          const toolUseId = (block as { tool_use_id: string }).tool_use_id;
+          if (!toolUseIds.has(toolUseId)) {
+            orphans.push(toolUseId);
+          }
+        }
+      }
+    }
+    return orphans;
+  }
+
+  // Pairing must be id-format-agnostic, so the fixture runs across both
+  // persisted tool id shapes: Anthropic-style `toolu_` ids and OpenAI
+  // Responses-native `call_` ids.
+  for (const idPrefix of ["toolu", "call"] as const) {
+    test(`advances the cut to a pair-safe boundary and succeeds against a pairing-validating provider (${idPrefix}_ ids)`, async () => {
+      const rounds = 30;
+      const messages = buildToolHeavyHistory(rounds, idPrefix);
+
+      const maxInputTokens = 20_000;
+      // Mirrors compactor.compactionPrefixBudget: window minus the
+      // instruction reserve (800) and the 15% output reserve.
+      const prefixBudget =
+        maxInputTokens - 800 - Math.floor(maxInputTokens * 0.15);
+      expect(estimate(messages)).toBeGreaterThan(prefixBudget);
+
+      // Fixture guard: without the pairing advance, the budget cut lands on
+      // an unsafe index and the retained tail carries a tool_result whose
+      // tool_use sits in the dropped prefix (the exact shape the provider
+      // rejects). If token-estimation changes ever make this land safely,
+      // the fixture must be re-tuned or this test proves nothing.
+      const rawCut = naiveDropCount(messages, prefixBudget);
+      expect(rawCut).toBeGreaterThan(0);
+      expect(isCleanUserBoundary(messages[rawCut])).toBe(false);
+      expect(orphanedResultIds(messages.slice(rawCut)).length).toBeGreaterThan(
+        0,
+      );
+
+      const { provider, lastRequest } = makeValidatingProvider(
+        compactionResponse(rounds - 2, "please inspect the next"),
+      );
+
+      const result = await runAssistantDrivenCompaction({
+        conversationId: "conv-test",
+        messages,
+        provider,
+        systemPrompt: "system",
+        compaction: { enabled: true, autoThreshold: 0.7 },
+        maxInputTokens,
+        force: true,
+        previousEstimatedInputTokens: 90_000,
+      });
+
+      // The pairing-validating provider accepted the request and the pass
+      // applied.
+      expect(result.compacted).toBe(true);
+
+      const sent = lastRequest();
+      expect(sent).not.toBeNull();
+      const sentMessages = sent ?? [];
+
+      // Every tool_result in the outbound request is preceded by its
+      // tool_use.
+      expect(orphanedResultIds(sentMessages)).toEqual([]);
+
+      // The cut itself was pair-safe: nothing needed the repair pass's
+      // orphan downgrade, and the retained pairs survive intact.
+      const sentText = requestText(sentMessages);
+      expect(sentText).not.toContain("[orphaned");
+
+      // The request still fits the window and announces the truncation.
+      expect(estimate(sentMessages)).toBeLessThan(maxInputTokens);
+      expect(sentText).toContain("summary covers only the visible portion");
+
+      // Recent valid content is retained verbatim: the last round's user
+      // turn, tool pair, and assistant reply all reach the provider.
+      const lastRound = rounds - 1;
+      expect(sentText).toContain(`[U${lastRound}] please inspect`);
+      expect(sentText).toContain(`[A${lastRound}] batch ${lastRound}`);
+      const sentToolUseIds = new Set<string>();
+      for (const msg of sentMessages) {
+        for (const block of msg.content) {
+          if (msg.role === "assistant" && block.type === "tool_use") {
+            sentToolUseIds.add(block.id);
+          }
+        }
+      }
+      expect(sentToolUseIds.has(`${idPrefix}_${lastRound}`)).toBe(true);
+    });
+  }
+
+  test("repairs a malformed below-budget history before the provider call", async () => {
+    // Orphan tool_result (its tool_use exists nowhere in the history) and a
+    // consecutive same-role user run, below the truncation budget so the
+    // request-build repair is the only transform in play.
+    const messages: Message[] = [
+      userTurn(0, "start the job"),
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "toolu_missing",
+            content: "stale result payload",
+          },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "[A0] acknowledged." }],
+      },
+      userTurn(1, "carry on with the job"),
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "[A1] done." }],
+      },
+    ];
+
+    const { provider, lastRequest } = makeValidatingProvider(
+      compactionResponse(1, "carry on with the job"),
+    );
+
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-test",
+      messages,
+      provider,
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      maxInputTokens: 200_000,
+      force: true,
+      previousEstimatedInputTokens: 90_000,
+    });
+
+    expect(result.compacted).toBe(true);
+
+    const sentMessages = lastRequest() ?? [];
+    // The orphan was downgraded to text: no tool_result blocks reach the
+    // provider, and the payload is preserved in the degraded form.
+    const hasToolResult = sentMessages.some((msg) =>
+      // guard:allow-tool-result-only: asserting the repair removed them
+      msg.content.some((block: ContentBlock) => block.type === "tool_result"),
+    );
+    expect(hasToolResult).toBe(false);
+    const sentText = requestText(sentMessages);
+    expect(sentText).toContain("stale result payload");
+    expect(sentText).toContain("orphaned tool_result");
+
+    // Same-role runs were merged: roles strictly alternate in the history
+    // portion of the request (everything before the trailing instruction).
+    const historyPortion = sentMessages.slice(0, -1);
+    for (let i = 1; i < historyPortion.length; i++) {
+      expect(historyPortion[i].role).not.toBe(historyPortion[i - 1].role);
+    }
+
+    // Valid user text survives the repair verbatim.
+    expect(sentText).toContain("[U0] start the job");
+    expect(sentText).toContain("[U1] carry on with the job");
+  });
+});

package/src/__tests__/history-repair.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import { deepRepairHistory } from "../agent/history-repair/history-repair.js";
+import { isRepairableOrderingError } from "../agent/history-repair/history-repair.js";
 import { repairHistory } from "../agent/history-repair/history-repair.js";
 import type { Message } from "../providers/types.js";
 
@@ -1110,3 +1111,41 @@ describe("deepRepairHistory", () => {
     expect(stats.orphanToolResultsDowngraded).toBe(0);
   });
 });
+
+describe("isRepairableOrderingError", () => {
+  test("matches Anthropic tool ordering rejections", () => {
+    expect(
+      isRepairableOrderingError(
+        "Requests which include `tool_use` blocks must have a corresponding `tool_result` block in the next message.",
+      ),
+    ).toBe(true);
+    expect(
+      isRepairableOrderingError(
+        "messages.5: tool_result block references tool_use_id toolu_abc which was not found",
+      ),
+    ).toBe(true);
+  });
+
+  test("matches the OpenAI Responses orphan function_call_output rejection", () => {
+    expect(
+      isRepairableOrderingError(
+        "No tool call found for function call output with call_id call_abc123.",
+      ),
+    ).toBe(true);
+  });
+
+  test("matches the OpenAI Chat Completions orphan tool_call_id rejection", () => {
+    expect(
+      isRepairableOrderingError(
+        "Invalid parameter: 'tool_call_id' of 'call_abc123' not found in 'tool_calls' of previous message.",
+      ),
+    ).toBe(true);
+  });
+
+  test("does not match unrelated provider errors", () => {
+    expect(isRepairableOrderingError("Rate limit exceeded")).toBe(false);
+    expect(
+      isRepairableOrderingError("Request too large for model context window"),
+    ).toBe(false);
+  });
+});

package/src/agent/history-repair/history-repair.ts

@@ -399,6 +399,14 @@ export const ORDERING_ERROR_PATTERNS: readonly RegExp[] = [
   /tool_use_id.*without.*tool_result/i,
   /tool_result.*tool_use_id.*not found/i,
   /messages.*invalid.*order/i,
+  // OpenAI Responses API: a function_call_output whose call_id has no
+  // matching function_call earlier in the request ("No tool call found for
+  // function call output with call_id ...").
+  /no tool call found for function call output/i,
+  // OpenAI Chat Completions API: a tool message whose tool_call_id is not in
+  // a preceding assistant message's tool_calls ("Invalid parameter:
+  // 'tool_call_id' of '...' not found in 'tool_calls' of previous message").
+  /tool_call_id.*not found/i,
 ];
 
 /**

package/src/context/compactor.ts

@@ -18,6 +18,7 @@
  * On any parse or resolution failure we abort the compaction and return
  * `compacted: false` — never silently lose messages.
  */
+import { repairHistory } from "../agent/history-repair/history-repair.js";
 import { optimizeImageForTransport } from "../agent/image-optimize.js";
 import type { CompactionConfig } from "../config/schemas/compaction.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
@@ -1056,9 +1057,14 @@ function extractTextFromResponse(content: ContentBlock[]): string {
 
 // Build the outbound message list for a compaction provider call: apply the
 // same pre-send sanitization bundle as the agent loop's model calls
-// (`preModelCallSanitize` — old tool-result media stripped, AX trees
-// collapsed, historical web-search results converted to text), then append
-// the summarization instruction at the tail.
+// (`preModelCallSanitize`: old tool-result media stripped, AX trees
+// collapsed, historical web-search results converted to text), run the
+// deterministic history repair over the sanitized projection, then append
+// the summarization instruction at the tail. The repair pass downgrades any
+// orphaned `tool_result` (its `tool_use` outside the request, e.g. cut off
+// by front truncation) to plain text and merges consecutive same-role runs,
+// so the request always satisfies the provider's pairing validation. A
+// well-formed history passes through repair structurally unchanged.
 //
 // Matching the loop's projection matters for two reasons. First, the summary
 // call's prefix stays byte-aligned with the agent's warm prompt cache — an
@@ -1076,7 +1082,10 @@ function buildCompactionRequest(
   history: Message[],
   instruction: Message,
 ): Message[] {
-  return [...preModelCallSanitize(history), instruction];
+  return [
+    ...repairHistory(preModelCallSanitize(history)).messages,
+    instruction,
+  ];
 }
 
 // Token headroom a compaction summary call reserves on top of its history: room
@@ -1129,6 +1138,34 @@ function truncateHistoryToBudget(args: {
   if (dropCount === 0) {
     return messages;
   }
+  // Advance the cut to a pair-safe boundary. The budget loop stops wherever
+  // the estimate first fits, which can land between an assistant `tool_use`
+  // and its user `tool_result` and leave an orphaned `tool_result` opening
+  // the retained portion (rejected by providers that validate pairing).
+  // Walk forward to the next clean user boundary, never dropping the final
+  // message (mirroring the budget loop's own bound). When no boundary exists
+  // the requested cut stands; the request-build repair pass downgrades any
+  // orphaned results so the outbound call remains valid.
+  const requestedDropCount = dropCount;
+  if (!isForwardCutBoundary(messages, dropCount)) {
+    for (let i = dropCount + 1; i < messages.length; i++) {
+      if (isForwardCutBoundary(messages, i)) {
+        dropCount = i;
+        break;
+      }
+    }
+  }
+  if (dropCount !== requestedDropCount) {
+    log.info(
+      {
+        requestedDropCount,
+        pairSafeDropCount: dropCount,
+        budgetTokens,
+        totalMessages: messages.length,
+      },
+      "Advanced compaction summary-call front truncation to a pair-safe boundary",
+    );
+  }
   log.info(
     { dropCount, budgetTokens, totalMessages: messages.length },
     "Compaction summary input exceeds context window — truncating from front",

package/src/persistence/migrations/361-normalize-managed-connection-rows.test.ts

@@ -0,0 +1,168 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateNormalizeManagedConnectionRows } from "./361-normalize-managed-connection-rows.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE provider_connections (
+      name        TEXT PRIMARY KEY,
+      provider    TEXT NOT NULL,
+      auth        TEXT NOT NULL,
+      label       TEXT,
+      base_url    TEXT,
+      models      TEXT,
+      created_at  INTEGER NOT NULL,
+      updated_at  INTEGER NOT NULL
+    );
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function insertRow(
+  sqlite: Database,
+  name: string,
+  provider: string,
+  auth: string,
+): void {
+  sqlite
+    .query(
+      /*sql*/ `INSERT INTO provider_connections (name, provider, auth, created_at, updated_at)
+       VALUES (?, ?, ?, 1, 1)`,
+    )
+    .run(name, provider, auth);
+}
+
+function readRows(
+  sqlite: Database,
+): Array<{ name: string; provider: string; auth: string }> {
+  return sqlite
+    .query(
+      `SELECT name, provider, auth FROM provider_connections ORDER BY name`,
+    )
+    .all() as Array<{ name: string; provider: string; auth: string }>;
+}
+
+function readRow(
+  sqlite: Database,
+  name: string,
+): { provider: string; auth: string } {
+  const row = readRows(sqlite).find((r) => r.name === name);
+  if (!row) {
+    throw new Error(`row "${name}" not found`);
+  }
+  return row;
+}
+
+describe("migration 361: normalize managed connection rows", () => {
+  test("rewrites a platform-auth row with a concrete provider to provider vellum", () => {
+    const { sqlite, db } = createTestDb();
+    insertRow(sqlite, "managed-openai", "openai", '{"type":"platform"}');
+
+    migrateNormalizeManagedConnectionRows(db);
+
+    const row = readRow(sqlite, "managed-openai");
+    expect(row.provider).toBe("vellum");
+    expect(JSON.parse(row.auth)).toEqual({ type: "platform" });
+  });
+
+  test("heals a stuck legacy canonical row (name vellum, concrete provider, platform auth)", () => {
+    const { sqlite, db } = createTestDb();
+    insertRow(sqlite, "vellum", "anthropic", '{"type":"platform"}');
+
+    migrateNormalizeManagedConnectionRows(db);
+
+    expect(readRow(sqlite, "vellum").provider).toBe("vellum");
+  });
+
+  test("rewrites a vellum-provider row with non-platform auth to platform auth", () => {
+    const { sqlite, db } = createTestDb();
+    insertRow(
+      sqlite,
+      "keyed-vellum",
+      "vellum",
+      '{"type":"api_key","credential":"vault/x"}',
+    );
+    insertRow(sqlite, "none-vellum", "vellum", '{"type":"none"}');
+
+    migrateNormalizeManagedConnectionRows(db);
+
+    expect(JSON.parse(readRow(sqlite, "keyed-vellum").auth)).toEqual({
+      type: "platform",
+    });
+    expect(JSON.parse(readRow(sqlite, "none-vellum").auth)).toEqual({
+      type: "platform",
+    });
+  });
+
+  test("leaves consistent rows untouched", () => {
+    const { sqlite, db } = createTestDb();
+    insertRow(sqlite, "vellum", "vellum", '{"type":"platform"}');
+    insertRow(
+      sqlite,
+      "anthropic-key",
+      "anthropic",
+      '{"type":"api_key","credential":"vault/anthropic"}',
+    );
+    insertRow(
+      sqlite,
+      "chatgpt-subscription",
+      "openai",
+      '{"type":"oauth_subscription"}',
+    );
+    insertRow(sqlite, "ollama-local", "ollama", '{"type":"none"}');
+
+    const before = readRows(sqlite);
+    migrateNormalizeManagedConnectionRows(db);
+
+    expect(readRows(sqlite)).toEqual(before);
+  });
+
+  test("leaves a BYOK row claiming the canonical name untouched", () => {
+    const { sqlite, db } = createTestDb();
+    insertRow(
+      sqlite,
+      "vellum",
+      "anthropic",
+      '{"type":"api_key","credential":"vault/anthropic"}',
+    );
+
+    migrateNormalizeManagedConnectionRows(db);
+
+    const row = readRow(sqlite, "vellum");
+    expect(row.provider).toBe("anthropic");
+    expect(JSON.parse(row.auth).type).toBe("api_key");
+  });
+
+  test("leaves a row with unparseable auth untouched", () => {
+    const { sqlite, db } = createTestDb();
+    insertRow(sqlite, "broken", "vellum", "not json");
+
+    migrateNormalizeManagedConnectionRows(db);
+
+    expect(readRow(sqlite, "broken").auth).toBe("not json");
+  });
+
+  test("is idempotent", () => {
+    const { sqlite, db } = createTestDb();
+    insertRow(sqlite, "managed-openai", "openai", '{"type":"platform"}');
+    insertRow(sqlite, "keyed-vellum", "vellum", '{"type":"api_key"}');
+
+    migrateNormalizeManagedConnectionRows(db);
+    const afterFirst = readRows(sqlite);
+    migrateNormalizeManagedConnectionRows(db);
+
+    expect(readRows(sqlite)).toEqual(afterFirst);
+  });
+
+  test("no-ops on a database from before the provider_connections table", () => {
+    const sqlite = new Database(":memory:");
+    const db = drizzle(sqlite, { schema });
+
+    expect(() => migrateNormalizeManagedConnectionRows(db)).not.toThrow();
+  });
+});