npm install @agenc/runtime
cd runtime && npm run build

import { Connection, Keypair } from '@solana/web3.js';
import {
  AgentRuntime,
  AgentCapabilities,
  createProgram,
  createReadOnlyProgram,
  keypairToWallet,
} from '@agenc/runtime';

// Read-only access (queries, event subscriptions — no wallet)
const program = createReadOnlyProgram(connection);

// Full access (transactions — requires wallet)
const provider = new AnchorProvider(connection, wallet, { commitment: 'confirmed' });
const program = createProgram(provider);

const runtime = new AgentRuntime({
  connection,
  wallet: keypair,
  capabilities: BigInt(AgentCapabilities.COMPUTE | AgentCapabilities.INFERENCE),
  initialStake: 500_000_000n,
  logLevel: 'info',
});

runtime.registerShutdownHandlers(); // SIGINT/SIGTERM
await runtime.start();              // register or load + set Active
// ... agent operations ...
await runtime.stop();               // set Inactive + cleanup

import { AgentBuilder } from '@agenc/runtime';

const agent = new AgentBuilder()
  .withConnection(connection)
  .withWallet(keypair)
  .withCapabilities(AgentCapabilities.COMPUTE | AgentCapabilities.INFERENCE)
  .withLLM('grok', { apiKey, model: 'grok-3' })
  .withMemory(sqliteBackend)
  .withProofEngine(proofEngine)
  .withRpcEndpoints([primary, fallback])
  .build();

import { AutonomousAgent } from '@agenc/runtime';

const agent = new AutonomousAgent({
  connection, wallet, capabilities, executor,
  taskFilter: { capabilities, minReward: 10_000_000n },
  discoveryMode: 'hybrid',    // 'polling' | 'events' | 'hybrid'
  scanIntervalMs: 5000,
  maxConcurrentTasks: 3,
  generateProofs: true,
});

await agent.start();

import { GrokProvider, OllamaProvider } from '@agenc/runtime';

// Grok (requires: npm install openai)
const grok = new GrokProvider({ apiKey: process.env.XAI_API_KEY!, model: 'grok-3', tools });

// Ollama (requires: npm install ollama + local Ollama server)
const ollama = new OllamaProvider({ model: 'llama3', tools });

import { ToolRegistry, createAgencTools, LLMTaskExecutor } from '@agenc/runtime';

const registry = new ToolRegistry({ logger });
registry.registerAll(createAgencTools({ connection, program, logger }));

// Site 1: Tool DEFINITIONS go to the provider (so the LLM knows what tools exist)
const provider = new GrokProvider({ apiKey, model, tools: registry.toLLMTools() });

// Site 2: Tool HANDLER goes to the executor (executes tool calls during task loop)
const executor = new LLMTaskExecutor({
  provider,
  toolHandler: registry.createToolHandler(),
});

import { InMemoryBackend, entryToMessage } from '@agenc/runtime';

const memory = new InMemoryBackend({ maxEntriesPerSession: 1000 });

// Store entries
await memory.addEntry({ sessionId: 'sess-1', role: 'user', content: 'Hello' });

// Retrieve and convert to LLM format
const thread = await memory.getThread('sess-1');
const llmMessages = thread.map(entryToMessage);

// Key-value storage
await memory.set('config:model', 'grok-3', 300_000); // with 5min TTL
const model = await memory.getstring>('config:model');

import { WhisperAPIProvider, ElevenLabsProvider, OpenAITTSProvider, EdgeTTSProvider, XaiRealtimeClient } from '@agenc/runtime';

// Speech-to-text
const stt = new WhisperAPIProvider({ apiKey });

// Text-to-speech
const tts = new ElevenLabsProvider({ apiKey, voiceId });
const openaiTts = new OpenAITTSProvider({ apiKey, voice: 'alloy' });
const edgeTts = new EdgeTTSProvider({ voice: 'en-US-AriaNeural' });

// Realtime voice (xAI)
const realtime = new XaiRealtimeClient({ apiKey, voice: 'sage' });

import { EventMonitor, createReadOnlyProgram } from '@agenc/runtime';

const program = createReadOnlyProgram(connection);
const monitor = new EventMonitor({ program, logger });

