@flowcodex/core 0.3.0

package/tests/auth-service.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fsp } from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { DefaultAuthService } from '../src/session/auth-service.js';
+import type { AuthService } from '../src/session/auth-service.js';
+import { authFilePath, keyFilePath } from '../src/session/session-store.js';
+
+let tmpHome: string;
+let prevHome: string | undefined;
+
+async function setTmpHome(): Promise<void> {
+  tmpHome = await fsp.mkdtemp(path.join(os.tmpdir(), 'fcx-auth-'));
+  prevHome = process.env.FLOWCODEX_HOME;
+  process.env.FLOWCODEX_HOME = tmpHome;
+}
+
+async function restoreHome(): Promise<void> {
+  if (prevHome !== undefined) process.env.FLOWCODEX_HOME = prevHome;
+  else delete process.env.FLOWCODEX_HOME;
+  await fsp.rm(tmpHome, { recursive: true, force: true }).catch(() => {});
+}
+
+function makeAuth(): AuthService {
+  return new DefaultAuthService({ authFile: authFilePath(), keyFile: keyFilePath() });
+}
+
+describe('DefaultAuthService', () => {
+  beforeEach(async () => {
+    await setTmpHome();
+  });
+  afterEach(async () => {
+    await restoreHome();
+  });
+
+  it('returns undefined for unknown provider when auth.json missing', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    expect(auth.get('anthropic')).toBeUndefined();
+  });
+
+  it('set + get round-trip for single key', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-test-123');
+    const entry = auth.get('anthropic');
+    expect(entry).toBeDefined();
+    expect(entry!.key).toBe('sk-test-123');
+    expect(entry!.label).toBe('default');
+  });
+
+  it('first key becomes active automatically', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-first');
+    expect(auth.get('anthropic')!.key).toBe('sk-first');
+  });
+
+  it('set with custom label', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-personal', 'personal');
+    const entry = auth.get('anthropic');
+    expect(entry!.label).toBe('personal');
+  });
+
+  it('multiple keys per provider, first stays active', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-first');
+    await auth.set('anthropic', 'sk-second', 'work');
+    expect(auth.get('anthropic')!.key).toBe('sk-first');
+    expect(auth.all()['anthropic']).toHaveLength(2);
+  });
+
+  it('setActive changes active key', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-first');
+    await auth.set('anthropic', 'sk-second', 'work');
+    await auth.setActive('anthropic', 'work');
+    expect(auth.get('anthropic')!.key).toBe('sk-second');
+  });
+
+  it('setActive with invalid label throws', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-first');
+    await expect(auth.setActive('anthropic', 'nonexistent')).rejects.toThrow();
+  });
+
+  it('remove by label removes one key', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-first');
+    await auth.set('anthropic', 'sk-second', 'work');
+    await auth.remove('anthropic', 'default');
+    expect(auth.all()['anthropic']).toHaveLength(1);
+    expect(auth.all()['anthropic']![0]!.label).toBe('work');
+  });
+
+  it('remove without label removes all keys', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-first');
+    await auth.set('anthropic', 'sk-second', 'work');
+    await auth.remove('anthropic');
+    expect(auth.get('anthropic')).toBeUndefined();
+  });
+
+  it('removing active key makes next key active', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-first');
+    await auth.set('anthropic', 'sk-second', 'work');
+    await auth.remove('anthropic', 'default');
+    expect(auth.get('anthropic')!.key).toBe('sk-second');
+  });
+
+  it('list returns all providers with keys', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-a');
+    await auth.set('openai', 'sk-b');
+    const entries = await auth.list();
+    expect(entries).toHaveLength(2);
+    const ids = entries.map((e) => e.providerId).sort();
+    expect(ids).toEqual(['anthropic', 'openai']);
+  });
+
+  it('status returns key count and active label', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-a');
+    await auth.set('anthropic', 'sk-b', 'work');
+    const status = await auth.status('anthropic');
+    expect(status.keyCount).toBe(2);
+    expect(status.activeLabel).toBe('default');
+  });
+
+  it('status detects env var', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    process.env.ANTHROPIC_API_KEY = 'sk-env';
+    try {
+      const status = await auth.status('anthropic');
+      expect(status.envVarDetected).toBe(true);
+    } finally {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('persists to encrypted auth.json on disk', async () => {
+    const auth = makeAuth();
+    await auth.load();
+    await auth.set('anthropic', 'sk-secret');
+    const raw = await fsp.readFile(authFilePath(), 'utf-8');
+    expect(raw).not.toContain('sk-secret');
+    expect(raw.startsWith('enc:v1:')).toBe(true);
+  });
+
+  it('loads from encrypted auth.json on restart', async () => {
+    const auth1 = makeAuth();
+    await auth1.load();
+    await auth1.set('anthropic', 'sk-secret');
+    const auth2 = makeAuth();
+    await auth2.load();
+    expect(auth2.get('anthropic')!.key).toBe('sk-secret');
+  });
+});

