Build a Long-Horizon Agent

1
import { OpenRouter, tool, stepCountIs, maxCost } from '@openrouter/agent';
2
import { z } from 'zod';
3
4
const openrouter = new OpenRouter({
5
  apiKey: process.env.OPENROUTER_API_KEY,
6
});
7
8
const searchTool = tool({
9
  name: 'search',
10
  description: 'Search the web for information',
11
  inputSchema: z.object({ query: z.string() }),
12
  execute: async ({ query }) => {
13
    return { results: await fetchResults(query) };
14
  },
15
});
16
17
const result = openrouter.callModel({
18
  model: '~anthropic/claude-opus-latest',
19
  input: 'Research the fusion energy landscape and produce a 5-page report.',
20
  tools: [searchTool],
21
  // Stop on whichever fires first.
22
  stopWhen: [stepCountIs(200), maxCost(5)],
23
});
24
25
const text = await result.getText();

1
import type { ConversationState, StateAccessor } from '@openrouter/agent';
2
import { readFile, rename, writeFile } from 'node:fs/promises';
3
4
const fileStateAccessor = (path: string): StateAccessor => ({
5
  load: async () => {
6
    // Only swallow ENOENT — real I/O or permission errors should surface
7
    // instead of silently restarting the agent from scratch.
8
    const raw = await readFile(path, 'utf8').catch((err: NodeJS.ErrnoException) => {
9
      if (err.code === 'ENOENT') return null;
10
      throw err;
11
    });
12
    return raw ? (JSON.parse(raw) as ConversationState) : null;
13
  },
14
  // Atomic write: write to a temp file, then rename. POSIX rename is
15
  // atomic on the same filesystem, so a crash mid-write cannot leave
16
  // a truncated state file that breaks resumption.
17
  save: async (state) => {
18
    const tmp = `${path}.tmp`;
19
    await writeFile(tmp, JSON.stringify(state));
20
    await rename(tmp, path);
21
  },
22
});
23
24
const result = openrouter.callModel({
25
  model: '~anthropic/claude-opus-latest',
26
  input: 'Plan and start a 3-day data migration.',
27
  tools: [searchTool],
28
  state: fileStateAccessor('./run.json'),
29
  stopWhen: [stepCountIs(200), maxCost(5)],
30
});
31
32
await result.getResponse();

1
const resumed = openrouter.callModel({
2
  model: '~anthropic/claude-opus-latest',
3
  input: [],
4
  state: fileStateAccessor('./run.json'),
5
  tools: [searchTool],
6
  stopWhen: [stepCountIs(200), maxCost(5)],
7
});
8
9
await resumed.getResponse();

1
const result = openrouter.callModel({
2
  model: '~anthropic/claude-opus-latest',
3
  input: 'Build a market analysis report on EV charging.',
4
  tools: [searchTool],
5
  stopWhen: [stepCountIs(100), maxCost(2)],
6
});
7
8
// Stream tool calls and text deltas concurrently.
9
const streamToolCalls = (async () => {
10
  for await (const call of result.getToolCallsStream()) {
11
    publishToDashboard({ kind: 'tool', name: call.name, args: call.arguments });
12
  }
13
})();
14
15
const streamText = (async () => {
16
  for await (const delta of result.getTextStream()) {
17
    publishToDashboard({ kind: 'token', delta });
18
  }
19
})();
20
21
await Promise.all([streamToolCalls, streamText]);
22
23
const final = await result.getResponse();
24
publishToDashboard({ kind: 'done', usage: final.usage });

1
import { OpenRouter, stepCountIs, maxCost } from '@openrouter/agent';
2
3
const openrouter = new OpenRouter({
4
  apiKey: process.env.OPENROUTER_API_KEY,
5
});
6
7
const SELF_ASK_MAX_ITERATIONS = 10;
8
const REVIEW_PROMPT = `Review your last response adversarially.
9
- Are there gaps, ambiguities, or unverified claims?
10
- If the work is complete and every claim is verified, reply with only [DONE].
11
- Otherwise list the gaps and keep researching.`;
12
13
const state = fileStateAccessor('./run.json');
14
let input: string | unknown[] =
15
  'Research the fusion energy landscape and produce a 5-page report.';
16
let final = '';
17
18
for (let i = 0; i < SELF_ASK_MAX_ITERATIONS; i++) {
19
  const result = openrouter.callModel({
20
    model: '~anthropic/claude-opus-latest',
21
    input,
22
    state,
23
    tools: [searchTool],
24
    // Per-iteration ceilings. The outer for-loop adds a third guard.
25
    stopWhen: [stepCountIs(50), maxCost(2)],
26
  });
27
  final = await result.getText();
28
  if (final.includes('[DONE]')) break;
29
  // Hand the assistant's own output back as an adversarial reviewer turn.
30
  input = REVIEW_PROMPT;
31
}

1
import { OpenRouter as SDK } from '@openrouter/sdk';
2
import { OpenRouter, stepCountIs, maxCost } from '@openrouter/agent';
3
import { readFile } from 'node:fs/promises';
4
5
const sdk = new SDK({ apiKey: process.env.OPENROUTER_API_KEY });
6
const agent = new OpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });
7
8
const audio = await readFile('./voice-memo.wav');
9
const transcription = await sdk.stt.createTranscription({
10
  model: 'openai/whisper-1',
11
  inputAudio: { data: audio.toString('base64'), format: 'wav' },
12
});
13
14
const result = agent.callModel({
15
  model: '~anthropic/claude-opus-latest',
16
  input: transcription.text,
17
  stopWhen: [stepCountIs(50), maxCost(2)],
18
});
19
20
const reply = await result.getText();

1
import { writeFile } from 'node:fs/promises';
2
3
const stream = await sdk.tts.createSpeech({
4
  model: 'openai/gpt-4o-mini-tts-2025-12-15',
5
  input: reply,
6
  voice: 'alloy',
7
  responseFormat: 'mp3',
8
});
9
10
const chunks: Uint8Array[] = [];
11
const reader = stream.getReader();
12
while (true) {
13
  const { done, value } = await reader.read();
14
  if (done) break;
15
  chunks.push(value);
16
}
17
18
await writeFile('./reply.mp3', Buffer.concat(chunks));

1
const final = await result.getResponse();
2
3
const webhookUrl = process.env.WEBHOOK_URL;
4
if (!webhookUrl) {
5
  throw new Error('WEBHOOK_URL env var is required for webhook notifications');
6
}
7
8
await fetch(webhookUrl, {
9
  method: 'POST',
10
  headers: { 'Content-Type': 'application/json' },
11
  body: JSON.stringify({
12
    status: 'completed',
13
    usage: final.usage,
14
    text: await result.getText(),
15
  }),
16
});