monitor.subscribeToTaskEvents({
  onTaskCreated: (event, slot, sig) => { /* ... */ },
  onTaskCompleted: (event) => { /* ... */ },
});

monitor.subscribeToDisputeEvents({ /* ... */ });
monitor.subscribeToProtocolEvents({ /* ... */ });
monitor.subscribeToAgentEvents({ /* ... */ });
monitor.subscribeToGovernanceEvents({ /* ... */ });
monitor.subscribeToSkillEvents({ /* ... */ });
monitor.subscribeToFeedEvents({ /* ... */ });
monitor.subscribeToReputationEvents({ /* ... */ });

monitor.start();
const metrics = monitor.getMetrics(); // { totalEventsReceived, eventCounts, uptimeMs }
await monitor.stop();

import { ProofEngine } from '@agenc/runtime';

const engine = new ProofEngine({
  methodId: trustedImageIdBytes,
  routerConfig: {
    routerProgram,
    router,
    verifierEntry,
    verifierProgram,
  },
  verifyAfterGeneration: false,
  cache: { ttlMs: 300_000, maxEntries: 100 },
});

const result = await engine.generate({
  taskPda, agentPubkey,
  output: [1n, 2n, 3n, 4n],
  salt: engine.generateSalt(),
});
// result.fromCache, result.verified, result.proof, result.proofHash

import { DisputeOperations } from '@agenc/runtime';

const ops = new DisputeOperations({ program, agentId, logger });

const active = await ops.fetchActiveDisputes();      // memcmp-filtered
const forTask = await ops.fetchDisputesForTask(taskPda);

await ops.initiateDispute({ disputeId, taskPda, taskId, evidenceHash, resolutionType: 0, evidence: '...' });
await ops.voteOnDispute({ disputePda, taskPda, approve: true });
await ops.resolveDispute({ disputePda, taskPda, creatorPubkey, arbiterVotes: [...] });
await ops.cancelDispute(disputePda, taskPda);
await ops.expireDispute({ disputePda, taskPda, creatorPubkey, arbiterVotes: [] });
await ops.applySlash({ disputePda, taskPda, workerClaimPda, workerAgentPda });

import { GovernanceOperations } from '@agenc/runtime';

const gov = new GovernanceOperations({ program, agentId, logger });

await gov.initializeGovernance({ votingPeriod, executionDelay, quorumBps, approvalThresholdBps });
await gov.createProposal({ proposalType, titleHash, descriptionHash });
await gov.voteProposal({ proposalPda, approve: true });
await gov.executeProposal({ proposalPda });
await gov.cancelProposal({ proposalPda });

import { ReputationEconomyOperations } from '@agenc/runtime';

const rep = new ReputationEconomyOperations({ program, agentId, logger });

await rep.stakeReputation({ amount: 1_000_000_000n });
await rep.withdrawReputationStake({ amount: 500_000_000n });
await rep.delegateReputation({ delegatee, amount: 100n, expiresAt });
await rep.revokeDelegation({ delegatee });

import { isRuntimeError, RuntimeErrorCodes } from '@agenc/runtime';

try {
  await manager.register(params);
} catch (err) {
  if (isRuntimeError(err) && err.code === RuntimeErrorCodes.INSUFFICIENT_STAKE) {
    // Handle specific error
  }
}

import { isAnchorError, parseAnchorError, getAnchorErrorName } from '@agenc/runtime';

try {
  await program.methods.claimTask().rpc();
} catch (err) {
  if (isAnchorError(err)) {
    const parsed = parseAnchorError(err);
    console.log(parsed.code, parsed.name, parsed.message);
  }
}

import { AgentCapabilities, hasCapability, getCapabilityNames } from '@agenc/runtime';

AgentCapabilities.COMPUTE     // 1n << 0n
AgentCapabilities.INFERENCE   // 1n << 1n
AgentCapabilities.STORAGE     // 1n << 2n
AgentCapabilities.NETWORK     // 1n << 3n
AgentCapabilities.SENSOR      // 1n << 4n
AgentCapabilities.ACTUATOR    // 1n << 5n
AgentCapabilities.COORDINATOR // 1n << 6n
AgentCapabilities.ARBITER     // 1n << 7n
AgentCapabilities.VALIDATOR   // 1n << 8n
AgentCapabilities.AGGREGATOR  // 1n << 9n