package/tests/blocks.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import {
+  isImageBlock,
+  isPdfBlock,
+  isToolUseBlock,
+  type ContentBlock,
+} from '../src/types/blocks.js';
+import type { LLMRequest, ToolChoice, StructuredOutputConfig } from '../src/types/provider.js';
+
+describe('ContentBlock type guards', () => {
+  it('isImageBlock matches base64 image', () => {
+    const b: ContentBlock = {
+      type: 'image',
+      source: { type: 'base64', media_type: 'image/png', data: 'abc' },
+    };
+    expect(isImageBlock(b)).toBe(true);
+  });
+  it('isImageBlock matches url image', () => {
+    const b: ContentBlock = {
+      type: 'image',
+      source: { type: 'url', url: 'https://example.com/x.png' },
+    };
+    expect(isImageBlock(b)).toBe(true);
+  });
+  it('isImageBlock rejects text', () => {
+    const b: ContentBlock = { type: 'text', text: 'hi' };
+    expect(isImageBlock(b)).toBe(false);
+  });
+  it('isPdfBlock matches pdf block', () => {
+    const b: ContentBlock = {
+      type: 'pdf',
+      source: { type: 'base64', media_type: 'application/pdf', data: 'abc' },
+    };
+    expect(isPdfBlock(b)).toBe(true);
+  });
+  it('isPdfBlock rejects image', () => {
+    const b: ContentBlock = {
+      type: 'image',
+      source: { type: 'base64', media_type: 'image/png', data: 'abc' },
+    };
+    expect(isPdfBlock(b)).toBe(false);
+  });
+  it('isToolUseBlock still works', () => {
+    const b: ContentBlock = { type: 'tool_use', id: '1', name: 'read', input: {} };
+    expect(isToolUseBlock(b)).toBe(true);
+  });
+});
+
+describe('LLMRequest v0.2.2 fields', () => {
+  it('accepts tool_choice with type tool', () => {
+    const tc: ToolChoice = { type: 'tool', name: 'structured_output' };
+    expect(tc.type).toBe('tool');
+    expect(tc.name).toBe('structured_output');
+  });
+  it('accepts tool_choice with type auto', () => {
+    const tc: ToolChoice = { type: 'auto' };
+    expect(tc.type).toBe('auto');
+    expect(tc.name).toBeUndefined();
+  });
+  it('accepts StructuredOutputConfig', () => {
+    const cfg: StructuredOutputConfig = {
+      name: 'structured_output',
+      schema: { type: 'object', properties: { x: { type: 'string' } } },
+    };
+    expect(cfg.name).toBe('structured_output');
+    expect(cfg.schema).toBeDefined();
+  });
+  it('LLMRequest allows tool_choice and typed output_config', () => {
+    const req: LLMRequest = {
+      model: 'm',
+      system: [],
+      messages: [],
+      tool_choice: { type: 'tool', name: 's' },
+      output_config: { name: 's', schema: {} },
+    };
+    expect(req.tool_choice?.type).toBe('tool');
+    expect(req.output_config?.name).toBe('s');
+  });
+});

