Build with the SDK

npm install agent-afk

export ANTHROPIC_API_KEY=sk-ant-...

import { queryText } from 'agent-afk';

const answer = await queryText('Summarize the last 10 git commits in this repo.', {
  model: 'sonnet',
});
console.log(answer);

import { query } from 'agent-afk';

for await (const event of query('Write a haiku about async generators.', { model: 'sonnet' })) {
  if (event.type === 'chunk' && event.chunk.type === 'content') {
    process.stdout.write(event.chunk.content);
  }
}

import { queryStructured } from 'agent-afk';
import { z } from 'zod';

const Review = z.object({
  sentiment: z.enum(['positive', 'neutral', 'negative']),
  score: z.number().min(0).max(1),
  themes: z.array(z.string()),
});

const result = await queryStructured(
  'Classify this review: "The battery dies in an hour but the screen is gorgeous."',
  Review,
  { model: 'sonnet', maxRetries: 3 },
);

result.sentiment; // typed as 'positive' | 'neutral' | 'negative'

await queryText('...', {
  model: 'opus',            // AgentModelInput — alias or full id; defaults to 'sonnet'
  systemPrompt: 'You are a terse assistant.',
  maxTurns: 20,
  tools: { allowedTools: ['read_file', 'grep', 'glob'] },
  customTools: [getWeather],  // in-process tools — see "Custom tools" below
  canUseTool,                 // permission hook — see "Permissions" below
  maxBudgetUsd: 0.50,
});

import { AgentSession } from 'agent-afk';

const session = new AgentSession({
  model: 'sonnet',                          // required
  systemPrompt: 'You are a pair-programming assistant.',
  tools: { allowedTools: ['read_file', 'bash', 'edit_file'] },
  // apiKey is optional — falls back to ANTHROPIC_API_KEY
});

// 1. Await the final message
const reply = await session.sendMessage('What does src/index.ts export?');
console.log(reply.content); // string

// 2. Stream the turn (same OutputEvent shape as query())
for await (const event of session.sendMessageStream('Now explain the provider layer.')) {
  if (event.type === 'chunk' && event.chunk.type === 'content') {
    process.stdout.write(event.chunk.content);
  }
}

// 3. Validated structured output on the live turn
import { z } from 'zod';
const files = await session.sendMessageStructured(
  'List the TypeScript files you touched, as JSON.',
  z.object({ files: z.array(z.string()) }),
);

await session.close(); // release the session when done

await session.interrupt();                      // cancel the in-flight turn
await session.setModel('opus');                 // hot-swap the model mid-conversation
await session.setPermissionMode('acceptEdits'); // change the permission posture
await session.close();                          // tear down and free resources

const controller = new AbortController();

const session = new AgentSession({
  model: 'sonnet',
  maxBudgetUsd: 1.00,
  abortSignal: controller.signal,
});

// elsewhere: controller.abort() cancels any in-flight work

import { tool, queryText } from 'agent-afk';
import { z } from 'zod';

const getWeather = tool(
  'get_weather',
  'Get the current temperature for a city.',
  z.object({ city: z.string() }),
  async ({ city }, _signal) => {
    const tempC = await lookupTemp(city);
    return { content: `It is ${tempC}°C in ${city}.` };
  },
);

const answer = await queryText('What should I wear in Oslo today?', {
  customTools: [getWeather],
});

const session = new AgentSession({ model: 'sonnet', customTools: [getWeather] });

import { AgentSession, SubagentManager } from 'agent-afk';
import { z } from 'zod';

const parent = new AgentSession({ model: 'sonnet' });
const manager = new SubagentManager({ parentModel: 'sonnet' });

const handle = await manager.forkSubagent({
  parent,                                   // provides session identity to fork from
  agentType: 'todo-scanner',                // required display label
  config: {
    model: 'haiku',                         // right-size the child
    tools: { allowedTools: ['read_file', 'grep', 'glob'] },
  },
  outputSchema: z.object({ todos: z.array(z.string()) }),
  phaseRole: 'read-only',                   // optional: hard read-only tool boundary
});

// Drive the child with its task prompt:
const result = await handle.runToResult('Find every TODO comment under src/ and list them.');

if (result.status === 'succeeded') {
  console.log(result.output?.todos);        // validated against outputSchema
}

await handle.teardown();

import { providerForModel, resolveProvider } from 'agent-afk';

providerForModel('sonnet');            // 'anthropic-direct'
providerForModel('gpt-4o');            // 'openai-compatible'
providerForModel('Qwen/Qwen2.5-72B');  // 'openai-compatible' (any org/model id)

import { AgentSession } from 'agent-afk';
import { myCustomProvider } from './my-provider.js';

const session = new AgentSession({ model: 'sonnet', provider: myCustomProvider });

import { AgentSession, createCanUseToolHook } from 'agent-afk';

const canUseTool = createCanUseToolHook({
  rules: {
    defaultMode: 'allow',
    tools: {
      bash: 'deny',            // runtime tool names (snake_case) — not "Bash"
      edit_file: 'deny',
      write_file: 'ask',
    },
  },
  onAsk: async ({ toolName, input }) => {
    // resolve interactively, from a policy, etc.
    return { behavior: 'allow' };
  },
  onDecision: (ctx, decision) => log(ctx.toolName, decision.behavior),
});

const session = new AgentSession({ model: 'sonnet', canUseTool });

if (event.type === 'chunk' && event.chunk.type === 'content') {
  process.stdout.write(event.chunk.content);
}

import { AgentSession, tool } from 'agent-afk';
import { z } from 'zod';

const now = tool(
  'now',
  'Return the current ISO timestamp.',
  z.object({}),
  async () => ({ content: new Date().toISOString() }),
);

const session = new AgentSession({
  model: 'sonnet',
  systemPrompt: 'You are a concise assistant. Use tools when useful.',
  customTools: [now],
  maxBudgetUsd: 0.25,
});

try {
  const a = await session.sendMessage('What time is it right now?');
  console.log(a.content);

  const b = await session.sendMessage('How many minutes until the next hour?');
  console.log(b.content);
} finally {
  await session.close();
}