brownian-code 2026.2.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brownian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# Brownian Code
+
+Think Claude Code, but built specifically for crypto research.
+
+[![npm version](https://img.shields.io/npm/v/brownian-code)](https://www.npmjs.com/package/brownian-code)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![GitHub release](https://img.shields.io/github/v/release/brownian-xyz/brownian-code)](https://github.com/brownian-xyz/brownian-code/releases)
+
+Brownian Code is an autonomous crypto research agent that thinks, plans, and learns as it works. It performs analysis using task planning, self-reflection, and real-time market data -- decomposing complex questions into research steps, gathering live data, validating its own work, and iterating until it has a confident, data-backed answer.
+
+## Install
+
+**Quick install (macOS / Linux):**
+
+```bash
+curl -fsSL https://brownian.xyz/install.sh | bash
+```
+
+**npm:**
+
+```bash
+npm install -g brownian-code
+```
+
+**Homebrew:**
+
+```bash
+brew tap brownian-xyz/brownian
+brew install brownian
+```
+
+**From source:**
+
+```bash
+git clone https://github.com/brownian-xyz/brownian-code.git
+cd brownian-code
+bun install
+bun start
+```
+
+## Quick Start
+
+1. Copy the example environment file and add at least one LLM API key:
+
+```bash
+cp env.example .env
+# Edit .env and add your API key(s)
+```
+
+2. Launch the agent:
+
+```bash
+brownian
+```
+
+3. Ask a question:
+
+```
+> Compare SOL vs ETH developer activity and TVL trends over the last quarter
+```
+
+See [QUICKSTART.md](QUICKSTART.md) for a full first-run walkthrough.
+
+## Features
+
+- **Autonomous task planning** -- Decomposes complex queries into structured research steps, executes them, and self-validates results.
+- **Self-reflection** -- Checks its own work, detects gaps, and iterates until tasks are complete. Built-in loop detection and step limits prevent runaway execution.
+- **Real-time crypto data** -- 227+ endpoints via Hive Intelligence covering prices, DeFi, wallets, security, NFTs, and more.
+- **Multi-provider LLM support** -- OpenAI, Anthropic, Google, xAI, OpenRouter, Ollama (local). Switch models on the fly with `/model`.
+- **Web search + browser** -- Exa/Tavily search and Playwright-based scraping for real-time web research.
+- **Extensible skills** -- Define custom research workflows as SKILL.md files.
+- **Conversation history** -- Persistent history with search, export, and context compaction.
+
+## Documentation
+
+| Document | Description |
+|----------|-------------|
+| [INSTALL.md](INSTALL.md) | Detailed installation guide with all methods |
+| [QUICKSTART.md](QUICKSTART.md) | First-run setup and usage walkthrough |
+| [docs/COMMANDS.md](docs/COMMANDS.md) | All CLI commands and keyboard shortcuts |
+| [docs/CONFIGURATION.md](docs/CONFIGURATION.md) | Environment variables and config files |
+| [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md) | Common issues and fixes |
+| [AGENTS.md](AGENTS.md) | Repository guidelines for AI coding agents |
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Open a Pull Request
+
+Please keep pull requests small and focused. Run `bun run typecheck && bun test` before submitting.
+
+## License
+
+MIT -- see [LICENSE](LICENSE) for details.

package/bin/brownian

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { join, dirname } from "node:path";
+
+// Check if bun is available
+try {
+  execFileSync("bun", ["--version"], { stdio: "ignore" });
+} catch {
+  console.error("Error: Bun runtime is required but not found on your PATH.");
+  console.error("");
+  console.error("Install bun:  curl -fsSL https://bun.sh/install | bash");
+  console.error("More info:    https://bun.sh");
+  process.exit(1);
+}
+
+// Launch the app via bun
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const entry = join(__dirname, "..", "src", "index.tsx");
+try {
+  execFileSync("bun", ["run", entry], { stdio: "inherit" });
+} catch (e) {
+  process.exit(e.status ?? 1);
+}

package/env.example

@@ -0,0 +1,21 @@
+# LLM API Keys
+OPENAI_API_KEY=your-api-key
+ANTHROPIC_API_KEY=your-api-key
+GOOGLE_API_KEY=your-api-key
+XAI_API_KEY=your-api-key
+OPENROUTER_API_KEY=your-api-key
+MOONSHOT_API_KEY=your-api-key
+DEEPSEEK_API_KEY=your-api-key
+
+# Ollama (Local LLM)
+OLLAMA_BASE_URL=http://127.0.0.1:11434
+
+# Web Search API Keys (Exa preferred, Tavily fallback)
+EXASEARCH_API_KEY=your-api-key
+TAVILY_API_KEY=your-api-key
+
+# LangSmith (optional - enable for tracing)
+# LANGSMITH_API_KEY=your-api-key
+# LANGSMITH_ENDPOINT=https://api.smith.langchain.com
+# LANGSMITH_PROJECT=brownian-code
+# LANGSMITH_TRACING=true

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "brownian-code",
+  "version": "2026.2.10",
+  "description": "Brownian Code - AI agent for crypto research",
+  "type": "module",
+  "main": "src/index.tsx",
+  "bin": {
+    "brownian": "./bin/brownian"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "env.example",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "scripts": {
+    "start": "bun run src/index.tsx",
+    "dev": "bun --watch run src/index.tsx",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "build:all": "bash scripts/build-all.sh",
+    "gateway": "bun run src/gateway/index.ts",
+    "gateway:login": "bun run src/gateway/channels/whatsapp/login.ts",
+    "prepublishOnly": "bun run typecheck && bun test"
+  },
+  "keywords": [
+    "crypto",
+    "research",
+    "ai",
+    "agent",
+    "cli",
+    "blockchain",
+    "defi",
+    "finance"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brownian-xyz/brownian-code.git"
+  },
+  "homepage": "https://brownian.xyz",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@langchain/anthropic": "^1.1.3",
+    "@langchain/core": "^1.1.0",
+    "@langchain/exa": "^1.0.1",
+    "@langchain/google-genai": "^2.0.0",
+    "@langchain/ollama": "^1.0.3",
+    "@langchain/openai": "^1.1.3",
+    "@langchain/tavily": "^1.0.1",
+    "@modelcontextprotocol/sdk": "^1.13.0",
+    "@mozilla/readability": "^0.6.0",
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "dotenv": "^17.2.3",
+    "exa-js": "^2.2.0",
+    "figlet": "^1.10.0",
+    "gray-matter": "^4.0.3",
+    "ink": "^6.5.1",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "langsmith": "^0.4.10",
+    "linkedom": "^0.18.12",
+    "playwright": "^1.52.0",
+    "react": "^19.2.0",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
+    "@types/bun": "latest",
+    "@types/figlet": "^1.7.0",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.2.7",
+    "babel-jest": "^30.2.0",
+    "ink-testing-library": "^4.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.9.3"
+  }
+}

package/src/agent/agent.test.ts

@@ -0,0 +1,414 @@
+import { describe, test, expect, mock, beforeAll, afterAll, beforeEach } from 'bun:test';
+import { createMockAIMessage, createMockTool, createTempDir } from '../test-utils/mocks.js';
+import type { AgentEvent, DoneEvent } from './types.js';
+
+// ---------------------------------------------------------------------------
+// Mock dependencies before importing Agent
+// ---------------------------------------------------------------------------
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const mockCallLlm = mock(async (): Promise<any> => ({
+  response: 'default response',
+  usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+}));
+
+mock.module('../model/llm.js', () => ({
+  callLlm: mockCallLlm,
+  DEFAULT_MODEL: 'claude-sonnet-4-5',
+}));
+
+const mockGetTools = mock(() => [
+  createMockTool('search', '{"results": "BTC is $65000"}'),
+  createMockTool('api', '{"data": "some api data"}'),
+]);
+
+mock.module('../tools/registry.js', () => ({
+  getTools: mockGetTools,
+  buildToolDescriptions: () => 'Mock tool descriptions',
+}));
+
+mock.module('./prompts.js', () => ({
+  buildSystemPrompt: () => 'You are a test agent.',
+  buildIterationPrompt: (query: string, results: string) => `Query: ${query}\nResults: ${results}`,
+  buildFinalAnswerPrompt: (query: string, context: string) => `Answer: ${query}\nContext: ${context}`,
+  DEFAULT_SYSTEM_PROMPT: 'Default test system prompt.',
+}));
+
+mock.module('../utils/tool-description.js', () => ({
+  getToolDescription: (name: string) => name,
+}));
+
+mock.module('../skills/index.js', () => ({
+  discoverSkills: () => [],
+  buildSkillMetadataSection: () => '',
+}));
+
+// Import Agent after mocks
+const { Agent } = await import('./agent.js');
+
+// ---------------------------------------------------------------------------
+// Setup temp CWD for scratchpad files
+// ---------------------------------------------------------------------------
+
+let originalCwd: string;
+let cleanup: () => void;
+
+beforeAll(() => {
+  originalCwd = process.cwd();
+  const tmp = createTempDir();
+  cleanup = tmp.cleanup;
+  process.chdir(tmp.path);
+});
+
+afterAll(() => {
+  process.chdir(originalCwd);
+  cleanup();
+});
+
+beforeEach(() => {
+  mockCallLlm.mockClear();
+  mockGetTools.mockClear();
+  mockGetTools.mockReturnValue([
+    createMockTool('search', '{"results": "BTC is $65000"}'),
+    createMockTool('api', '{"data": "some api data"}'),
+  ]);
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function collectEvents(agent: any, query: string): Promise<AgentEvent[]> {
+  const events: AgentEvent[] = [];
+  for await (const event of agent.run(query)) {
+    events.push(event);
+  }
+  return events;
+}
+
+function findDone(events: AgentEvent[]): DoneEvent {
+  return events.find(e => e.type === 'done') as DoneEvent;
+}
+
+// ---------------------------------------------------------------------------
+// Simple query (no tools)
+// ---------------------------------------------------------------------------
+
+describe('Agent - simple query (no tools)', () => {
+  test('LLM returns string → done with text, iterations=1', async () => {
+    mockCallLlm.mockResolvedValue({
+      response: 'Hello! How can I help?',
+      usage: { inputTokens: 50, outputTokens: 20, totalTokens: 70 },
+    });
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5' });
+    const events = await collectEvents(agent, 'hi');
+
+    const done = findDone(events);
+    expect(done).toBeDefined();
+    expect(done.answer).toBe('Hello! How can I help?');
+    expect(done.iterations).toBe(1);
+    expect(done.toolCalls.length).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Single tool call
+// ---------------------------------------------------------------------------
+
+describe('Agent - tool calls', () => {
+  test('single tool call flow: tool_start → tool_end → done', async () => {
+    // First call: LLM wants to call a tool
+    mockCallLlm.mockResolvedValueOnce({
+      response: createMockAIMessage('Let me search for that', [
+        { name: 'search', args: { query: 'BTC price' } },
+      ]),
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+    // Second call: LLM gives final answer (no tools)
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'BTC is at $65,000',
+      usage: { inputTokens: 200, outputTokens: 100, totalTokens: 300 },
+    });
+    // Third call: final answer generation
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'Bitcoin is currently priced at $65,000.',
+      usage: { inputTokens: 150, outputTokens: 80, totalTokens: 230 },
+    });
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5' });
+    const events = await collectEvents(agent, 'What is BTC price?');
+
+    const types = events.map(e => e.type);
+    expect(types).toContain('tool_start');
+    expect(types).toContain('tool_end');
+    expect(types).toContain('done');
+
+    const done = findDone(events);
+    expect(done.toolCalls.length).toBeGreaterThan(0);
+  });
+
+  test('tool error: yields tool_error and agent continues', async () => {
+    const errorTool = createMockTool('broken', () => {
+      throw new Error('API timeout');
+    });
+    mockGetTools.mockReturnValue([errorTool]);
+
+    // LLM calls the broken tool
+    mockCallLlm.mockResolvedValueOnce({
+      response: createMockAIMessage('', [
+        { name: 'broken', args: {} },
+      ]),
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+    // LLM gives answer after error
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'I encountered an error.',
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+    // Final answer generation
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'Sorry, there was an error getting the data.',
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5' });
+    const events = await collectEvents(agent, 'test error');
+
+    const types = events.map(e => e.type);
+    expect(types).toContain('tool_error');
+    expect(types).toContain('done');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Max iterations
+// ---------------------------------------------------------------------------
+
+describe('Agent - max iterations', () => {
+  test('stops at max iterations and still generates final answer', async () => {
+    // Always return tool calls to force max iterations
+    mockCallLlm.mockResolvedValue({
+      response: createMockAIMessage('thinking...', [
+        { name: 'search', args: { query: 'loop' } },
+      ]),
+      usage: { inputTokens: 50, outputTokens: 25, totalTokens: 75 },
+    });
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5', maxIterations: 2 });
+
+    // Override only the last callLlm (final answer after max iterations)
+    let callCount = 0;
+    mockCallLlm.mockImplementation(async () => {
+      callCount++;
+      if (callCount <= 2) {
+        return {
+          response: createMockAIMessage('', [
+            { name: 'search', args: { query: `attempt ${callCount}` } },
+          ]),
+          usage: { inputTokens: 50, outputTokens: 25, totalTokens: 75 },
+        };
+      }
+      // Final answer generation call
+      return {
+        response: 'Max iterations reached, here is what I found.',
+        usage: { inputTokens: 50, outputTokens: 25, totalTokens: 75 },
+      };
+    });
+
+    const events = await collectEvents(agent, 'loop test');
+    const done = findDone(events);
+    expect(done).toBeDefined();
+    expect(done.iterations).toBe(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// No tools available
+// ---------------------------------------------------------------------------
+
+describe('Agent - no tools', () => {
+  test('yields done with "No tools available" message', async () => {
+    mockGetTools.mockReturnValue([]);
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5' });
+    const events = await collectEvents(agent, 'test query');
+
+    const done = findDone(events);
+    expect(done.answer).toContain('No tools available');
+    expect(done.iterations).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Skill deduplication
+// ---------------------------------------------------------------------------
+
+describe('Agent - skill deduplication', () => {
+  test('same skill called twice → second skipped', async () => {
+    const skillInvocations: string[] = [];
+    const skillTool = createMockTool('skill', (args) => {
+      skillInvocations.push(args.skill as string);
+      return 'skill result';
+    });
+    mockGetTools.mockReturnValue([skillTool]);
+
+    // LLM requests same skill twice in one response
+    mockCallLlm.mockResolvedValueOnce({
+      response: createMockAIMessage('', [
+        { name: 'skill', args: { skill: 'price-lookup' } },
+        { name: 'skill', args: { skill: 'price-lookup' } },
+      ]),
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'Done.',
+      usage: { inputTokens: 50, outputTokens: 25, totalTokens: 75 },
+    });
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'Final answer after skill.',
+      usage: { inputTokens: 50, outputTokens: 25, totalTokens: 75 },
+    });
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5' });
+    const events = await collectEvents(agent, 'run skill');
+
+    // Skill should only have been invoked once
+    expect(skillInvocations.length).toBe(1);
+    expect(skillInvocations[0]).toBe('price-lookup');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Thinking events
+// ---------------------------------------------------------------------------
+
+describe('Agent - thinking events', () => {
+  test('emits thinking event when LLM includes text alongside tool calls', async () => {
+    mockCallLlm.mockResolvedValueOnce({
+      response: createMockAIMessage('Let me search for Bitcoin data.', [
+        { name: 'search', args: { query: 'BTC' } },
+      ]),
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'BTC is $65k',
+      usage: { inputTokens: 50, outputTokens: 25, totalTokens: 75 },
+    });
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'Bitcoin costs $65,000.',
+      usage: { inputTokens: 50, outputTokens: 25, totalTokens: 75 },
+    });
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5' });
+    const events = await collectEvents(agent, 'BTC price');
+
+    const thinking = events.find(e => e.type === 'thinking');
+    expect(thinking).toBeDefined();
+    if (thinking?.type === 'thinking') {
+      expect(thinking.message).toContain('search for Bitcoin');
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Token usage tracking
+// ---------------------------------------------------------------------------
+
+describe('Agent - token usage', () => {
+  test('done event includes accumulated token usage', async () => {
+    mockCallLlm.mockResolvedValue({
+      response: 'Quick answer',
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5' });
+    const events = await collectEvents(agent, 'simple');
+
+    const done = findDone(events);
+    expect(done.tokenUsage).toBeDefined();
+    expect(done.tokenUsage!.totalTokens).toBeGreaterThan(0);
+    expect(done.totalTime).toBeGreaterThanOrEqual(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildFullContextForAnswer
+// ---------------------------------------------------------------------------
+
+describe('Agent - context building', () => {
+  test('filters out error results from final context', async () => {
+    const errorTool = createMockTool('flaky', (args) => {
+      if (args.fail) throw new Error('timeout');
+      return '{"data": "good"}';
+    });
+    const goodTool = createMockTool('reliable', () => '{"data": "success"}');
+    mockGetTools.mockReturnValue([errorTool, goodTool]);
+
+    // First call: both tools, one will fail
+    mockCallLlm.mockResolvedValueOnce({
+      response: createMockAIMessage('', [
+        { name: 'flaky', args: { fail: true } },
+        { name: 'reliable', args: {} },
+      ]),
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+    // Second call: no more tools
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'data gathered',
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+    // Final answer
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'Here is the result from reliable tool.',
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5' });
+    const events = await collectEvents(agent, 'mixed results');
+
+    const done = findDone(events);
+    expect(done.answer).toBeDefined();
+    // The final answer prompt should have been called with context that excludes errors
+    // We can verify the LLM was called with a prompt that doesn't include "Error:"
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const lastCallArgs = mockCallLlm.mock.calls[mockCallLlm.mock.calls.length - 1] as any[];
+    const promptArg = lastCallArgs?.[0] as string;
+    if (promptArg) {
+      expect(promptArg).not.toContain('Error: timeout');
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// answer_start event
+// ---------------------------------------------------------------------------
+
+describe('Agent - answer_start event', () => {
+  test('emits answer_start before done', async () => {
+    mockCallLlm.mockResolvedValueOnce({
+      response: createMockAIMessage('', [
+        { name: 'search', args: { query: 'test' } },
+      ]),
+      usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+    });
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'done searching',
+      usage: { inputTokens: 50, outputTokens: 25, totalTokens: 75 },
+    });
+    mockCallLlm.mockResolvedValueOnce({
+      response: 'Final answer.',
+      usage: { inputTokens: 50, outputTokens: 25, totalTokens: 75 },
+    });
+
+    const agent = Agent.create({ model: 'claude-sonnet-4-5' });
+    const events = await collectEvents(agent, 'test');
+
+    const types = events.map(e => e.type);
+    const answerStartIdx = types.indexOf('answer_start');
+    const doneIdx = types.indexOf('done');
+    expect(answerStartIdx).toBeGreaterThanOrEqual(0);
+    expect(doneIdx).toBeGreaterThan(answerStartIdx);
+  });
+});