package/tests/catalog-parser.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect } from 'vitest';
+import { DefaultCatalogParser } from '../src/infrastructure/catalog-parser.js';
+import type { ModelInfo } from '../src/infrastructure/catalog-parser.js';
+
+const SNAPSHOT = {
+  anthropic: {
+    npm: '@anthropic-ai/sdk',
+    models: {
+      'claude-sonnet-4-6': {
+        name: 'Claude Sonnet 4.6',
+        limit: { context: 200_000, output: 8192 },
+        cost: { input: 3, output: 15 },
+        tool_call: true,
+        modalities: { input: ['text'], output: ['text'] },
+      },
+      'claude-haiku-4-5': {
+        name: 'Claude Haiku 4.5',
+        limit: { context: 200_000, output: 8192 },
+        cost: { input: 0.8, output: 4 },
+        tool_call: true,
+        modalities: { input: ['text'], output: ['text'] },
+      },
+      'claude-opus-4-1': {
+        name: 'Claude Opus 4.1',
+        limit: { context: 200_000, output: 8192 },
+        cost: { input: 15, output: 75 },
+        tool_call: true,
+        modalities: { input: ['text'], output: ['text'] },
+      },
+      'claude-no-tools': {
+        name: 'Claude No Tools',
+        limit: { context: 200_000, output: 8192 },
+        cost: { input: 0.1, output: 0.5 },
+        tool_call: false,
+        modalities: { input: ['text'], output: ['text'] },
+      },
+      'claude-tiny-context': {
+        name: 'Claude Tiny Context',
+        limit: { context: 8_000, output: 8192 },
+        cost: { input: 0.1, output: 0.5 },
+        tool_call: true,
+        modalities: { input: ['text'], output: ['text'] },
+      },
+    },
+  },
+};
+
+function parseRawForTest(raw: unknown): ModelInfo[] {
+  const data = raw as Record<string, unknown>;
+  const models: ModelInfo[] = [];
+  for (const [providerId, provider] of Object.entries(data)) {
+    const p = provider as Record<string, unknown>;
+    const rawModels = p.models as Record<string, unknown> | undefined;
+    if (!rawModels) continue;
+    for (const [modelId, model] of Object.entries(rawModels)) {
+      const m = model as Record<string, unknown>;
+      const limit = m.limit as Record<string, number>;
+      const cost = m.cost as Record<string, number>;
+      const modalities = m.modalities as Record<string, string[]>;
+      models.push({
+        id: modelId,
+        name: (m.name as string) ?? modelId,
+        provider: providerId,
+        npm: p.npm as string | undefined,
+        reasoning: (m.reasoning as boolean) ?? false,
+        limit: { context: limit.context, output: limit.output },
+        cost: cost ? { input: cost.input, output: cost.output } : undefined,
+        tool_call: (m.tool_call as boolean) ?? false,
+        modalities: { input: modalities?.input ?? ['text'], output: modalities?.output ?? ['text'] },
+      });
+    }
+  }
+  return models;
+}
+
+function makeParserWithSnapshot(snapshot: unknown): DefaultCatalogParser {
+  const parser = new DefaultCatalogParser({ disableNetwork: true });
+  (parser as unknown as { cached: { models: ModelInfo[]; fetchedAt: number; source: string } }).cached = {
+    models: parseRawForTest(snapshot),
+    fetchedAt: Date.now(),
+    source: 'snapshot',
+  };
+  return parser;
+}
+
+describe('DefaultCatalogParser.getCheapestModel', () => {
+  it('returns the cheapest tool-capable model excluding the current one', () => {
+    const parser = makeParserWithSnapshot(SNAPSHOT);
+    const cheapest = parser.getCheapestModel('anthropic', 'claude-sonnet-4-6');
+    expect(cheapest).toBeDefined();
+    expect(cheapest!.id).toBe('claude-haiku-4-5');
+    expect(cheapest!.cost!.output).toBe(4);
+  });
+
+  it('returns the cheapest remaining model when current is haiku', () => {
+    const parser = makeParserWithSnapshot(SNAPSHOT);
+    const cheapest = parser.getCheapestModel('anthropic', 'claude-haiku-4-5');
+    expect(cheapest).toBeDefined();
+    expect(cheapest!.id).toBe('claude-sonnet-4-6');
+  });
+
+  it('excludes models without tool_call support', () => {
+    const parser = makeParserWithSnapshot(SNAPSHOT);
+    const cheapest = parser.getCheapestModel('anthropic', 'claude-opus-4-1');
+    expect(cheapest).toBeDefined();
+    expect(cheapest!.id).not.toBe('claude-no-tools');
+  });
+
+  it('excludes models with context limit below 16000', () => {
+    const parser = makeParserWithSnapshot(SNAPSHOT);
+    const cheapest = parser.getCheapestModel('anthropic', 'claude-opus-4-1');
+    expect(cheapest).toBeDefined();
+    expect(cheapest!.id).not.toBe('claude-tiny-context');
+  });
+
+  it('returns undefined when no candidates remain', () => {
+    const parser = makeParserWithSnapshot({
+      anthropic: {
+        npm: '@anthropic-ai/sdk',
+        models: {
+          'only-model': {
+            name: 'Only',
+            limit: { context: 200_000, output: 8192 },
+            cost: { input: 1, output: 1 },
+            tool_call: true,
+            modalities: { input: ['text'], output: ['text'] },
+          },
+        },
+      },
+    });
+    const cheapest = parser.getCheapestModel('anthropic', 'only-model');
+    expect(cheapest).toBeUndefined();
+  });
+
+  it('returns undefined when provider has no models', () => {
+    const parser = makeParserWithSnapshot({ other: { models: {} } });
+    const cheapest = parser.getCheapestModel('anthropic', 'anything');
+    expect(cheapest).toBeUndefined();
+  });
+
+  it('returns undefined when cached catalog is empty (not loaded)', () => {
+    const parser = new DefaultCatalogParser({ disableNetwork: true });
+    const cheapest = parser.getCheapestModel('anthropic', 'anything');
+    expect(cheapest).toBeUndefined();
+  });
+});
+
+import { classifyFamily } from '../src/infrastructure/catalog-parser.js';
+
+describe('classifyFamily', () => {
+  it('classifies @anthropic-ai/sdk as anthropic', () => {
+    expect(classifyFamily('@anthropic-ai/sdk')).toBe('anthropic');
+  });
+
+  it('classifies openai as openai', () => {
+    expect(classifyFamily('openai')).toBe('openai');
+  });
+
+  it('classifies @google/genai as google', () => {
+    expect(classifyFamily('@google/genai')).toBe('google');
+  });
+
+  it('classifies openai-compatible packages as openai-compatible', () => {
+    expect(classifyFamily('some-openai-compatible')).toBe('openai-compatible');
+  });
+
+  it('returns unsupported for undefined', () => {
+    expect(classifyFamily(undefined)).toBe('unsupported');
+  });
+
+  it('returns unsupported for unknown packages', () => {
+    expect(classifyFamily('unknown-pkg')).toBe('unsupported');
+  });
+});

