Your first production agent.

// Module 16: your first production agent. Wire it once, run it forever.
import Anthropic from '@anthropic-ai/sdk';

// From the previous modules
import { loadState, saveState }     from './state.js';           // Module 06
import { Trace }                    from './trace.js';           // Module 06 + 10
import { Logger }                   from './logger.js';          // Module 12
import { checkKillSwitch }          from './kill.js';            // Module 14
import { readOverride }             from './override.js';        // Module 14
import { browseMarketsTool,  browseMarkets }  from './tools/browse.js';     // Module 07
import { checkFreshnessTool, checkFreshness } from './tools/freshness.js';    // Module 08
import { smartBuyTool,       smartBuy }        from './tools/smart_buy.js';  // Module 10
import { placeOrderSafe }           from './tools/guard.js';     // Module 14

const client    = new Anthropic();
const MAX_ITERS = 10;

async function runOnce() {
  const log   = new Logger();
  const trace = new Trace();

  checkKillSwitch();                              // Module 14: hard stop if flag set
  const override = readOverride();                // Module 14: human pause support
  if (override.paused) {
    log.info('paused', { reason: override.reason, until: override.until });
    return;
  }

  const state = await loadState();                // Module 06: position memory
  log.info('agent_start', { model: 'claude-opus-4-8', positions: state.positions.length });

  const messages: Anthropic.MessageParam[] = [
    { role: 'user', content: 'Scan Limitless for one good trade. If nothing qualifies, do nothing.' },
  ];

  for (let i = 0; i < MAX_ITERS; i++) {
    checkKillSwitch();                            // Module 14: re-check every iteration
    const resp = await client.messages.create({
      model:      'claude-opus-4-8',
      max_tokens: 1024,
      system:     'You are a cautious Limitless trading agent. Always call check_freshness before any trade.',
      tools:      [browseMarketsTool, checkFreshnessTool, smartBuyTool],
      messages,
    });

    await trace.log('assistant', resp.content);   // Module 12: reasoning trace

    if (resp.stop_reason === 'end_turn') break;

    const toolUses = resp.content.filter((c: any) => c.type === 'tool_use');
    messages.push({ role: 'assistant', content: resp.content });
    const results = await Promise.all(toolUses.map(async (tu: any) => {
      let out: string;
      try {
        if (tu.name === 'browse_markets')      out = await browseMarkets(tu.input);
        else if (tu.name === 'check_freshness') out = await checkFreshness(tu.input);
        else if (tu.name === 'smart_buy')      out = await smartBuy(tu.input);   // smart_buy calls placeOrderSafe internally
        else                                   out = `Error: unknown tool ${tu.name}`;
      } catch (e: any) {
        out = `Error: ${e.message}`;
      }
      await trace.log('tool_result', { name: tu.name, output: out });
      return { type: 'tool_result' as const, tool_use_id: tu.id, content: out };
    }));
    messages.push({ role: 'user', content: results });
  }

  await saveState(state);                          // Module 06: persist atomically
  log.info('agent_finish', { run_id: trace.runId });
}

runOnce().catch(err => {
  console.error('FATAL', err);
  process.exit(1);
});

# Module 16: your first production agent. Wire it once, run it forever.
import asyncio
import json
import os
import sys
from openai import AsyncOpenAI

# From the previous modules
from state    import load_state, save_state              # Module 06
from trace    import Trace                               # Module 06 + 10
from logger   import Logger                              # Module 12
from kill     import check_kill_switch                   # Module 14
from override import read_override                       # Module 14
from tools.browse    import browse_markets_tool,    browse_markets      # Module 07
from tools.freshness     import check_freshness_tool, check_freshness   # Module 08
from tools.smart_buy import smart_buy_tool,         smart_buy           # Module 10 (calls place_order_safe)

client    = AsyncOpenAI()
MAX_ITERS = 10


async def run_once() -> None:
    log   = Logger()
    trace = Trace()

    check_kill_switch()                                 # Module 14: hard stop
    override = read_override()                          # Module 14: human pause
    if override.paused:
        log.info("paused", reason=override.reason, until=override.until)
        return

    state = load_state()                                # Module 06: position memory
    log.info("agent_start", model="gpt-4o", positions=len(state.positions))

    messages = [
        {"role": "system", "content": "You are a cautious Limitless trading agent. Always call check_freshness before any trade."},
        {"role": "user",   "content": "Scan Limitless for one good trade. If nothing qualifies, do nothing."},
    ]

    for _ in range(MAX_ITERS):
        check_kill_switch()                             # Module 14: re-check every iteration
        resp = await client.chat.completions.create(
            model    = "gpt-4o",
            messages = messages,
            tools    = [browse_markets_tool, check_freshness_tool, smart_buy_tool],
        )
        msg = resp.choices[0].message
        messages.append(msg.model_dump(exclude_none=True))
        trace.log("assistant", {"content": msg.content})   # Module 12: reasoning trace

        if not msg.tool_calls:
            break

        for call in msg.tool_calls:
            args = json.loads(call.function.arguments)
            try:
                if call.function.name == "browse_markets":
                    out = browse_markets(**args)
                elif call.function.name == "check_freshness":
                    out = check_freshness(**args)
                elif call.function.name == "smart_buy":
                    out = smart_buy(**args)              # smart_buy calls place_order_safe internally
                else:
                    out = f"Error: unknown tool {call.function.name}"
            except Exception as e:
                out = f"Error: {e}"

            trace.log("tool_result", {"name": call.function.name, "output": out})
            messages.append({"role": "tool", "tool_call_id": call.id, "content": out})

    save_state(state)                                    # Module 06: persist atomically
    log.info("agent_finish", run_id=trace.run_id)


if __name__ == "__main__":
    try:
        asyncio.run(run_once())
    except Exception as e:
        print(f"FATAL {e}", file=sys.stderr)
        sys.exit(1)