Registry and serving

/**
 * Classify an array of mixed Agent/Team/Workflow instances into
 * separate maps keyed by each instance's `.name` property.
 */
export declare function classifyServables(items: Servable[]): ClassifiedServables;

export declare const registry: Registry;

/**
 * Live registry for Agents, Teams, and Workflows.
 *
 * Instances auto-register on construction (unless `register: false`).
 * Transport layers (Express, Socket.IO) read from the registry dynamically —
 * agents created after the gateway starts are immediately available.
 *
 * Names are labels, not unique keys: registering an item with an existing
 * name replaces the previous entry (last-write-wins). This allows the same
 * agent definition to be constructed repeatedly (loops, factories,
 * concurrent requests) without conflicts.
 *
 * @example
 * ```ts
 * createAgentGateway({ io, security: { mode: "local" } });
 *
 * new Agent({ name: "bot", model: openai("gpt-4o") });
 * // "bot" is immediately reachable via the gateway
 * ```
 */
export declare class Registry {
    readonly agents: Map<string, ServableAgent>;
    readonly teams: Map<string, Team>;
    readonly workflows: Map<string, Workflow<any>>;
    add(item: Servable): void;
    remove(item: Servable): boolean;
    getAgent(name: string): ServableAgent | undefined;
    getTeam(name: string): Team | undefined;
    getWorkflow(name: string): Workflow<any> | undefined;
    clear(): void;
    list(): {
        agents: string[];
        teams: string[];
        workflows: string[];
    };
    describeAgents(): Array<{
        name: string;
        model: string;
        provider: string;
        tools: string[];
        hasStructuredOutput: boolean;
        description?: string;
        capabilities: string[];
        version?: string;
    }>;
    getAgentCard(name: string): object | null;
    getAllAgentCards(): object[];
    describeTeams(): Array<{
        name: string;
    }>;
    describeWorkflows(): Array<{
        name: string;
    }>;
}

export type Servable = Agent | ServableAgent | Team | Workflow<any>;

/**
 * The minimal contract an agent must satisfy to be served by Agentium's
 * runtime (registry, Express/Socket.IO gateways, queue workers, observability).
 *
 * The first-party `Agent` class satisfies this structurally, but so can any
 * external implementation — a LangGraph graph, a Claude Agent SDK agent, or
 * plain custom code. Use `defineExternalAgent()` for a convenient way to wrap
 * custom run logic into this shape.
 *
 * Optional metadata fields light up extra runtime features when present
 * (provider-specific API key routing, swagger docs, approval endpoints,
 * checkpoint endpoints, correction capture).
 */
export interface ServableAgent {
    readonly kind: "agent";
    readonly name: string;
    run(input: MessageContent, opts?: RunOpts): Promise<RunOutput>;
    stream(input: MessageContent, opts?: RunOpts): AsyncIterable<StreamChunk>;
    /** Event bus for observability (tracing, metrics, approval streams). */
    readonly eventBus?: EventBus;
    readonly modelId?: string;
    readonly providerId?: string;
    readonly tools?: ReadonlyArray<{
        name: string;
        description?: string;
    }>;
    readonly instructions?: unknown;
    readonly hasStructuredOutput?: boolean;
    readonly structuredOutputSchema?: unknown;
    /** MemoryManager (or compatible) — enables the corrections endpoint. */
    readonly memory?: unknown;
    /** HITL approval manager — enables the approval endpoints. */
    readonly approvalManager?: unknown;
    /** Checkpoint manager — enables the checkpoint endpoints. */
    readonly checkpointManager?: unknown;
}

export interface ClassifiedServables {
    agents: Record<string, ServableAgent>;
    teams: Record<string, Team>;
    workflows: Record<string, Workflow<any>>;
}