package/tests/compactor.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect } from 'vitest';
+import {
+  HybridCompactor,
+  MODE_CONFIGS,
+  ACTIVE_MODE,
+  FLOOR_PRESERVE_K,
+  repairToolUseAdjacency,
+} from '../src/execution/compactor.js';
+import type { ContentBlock, Message } from '../src/types/blocks.js';
+
+function text(t: string): ContentBlock {
+  return { type: 'text', text: t };
+}
+function toolUse(id: string, name = 'read', input: unknown = {}): ContentBlock {
+  return { type: 'tool_use', id, name, input };
+}
+function toolResult(id: string, content: string): ContentBlock {
+  return { type: 'tool_result', tool_use_id: id, content };
+}
+function user(content: ContentBlock[] | string): Message {
+  return { role: 'user', content };
+}
+function assistant(content: ContentBlock[]): Message {
+  return { role: 'assistant', content };
+}
+
+function bigResult(id: string, tokens: number): ContentBlock {
+  return toolResult(id, 'x'.repeat(tokens * 4));
+}
+
+describe('MODE_CONFIGS', () => {
+  it('defines all four modes', () => {
+    expect(Object.keys(MODE_CONFIGS).sort()).toEqual(['archival', 'balanced', 'deep', 'frugal']);
+  });
+  it('ACTIVE_MODE is balanced', () => {
+    expect(ACTIVE_MODE).toBe('balanced');
+  });
+  it('every mode preserves at least FLOOR_PRESERVE_K', () => {
+    for (const cfg of Object.values(MODE_CONFIGS)) {
+      expect(cfg.preserveK).toBeGreaterThanOrEqual(FLOOR_PRESERVE_K);
+    }
+  });
+});
+
+describe('HybridCompactor', () => {
+  const compactor = new HybridCompactor();
+
+  it('returns messages unchanged when already small', async () => {
+    const msgs = [user('hi'), assistant([text('hello')])];
+    const r = await compactor.compact({ messages: msgs, mode: 'balanced', aggressive: false });
+    expect(r.messages).toHaveLength(2);
+    expect(r.after).toBeLessThanOrEqual(r.before);
+  });
+
+  it('Phase 1 elides oversized tool_results in compactable region', async () => {
+    const big = bigResult('1', 3000); // > balanced.elideThreshold (2000)
+    const msgs: Message[] = [
+      user('do task'),
+      assistant([text('thinking'), toolUse('1')]),
+      user([big]),
+      assistant([text('done')]),
+    ];
+    // pad enough recent turns to push the ancient pair into the compactable region
+    for (let i = 0; i < 11; i++) {
+      msgs.push(user([text(`q${i}`)]));
+      msgs.push(assistant([text(`a${i}`)]));
+    }
+    const r = await compactor.compact({ messages: msgs, mode: 'balanced', aggressive: false });
+    const elidedBlock = r.messages
+      .flatMap((m) => (typeof m.content === 'string' ? [] : m.content))
+      .find((b) => b.type === 'tool_result') as Extract<ContentBlock, { type: 'tool_result' }> | undefined;
+    expect(elidedBlock).toBeDefined();
+    expect((elidedBlock as { content: string }).content).toContain('[elided');
+    expect(r.after).toBeLessThan(r.before);
+    expect(r.digest).toContain('tool_results elided');
+  });
+
+  it('preserves recent assistant turns verbatim (preserveK)', async () => {
+    const msgs: Message[] = [];
+    for (let i = 0; i < 12; i++) {
+      msgs.push(user(`q${i}`));
+      msgs.push(assistant([text(`a${i}`)]));
+    }
+    const r = await compactor.compact({ messages: msgs, mode: 'balanced', aggressive: false });
+    // last balanced.preserveK (10) assistant turns preserved verbatim
+    const lastBlocks = r.messages[r.messages.length - 1]!.content as ContentBlock[];
+    expect((lastBlocks[0] as { text: string }).text).toBe('a11');
+  });
+
+  it('Phase 2 (aggressive) collapses ancient tool I/O but keeps text', async () => {
+    const msgs: Message[] = [user('do it')];
+    // ancient turn with tool I/O (before the preserveK boundary)
+    msgs.push(assistant([text('ancient decision'), toolUse('1'), toolUse('2')]));
+    msgs.push(user([toolResult('1', 'r1'), toolResult('2', 'r2')]));
+    // pad with enough recent assistant turns to exceed preserveK (balanced=10)
+    for (let i = 0; i < 11; i++) {
+      msgs.push(assistant([text(`recent ${i}`)]));
+      msgs.push(user([text(`ack ${i}`)]));
+    }
+    const r = await compactor.compact({ messages: msgs, mode: 'balanced', aggressive: true });
+    const ancient = r.messages.find((m) => m.role === 'assistant' && Array.isArray(m.content) && m.content.some((b) => b.type === 'text' && b.text === 'ancient decision'));
+    expect(ancient).toBeDefined();
+    const ancientContent = ancient!.content as ContentBlock[];
+    expect(ancientContent.some((b) => b.type === 'tool_use')).toBe(false);
+    expect(r.digest).toContain('ancient turns digested');
+  });
+
+  it('preserves tool_use/tool_result pairing (repairToolUseAdjacency runs)', async () => {
+    const msgs: Message[] = [
+      user('go'),
+      assistant([text('ok'), toolUse('1')]),
+      user([toolResult('1', 'result data')]),
+      assistant([text('done')]),
+    ];
+    const r = await compactor.compact({ messages: msgs, mode: 'balanced', aggressive: false });
+    // the tool_use '1' must still have its tool_result, or both dropped together
+    const uses = r.messages.flatMap((m) => (typeof m.content === 'string' ? [] : m.content)).filter((b) => b.type === 'tool_use');
+    const results = r.messages.flatMap((m) => (typeof m.content === 'string' ? [] : m.content)).filter((b) => b.type === 'tool_result');
+    const useIds = new Set(uses.map((b) => (b as { id: string }).id));
+    const resultIds = new Set(results.map((b) => (b as { tool_use_id: string }).tool_use_id));
+    for (const id of useIds) expect(resultIds.has(id)).toBe(true);
+    for (const id of resultIds) expect(useIds.has(id)).toBe(true);
+  });
+
+  it('never drops below FLOOR_PRESERVE_K assistant turns even when aggressive', async () => {
+    const msgs: Message[] = [];
+    for (let i = 0; i < 8; i++) {
+      msgs.push(user(`q${i}`));
+      msgs.push(assistant([text(`a${i}`)]));
+    }
+    const r = await compactor.compact({ messages: msgs, mode: 'frugal', aggressive: true });
+    const assistants = r.messages.filter((m) => m.role === 'assistant');
+    expect(assistants.length).toBeGreaterThanOrEqual(FLOOR_PRESERVE_K);
+  });
+});
+
+describe('repairToolUseAdjacency', () => {
+  it('drops orphan tool_use with no matching tool_result', () => {
+    const msgs: Message[] = [
+      assistant([text('x'), toolUse('orphan'), toolUse('paired')]),
+      user([toolResult('paired', 'r')]),
+    ];
+    const r = repairToolUseAdjacency(msgs);
+    expect(r.removedToolUses).toBe(1);
+    const uses = r.changed.flatMap((m) => (typeof m.content === 'string' ? [] : m.content)).filter((b) => b.type === 'tool_use');
+    expect(uses).toHaveLength(1);
+    expect((uses[0] as { id: string }).id).toBe('paired');
+  });
+
+  it('drops orphan tool_result with no matching tool_use', () => {
+    const msgs: Message[] = [
+      assistant([toolUse('1')]),
+      user([toolResult('1', 'r'), toolResult('orphan', 'x')]),
+    ];
+    const r = repairToolUseAdjacency(msgs);
+    expect(r.removedToolResults).toBe(1);
+  });
+
+  it('drops messages that become empty', () => {
+    const msgs: Message[] = [
+      assistant([toolUse('orphan')]), // will be dropped (no result), message becomes empty
+      user([text('keep')]),
+    ];
+    const r = repairToolUseAdjacency(msgs);
+    expect(r.removedMessages).toBeGreaterThanOrEqual(1);
+    expect(r.changed).toHaveLength(1);
+  });
+
+  it('preserves text/thinking/image blocks untouched', () => {
+    const msgs: Message[] = [
+      assistant([text('hello'), toolUse('1')]),
+      user([toolResult('1', 'r')]),
+    ];
+    const r = repairToolUseAdjacency(msgs);
+    expect(r.removedToolUses).toBe(0);
+    expect(r.removedToolResults).toBe(0);
+    const first = r.changed[0]!.content as ContentBlock[];
+    expect((first[0] as { text: string }).text).toBe('hello');
+  });
+});