Testing.

// Module 13: Tool-unit test for browse_markets
import { describe, it, expect } from 'vitest';
import { browseMarkets } from '../tools/browse_markets.js';

describe('browse_markets', () => {
  it('returns an array of market objects with required fields', async () => {
    const result = await browseMarkets({ limit: 5 });

    expect(Array.isArray(result.markets)).toBe(true);
    expect(result.markets.length).toBeLessThanOrEqual(5);

    for (const m of result.markets) {
      expect(m).toHaveProperty('id');
      expect(m).toHaveProperty('slug');
      expect(m).toHaveProperty('title');
      expect(typeof m.id).toBe('string');
      expect(typeof m.slug).toBe('string');
    }
  });

  it('rejects limit above 100', async () => {
    await expect(browseMarkets({ limit: 200 }))
      .rejects.toThrow(/limit must be/i);
  });

  it('returns empty array when no markets match filter', async () => {
    const result = await browseMarkets({ limit: 5, category: 'nonexistent' });
    expect(result.markets).toEqual([]);
  });
});

# Module 13: Tool-unit test for browse_markets
import pytest
from tools.browse_markets import browse_markets


def test_returns_market_objects_with_required_fields():
    result = browse_markets(limit=5)

    assert isinstance(result["markets"], list)
    assert len(result["markets"]) <= 5

    for m in result["markets"]:
        assert "id" in m
        assert "slug" in m
        assert "title" in m
        assert isinstance(m["id"], str)
        assert isinstance(m["slug"], str)


def test_rejects_limit_above_100():
    with pytest.raises(ValueError, match=r"limit must be"):
        browse_markets(limit=200)


def test_returns_empty_array_when_no_markets_match():
    result = browse_markets(limit=5, category="nonexistent")
    assert result["markets"] == []

// Module 13: Mock tool layer + trajectory recorder
import { randomUUID } from 'node:crypto';

interface ToolCall  { name: string; input: Record<string, unknown>; }
interface TraceStep { ts: string; kind: 'tool_call' | 'tool_result' | 'llm'; data: unknown; }

export class Trajectory {
  readonly id = randomUUID();
  readonly steps: TraceStep[] = [];

  record(kind: TraceStep['kind'], data: unknown) {
    this.steps.push({ ts: new Date().toISOString(), kind, data });
  }

  toolCalls()   { return this.steps.filter(s => s.kind === 'tool_call'); }
  toolResults() { return this.steps.filter(s => s.kind === 'tool_result'); }
}

// Mock tools: return canned data shaped like real Limitless responses
const MOCK_MARKETS = [
  { id: 'mkt_abc123', slug: 'btc-above-100k-june', title: 'Will BTC be above $100k in June?', yes_price: 0.62, no_price: 0.38 },
  { id: 'mkt_def456', slug: 'eth-merge-on-time',   title: 'Will the ETH upgrade ship on time?',  yes_price: 0.45, no_price: 0.55 },
];

export const mockTools: Record<string, (input: unknown) => unknown> = {
  browse_markets: (_input) => ({ markets: MOCK_MARKETS }),

  get_market: (input: any) => {
    const m = MOCK_MARKETS.find(m => m.id === input.market_id);
    if (!m) throw new Error(`market not found: ${input.market_id}`);
    return m;
  },

  place_limit_order: (input: any) => {
    if (!input.market_id || !input.side || !input.size_usd)
      throw new Error('missing required fields');
    if (input.size_usd > 25)
      throw new Error('exceeds per-order limit');
    return { order_id: 'ord_' + randomUUID().slice(0, 8), status: 'open' };
  },
};

// Usage in a test:
// const traj = new Trajectory();
// const agent = new Agent({ tools: mockTools, trajectory: traj });
// await agent.run('Find a crypto market and place a small YES order');
// assert(traj.toolCalls().some(c => c.data.name === 'browse_markets'));

# Module 13: Mock tool layer + trajectory recorder
import uuid
from dataclasses import dataclass, field
from datetime import datetime
from typing import Any

@dataclass
class TraceStep:
    ts: str
    kind: str   # "tool_call" | "tool_result" | "llm"
    data: Any

@dataclass
class Trajectory:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    steps: list[TraceStep] = field(default_factory=list)

    def record(self, kind: str, data: Any) -> None:
        self.steps.append(TraceStep(
            ts=datetime.utcnow().isoformat() + "Z", kind=kind, data=data,
        ))

    def tool_calls(self)   -> list[TraceStep]: return [s for s in self.steps if s.kind == "tool_call"]
    def tool_results(self) -> list[TraceStep]: return [s for s in self.steps if s.kind == "tool_result"]


# Mock tools: canned data shaped like real Limitless responses
MOCK_MARKETS = [
    {"id": "mkt_abc123", "slug": "btc-above-100k-june", "title": "Will BTC be above $100k in June?", "yes_price": 0.62, "no_price": 0.38},
    {"id": "mkt_def456", "slug": "eth-merge-on-time",   "title": "Will the ETH upgrade ship on time?",  "yes_price": 0.45, "no_price": 0.55},
]


def mock_browse_markets(_input: dict) -> dict:
    return {"markets": MOCK_MARKETS}


def mock_get_market(input: dict) -> dict:
    m = next((m for m in MOCK_MARKETS if m["id"] == input["market_id"]), None)
    if not m:
        raise ValueError(f"market not found: {input['market_id']}")
    return m


def mock_place_limit_order(input: dict) -> dict:
    for key in ("market_id", "side", "size_usd"):
        if key not in input:
            raise ValueError(f"missing required field: {key}")
    if input["size_usd"] > 25:
        raise ValueError("exceeds per-order limit")
    return {"order_id": f"ord_{uuid.uuid4().hex[:8]}", "status": "open"}


MOCK_TOOLS = {
    "browse_markets":    mock_browse_markets,
    "get_market":        mock_get_market,
    "place_limit_order": mock_place_limit_order,
}


# Usage in a test:
# traj = Trajectory()
# agent = Agent(tools=MOCK_TOOLS, trajectory=traj)
# agent.run("Find a crypto market and place a small YES order")
# assert any(c.data["name"] == "browse_markets" for c in traj.tool_calls())