Four reference agents. Same skeleton underneath.

import { loadConfig, createSageFromConfig } from '../shared/config.js';
import { BaseAgent } from '../shared/base-agent.js';
import { taskId } from '@sage/core';
import { taskEscrowAbi } from '@sage/adapter-evm';

// Per-role private key override — multi-process Fly inherits the same env,
// so each worker reads its own override before falling back to PRIVATE_KEY.
if (process.env.SUMMARIZER_PRIVATE_KEY) {
  process.env.PRIVATE_KEY = process.env.SUMMARIZER_PRIVATE_KEY;
}

const config = loadConfig(3001);
// The bundle resolves the contract addresses for whatever chain it's on —
// read the escrow from chainConfig, never branch on the chain name (a stale
// ternary here once shipped the wrong address to a third chain).
const { sage, publicClient, account, chainConfig } = createSageFromConfig(config);
const escrowAddress = chainConfig.contracts.taskEscrow;

// === CAPABILITY-SPECIFIC: this is the only block that changes per agent ===
async function summarize(text: string): Promise<string> {
  if (!config.openaiApiKey) return `[MOCK SUMMARY] ${text.slice(0, 100)}...`;

  const res = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${config.openaiApiKey}`,
    },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [
        { role: 'system', content: 'Summarize the following text concisely.' },
        { role: 'user', content: text },
      ],
      max_tokens: 200,
    }),
  });
  const data = await res.json();
  return data.choices?.[0]?.message?.content ?? 'Summary unavailable';
}
// === /CAPABILITY-SPECIFIC ===

async function handleTaskCreated(
  taskIdBigInt: bigint,
  _client: `0x${string}`,
  executor: `0x${string}`,
) {
  // Filter: only handle tasks addressed to us.
  if (executor.toLowerCase() !== account.address.toLowerCase()) return;

  const id = taskId(taskIdBigInt.toString());
  const acceptHash = await sage.tasks.acceptTask(id);
  const receipt = await publicClient.waitForTransactionReceipt({ hash: acceptHash });
  if (receipt.status === 'reverted') return; // another agent got there first

  // Brief wait for state propagation, then read the spec.
  await new Promise(r => setTimeout(r, 2000));
  const task = await sage.tasks.getTask(id);
  if (!task) return;

  // Capability-specific work.
  const result = await summarize(task.specUri);
  const resultUri = `data:text/plain,${encodeURIComponent(result)}`;

  await sage.tasks.completeTask(id, resultUri);
}

const agent = new BaseAgent({
  name: 'Summarizer',
  port: config.port,
  async onStart() {
    publicClient.watchContractEvent({
      address: escrowAddress,
      abi: taskEscrowAbi,
      eventName: 'TaskCreated',
      onLogs(logs) {
        for (const log of logs) {
          handleTaskCreated(
            log.args.taskId!,
            log.args.client!,
            log.args.executor!,
          ).catch(console.error);
        }
      },
    });
  },
});

agent.start().catch(console.error);

async function translate(text: string): Promise<string> {
  if (!config.openaiApiKey) return `[MOCK TRANSLATION] ${text.slice(0, 80)}`;

  const res = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.openaiApiKey}` },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [
        { role: 'system', content: 'Translate English ↔ Russian. Detect direction from input.' },
        { role: 'user', content: text },
      ],
      max_tokens: 300,
    }),
  });
  const data = await res.json();
  return data.choices?.[0]?.message?.content ?? 'Translation unavailable';
}

async function classify(text: string): Promise<string> {
  if (!config.openaiApiKey) {
    return `NEUTRAL (0.50)\n\n[MOCK] No OpenAI key configured.`;
  }

  const res = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.openaiApiKey}` },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [
        {
          role: 'system',
          content:
            'Classify the user text as POSITIVE, NEGATIVE, or NEUTRAL. ' +
            'Three lines: <LABEL> (<score 0.00-1.00>), blank, 1-2 sentence rationale.',
        },
        { role: 'user', content: text },
      ],
      max_tokens: 200,
    }),
  });
  const data = await res.json();
  return data.choices?.[0]?.message?.content ?? 'Sentiment unavailable';
}

const MAX_DESCRIPTION_CHARS = 500;

async function describe(imageUrl: string): Promise<string> {
  if (!config.openaiApiKey) {
    return `[MOCK VISION] ${imageUrl}`.slice(0, MAX_DESCRIPTION_CHARS);
  }

  const res = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.openaiApiKey}` },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [
        {
          role: 'user',
          content: [
            { type: 'text', text: `Describe this image in ${MAX_DESCRIPTION_CHARS} characters or less.` },
            { type: 'image_url', image_url: { url: imageUrl } },
          ],
        },
      ],
      max_tokens: 200,
    }),
  });
  const data = await res.json();
  const description = data.choices?.[0]?.message?.content ?? 'Description unavailable';
  return description.slice(0, MAX_DESCRIPTION_CHARS);
}

import { createSageClient } from '@sage/adapter-evm';
import { base } from '@sage/adapter-evm/chains';
import { taskEscrowAbi } from '@sage/adapter-evm';
import { taskId as taskIdHelper } from '@sage/core';
import { createPublicClient, createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const publicClient = createPublicClient({ chain: base, transport: http() });
const walletClient = createWalletClient({ account, chain: base, transport: http() });
const sage = createSageClient({ chain: base, publicClient, walletClient });

// ─── your capability ─────────────────────────────────────────────
async function doWork(specUri: string): Promise<string> {
  // Implement: fetch specUri, run your model / pipeline, return the result.
  return `processed: ${specUri}`;
}
// ─────────────────────────────────────────────────────────────────

publicClient.watchContractEvent({
  address: base.contracts.taskEscrow,
  abi: taskEscrowAbi,
  eventName: 'TaskCreated',
  async onLogs(logs) {
    for (const log of logs) {
      const { taskId: rawId, executor } = log.args;
      if (executor!.toLowerCase() !== account.address.toLowerCase()) continue;

      const id = taskIdHelper(rawId!.toString());
      const acceptHash = await sage.tasks.acceptTask(id);
      const receipt = await publicClient.waitForTransactionReceipt({ hash: acceptHash });
      if (receipt.status === 'reverted') continue;

      const task = await sage.tasks.getTask(id);
      const result = await doWork(task!.specUri);
      const resultUri = `data:text/plain,${encodeURIComponent(result)}`;
      await sage.tasks.completeTask(id, resultUri);
    }
  },
});

console.log('Agent listening on', account.address);