AgentRegistry

import { AgentRegistry } from '@frontmcp/sdk';

// Access via scope
const agents = scope.agents;

// List all agents
const allAgents = agents.getAgents();

// Find by ID
const agent = agents.findById('research-agent');

// Get agents as callable tools
const agentTools = agents.getAgentsAsTools();

getAgents(includeHidden?: boolean): ReadonlyArray<AgentEntry>

const agents = registry.getAgents();
for (const agent of agents) {
  console.log(`Agent: ${agent.id} - ${agent.description}`);
}

findById(id: string): AgentEntry | undefined

const agent = registry.findById('research-agent');
if (agent) {
  console.log(`Found: ${agent.name}`);
}

findByName(name: string): AgentEntry | undefined

const agent = registry.findByName('research');

getVisibleAgentsFor(agentId: string): ReadonlyArray<AgentEntry>

// Get agents that 'orchestrator' can call
const visibleAgents = registry.getVisibleAgentsFor('orchestrator');

getAgentsAsTools(): ReadonlyArray<ToolDefinition>

const agentTools = registry.getAgentsAsTools();
// Each agent becomes a callable tool with its input schema

getAgentToolsFor(agentId: string): ReadonlyArray<ToolDefinition>

// Get tools available to 'coordinator' agent
const tools = registry.getAgentToolsFor('coordinator');

getInlineAgents(): ReadonlyArray<AgentEntry>

listAllInstances(): ReadonlyArray<AgentEntry>

subscribe(
  opts: SubscribeOptions,
  cb: (event: AgentChangeEvent) => void
): () => void

const unsubscribe = registry.subscribe({}, (event) => {
  console.log(`Agent ${event.kind} (v${event.version}):`, event.agentId ?? 'n/a');
});

// Later
unsubscribe();

getCapabilities(): { listChanged: boolean }

hasAny(): boolean

adoptFromChild(child: AgentRegistry, childOwner: Owner): void

removeChild(child: AgentRegistry): void

dispose(): void

interface AgentChangeEvent {
  kind: 'added' | 'updated' | 'removed' | 'reset'
      | 'execution_start' | 'execution_complete' | 'execution_error';
  changeScope: 'global' | 'scope' | 'app' | 'plugin' | 'agent';
  version: number;
  snapshot: readonly AgentInstance[];
  /** ID of the affected agent (for single-agent events) */
  agentId?: string;
  agentFullName?: string;
  owner?: { kind: AgentChangeScope; id: string };
  timestamp?: number;
  execution?: {
    runId: string;
    input?: unknown;
    output?: unknown;
    error?: Error;
    durationMs?: number;
  };
}

@Agent({
  id: 'coordinator',
  name: 'Coordinator',
  description: 'Coordinates research tasks',
  visibleAgents: ['researcher', 'writer'], // Can only call these agents
})
class CoordinatorAgent extends AgentContext { }

const visible = registry.getVisibleAgentsFor('coordinator');
// Returns only 'researcher' and 'writer' agents

@Agent({
  id: 'research',
  name: 'Research Agent',
  inputSchema: {
    topic: z.string(),
    depth: z.enum(['shallow', 'deep']),
  },
})
class ResearchAgent extends AgentContext { }

// The agent becomes callable as a tool
await client.callTool('research', {
  topic: 'AI advancements',
  depth: 'deep',
});