@holoscript/framework 6.0.3

package/dist/OrchestratorAgent-BvWgf9uw.d.cts

@@ -0,0 +1,798 @@
+import { B as BaseAgent, A as AgentIdentity, P as PhaseResult } from './implementations-D9T3un9D.cjs';
+import { A as AgentManifest, a as AgentCapability, C as CapabilityType, b as CapabilityDomain, L as LatencyProfile, T as TrustLevel, V as Vector3 } from './AgentManifest-CB4xM-Ma.cjs';
+import { EventEmitter } from 'events';
+
+/**
+ * @holoscript/core - Capability Matcher
+ *
+ * Matches capability queries against agent manifests.
+ * Part of HoloScript v3.1 Agentic Choreography.
+ */
+
+/**
+ * Query for finding agents with specific capabilities
+ */
+interface CapabilityQuery {
+    /** Required capability type(s) */
+    type?: CapabilityType | CapabilityType[] | string | string[];
+    /** Required domain(s) */
+    domain?: CapabilityDomain | CapabilityDomain[] | string | string[];
+    /** Maximum acceptable latency */
+    maxLatency?: LatencyProfile;
+    /** Minimum required trust level */
+    minTrust?: TrustLevel;
+    /** Spatial requirements */
+    spatial?: SpatialQuery;
+    /** Required tags */
+    tags?: string[];
+    /** Custom filters */
+    filters?: Record<string, unknown>;
+    /** Maximum results to return */
+    limit?: number;
+    /** Whether to include offline agents */
+    includeOffline?: boolean;
+    /** Sort order */
+    sortBy?: 'latency' | 'trust' | 'priority' | 'name';
+    /** Sort direction */
+    sortOrder?: 'asc' | 'desc';
+}
+/**
+ * Spatial query for location-aware discovery
+ */
+interface SpatialQuery {
+    /** Point that must be within agent's scope */
+    point?: Vector3;
+    /** Scene/world filter */
+    scene?: string;
+    /** Node IDs to check */
+    nodes?: string[];
+    /** Minimum overlap with bounding box */
+    overlaps?: {
+        min: Vector3;
+        max: Vector3;
+    };
+    /** Require global scope */
+    requireGlobal?: boolean;
+}
+/**
+ * Individual capability match result
+ */
+interface CapabilityMatch {
+    /** The matched capability */
+    capability: AgentCapability;
+    /** Match score (0-1) */
+    score: number;
+    /** Which query criteria matched */
+    matchedCriteria: string[];
+}
+/**
+ * Agent match result with scoring
+ */
+interface AgentMatch {
+    /** The matched agent manifest */
+    manifest: AgentManifest;
+    /** Overall match score (0-1) */
+    score: number;
+    /** Individual capability matches */
+    capabilities: CapabilityMatch[];
+    /** Why this agent matched */
+    reasons: string[];
+}
+/**
+ * Matches capability queries against agent manifests
+ */
+declare class CapabilityMatcher {
+    /**
+     * Check if a capability matches the query
+     */
+    matchCapability(capability: AgentCapability, query: CapabilityQuery): CapabilityMatch | null;
+    /**
+     * Check if an agent matches the query
+     */
+    matchAgent(manifest: AgentManifest, query: CapabilityQuery): AgentMatch | null;
+    /**
+     * Find all matching agents from a list
+     */
+    findMatches(manifests: AgentManifest[], query: CapabilityQuery): AgentMatch[];
+    /**
+     * Find the best matching agent
+     */
+    findBest(manifests: AgentManifest[], query: CapabilityQuery): AgentMatch | null;
+    /**
+     * Sort matches by criteria
+     */
+    sortMatches(matches: AgentMatch[], sortBy: 'latency' | 'trust' | 'priority' | 'name' | 'score', sortOrder: 'asc' | 'desc'): void;
+    private getFastestLatency;
+    private getHighestPriority;
+}
+/**
+ * Default matcher instance
+ */
+declare const defaultMatcher: CapabilityMatcher;
+/**
+ * Convenience function to find matching agents
+ */
+declare function findAgents(manifests: AgentManifest[], query: CapabilityQuery): AgentMatch[];
+/**
+ * Convenience function to find the best agent
+ */
+declare function findBestAgent(manifests: AgentManifest[], query: CapabilityQuery): AgentMatch | null;
+
+/**
+ * @holoscript/core - Agent Registry
+ *
+ * Central registry for agent registration, discovery, and health tracking.
+ * Part of HoloScript v3.1 Agentic Choreography.
+ */
+
+/**
+ * Discovery mode for the registry
+ */
+type DiscoveryMode = 'central' | 'broadcast' | 'hybrid';
+/**
+ * Registry configuration
+ */
+interface RegistryConfig {
+    /** Discovery mode */
+    mode: DiscoveryMode;
+    /** Default TTL for agent registrations (ms) */
+    defaultTTL: number;
+    /** Health check interval (ms) */
+    healthCheckInterval: number;
+    /** Max time before agent is marked offline (ms) */
+    offlineThreshold: number;
+    /** Whether to auto-cleanup offline agents */
+    autoCleanup: boolean;
+    /** Cleanup interval (ms) */
+    cleanupInterval: number;
+    /** Maximum number of agents */
+    maxAgents: number;
+    /** Minimum trust level for registration */
+    minTrustForRegistration: TrustLevel;
+}
+/**
+ * Default configuration
+ */
+declare const DEFAULT_REGISTRY_CONFIG: RegistryConfig;
+/**
+ * Registry event types
+ */
+interface RegistryEvents {
+    'agent:registered': (manifest: AgentManifest) => void;
+    'agent:deregistered': (agentId: string, reason: string) => void;
+    'agent:online': (agentId: string) => void;
+    'agent:offline': (agentId: string) => void;
+    'agent:degraded': (agentId: string) => void;
+    'agent:updated': (manifest: AgentManifest) => void;
+    'registry:cleanup': (removedCount: number) => void;
+    'registry:error': (error: Error) => void;
+}
+/**
+ * Central registry for agent registration and discovery
+ */
+declare class AgentRegistry extends EventEmitter {
+    private agents;
+    private matcher;
+    private config;
+    private healthCheckTimer?;
+    private cleanupTimer?;
+    private isShuttingDown;
+    constructor(config?: Partial<RegistryConfig>);
+    /**
+     * Start the registry (begins health checks and cleanup)
+     */
+    start(): void;
+    /**
+     * Stop the registry
+     */
+    stop(): void;
+    /**
+     * Clear all agents and reset
+     */
+    clear(): void;
+    /**
+     * Register an agent
+     */
+    register(manifest: AgentManifest): Promise<void>;
+    /**
+     * Deregister an agent
+     */
+    deregister(agentId: string): Promise<void>;
+    /**
+     * Update an agent's heartbeat
+     */
+    heartbeat(agentId: string): Promise<void>;
+    /**
+     * Discover agents matching a capability query
+     */
+    discover(query: CapabilityQuery): Promise<AgentManifest[]>;
+    /**
+     * Discover agents with full match details
+     */
+    discoverWithScores(query: CapabilityQuery): Promise<AgentMatch[]>;
+    /**
+     * Find the best agent for a query
+     */
+    findBest(query: CapabilityQuery): Promise<AgentManifest | null>;
+    /**
+     * Get a specific agent by ID
+     */
+    get(agentId: string): AgentManifest | undefined;
+    /**
+     * Check if an agent is registered
+     */
+    has(agentId: string): boolean;
+    /**
+     * Get all registered manifests
+     */
+    getAllManifests(): AgentManifest[];
+    /**
+     * Get count of registered agents
+     */
+    get size(): number;
+    /**
+     * Get count by status
+     */
+    getStatusCounts(): Record<string, number>;
+    /**
+     * Perform health check on all agents
+     */
+    private performHealthCheck;
+    /**
+     * Cleanup expired/offline agents
+     */
+    private cleanup;
+    /**
+     * Find agents by trust level
+     */
+    findByTrust(trustLevel: TrustLevel): AgentManifest[];
+    /**
+     * Find agents by tag
+     */
+    findByTag(tag: string): AgentManifest[];
+    /**
+     * Find online agents
+     */
+    findOnline(): AgentManifest[];
+    /**
+     * Find agents in a scene
+     */
+    findInScene(scene: string): AgentManifest[];
+    /**
+     * Export registry state
+     */
+    export(): {
+        agents: AgentManifest[];
+        config: RegistryConfig;
+        timestamp: number;
+    };
+    /**
+     * Import registry state
+     */
+    import(data: {
+        agents: AgentManifest[];
+    }): Promise<void>;
+}
+/**
+ * Get or create the default registry instance
+ */
+declare function getDefaultRegistry(config?: Partial<RegistryConfig>): AgentRegistry;
+/**
+ * Reset the default registry
+ */
+declare function resetDefaultRegistry(): void;
+
+/**
+ * @holoscript/core - Federated Registry Adapter
+ *
+ * Extends the AgentRegistry with cross-composition discovery by
+ * fetching remote A2A Agent Cards from /.well-known/agent-card.json
+ * endpoints and converting them to AgentManifest entries.
+ *
+ * Part of HoloScript v5.5 "Agents as Universal Orchestrators".
+ */
+
+/**
+ * Minimal A2A AgentCard shape for federation.
+ * Matches the full AgentCard type in packages/mcp-server/src/a2a.ts.
+ */
+interface A2AAgentCard {
+    id: string;
+    name: string;
+    description?: string;
+    endpoint: string;
+    version: string;
+    provider?: {
+        organization: string;
+        url: string;
+    };
+    capabilities?: {
+        streaming?: boolean;
+        pushNotifications?: boolean;
+        stateTransitionHistory?: boolean;
+    };
+    skills?: A2ASkill[];
+}
+interface A2ASkill {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    inputModes?: string[];
+    outputModes?: string[];
+}
+interface FederatedRegistryConfig {
+    /** Remote agent-card.json URLs to poll */
+    seedUrls: string[];
+    /** Poll interval in ms (default 60_000) */
+    pollIntervalMs: number;
+    /** Maximum remote agents to track (default 100) */
+    maxRemoteAgents: number;
+    /** Trust level assigned to remote agents (default 'external') */
+    trustRemoteAs: TrustLevel;
+    /** HTTP fetch timeout in ms (default 5_000) */
+    timeout: number;
+    /** Custom fetch function (for testing) */
+    fetchFn?: (url: string, init?: RequestInit) => Promise<Response>;
+}
+declare class FederatedRegistryAdapter {
+    private registry;
+    private config;
+    private pollTimer?;
+    private remoteAgentIds;
+    private lastPollResults;
+    constructor(registry: AgentRegistry, config?: Partial<FederatedRegistryConfig>);
+    /**
+     * Fetch a remote agent card and register it into the local registry.
+     * Returns the converted manifest on success, null on failure.
+     */
+    fetchAndRegister(url: string): Promise<AgentManifest | null>;
+    /**
+     * Poll all seed URLs once. Returns summary of results.
+     */
+    pollAll(): Promise<{
+        added: number;
+        updated: number;
+        failed: string[];
+    }>;
+    /**
+     * Start periodic polling of seed URLs.
+     */
+    startPolling(): void;
+    /**
+     * Stop periodic polling.
+     */
+    stopPolling(): void;
+    /**
+     * Whether polling is currently active.
+     */
+    get isPolling(): boolean;
+    /**
+     * Convert an A2A AgentCard to an AgentManifest.
+     */
+    a2aCardToManifest(card: A2AAgentCard, sourceUrl: string): AgentManifest;
+    /**
+     * Discover agents across local registry + remote seeds.
+     * Ensures all seed URLs are polled before querying.
+     */
+    discoverFederated(query: CapabilityQuery): Promise<AgentMatch[]>;
+    /**
+     * Get all remote agent IDs tracked by this adapter.
+     */
+    getRemoteAgentIds(): string[];
+    /**
+     * Get the number of remote agents currently tracked.
+     */
+    get remoteAgentCount(): number;
+    /**
+     * Get poll results for a specific URL.
+     */
+    getPollResult(url: string): {
+        timestamp: number;
+        success: boolean;
+    } | undefined;
+    /**
+     * Add a seed URL dynamically (does not trigger immediate poll).
+     */
+    addSeedUrl(url: string): void;
+    /**
+     * Remove a seed URL and optionally deregister its agent.
+     */
+    removeSeedUrl(url: string, deregister?: boolean): Promise<void>;
+    /**
+     * Fetch an agent card from a URL.
+     */
+    private fetchAgentCard;
+    /**
+     * Extract capabilities from an A2A AgentCard's skills.
+     */
+    private extractCapabilities;
+    /**
+     * Extract endpoint from an A2A AgentCard.
+     */
+    private extractEndpoint;
+    /**
+     * Derive capability type from A2A skill tags.
+     */
+    private deriveType;
+    /**
+     * Derive capability domain from A2A skill tags.
+     */
+    private deriveDomain;
+    /**
+     * Check if a URL has been successfully polled before.
+     */
+    private isKnownUrl;
+}
+
+/**
+ * @holoscript/core - Task Delegation Service
+ *
+ * Cross-agent task forwarding with support for local (in-process) and remote
+ * (A2A JSON-RPC) delegation. Includes auto-delegation via capability matching,
+ * retry with exponential backoff, and delegation history tracking.
+ *
+ * Part of HoloScript v5.5 "Agents as Universal Orchestrators".
+ */
+
+interface DelegationRequest {
+    /** Target agent ID (from AgentManifest.id) */
+    targetAgentId: string;
+    /** Skill/tool name to invoke on the target agent */
+    skillId: string;
+    /** Arguments to pass to the skill */
+    arguments: Record<string, unknown>;
+    /** Timeout in ms (default 30_000) */
+    timeout?: number;
+    /** Number of retries on failure (default 0) */
+    retries?: number;
+    /** Callback URL for async results (reserved for future use) */
+    callbackUrl?: string;
+}
+interface DelegationResult {
+    /** Unique task ID for tracking */
+    taskId: string;
+    /** Final delegation status */
+    status: 'completed' | 'failed' | 'timeout' | 'rejected';
+    /** Result data on success */
+    result?: unknown;
+    /** Error message on failure */
+    error?: string;
+    /** Total execution time in ms */
+    durationMs: number;
+    /** Info about the delegated agent */
+    delegatedTo: {
+        agentId: string;
+        endpoint: string;
+    };
+}
+interface TaskDelegationConfig {
+    /** Default timeout for delegations in ms (default 30_000) */
+    defaultTimeout: number;
+    /** Maximum delegation history entries (default 1000, LRU eviction) */
+    maxHistory: number;
+    /** Custom fetch function (for testing) */
+    fetchFn?: (url: string, init?: RequestInit) => Promise<Response>;
+    /** Local tool executor for in-process agents */
+    localExecutor?: (skillId: string, args: Record<string, unknown>) => Promise<unknown>;
+    /** Optional observability hook for per-task delegation trace events */
+    traceHook?: (event: DelegationTraceEvent) => void;
+    /** Optional transport adapter for remote A2A calls */
+    transportAdapter?: A2ATransportAdapter;
+    /** Optional idempotency key factory for remote A2A calls */
+    idempotencyKeyFactory?: (ctx: {
+        taskId: string;
+        attempt: number;
+        endpointUrl: string;
+        skillId: string;
+    }) => string;
+}
+interface A2ATransportAdapter {
+    send(input: {
+        endpointUrl: string;
+        requestBody: Record<string, unknown>;
+        idempotencyKey: string;
+        fetchFn: (url: string, init?: RequestInit) => Promise<Response>;
+    }): Promise<unknown>;
+}
+type DelegationTracePhase = 'start' | 'attempt' | 'retry' | 'success' | 'failure' | 'timeout' | 'rejected' | 'replay_requested' | 'replay_completed' | 'replay_failed';
+interface DelegationTraceEvent {
+    taskId: string;
+    phase: DelegationTracePhase;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+}
+declare class TaskDelegationService {
+    private registry;
+    private adapter?;
+    private config;
+    private history;
+    private traceHistory;
+    private requestHistory;
+    constructor(registry: AgentRegistry, adapter?: FederatedRegistryAdapter, config?: Partial<TaskDelegationConfig>);
+    /**
+     * Delegate a task to a specific agent by ID.
+     */
+    delegateTo(request: DelegationRequest): Promise<DelegationResult>;
+    /**
+     * Auto-delegate: find the best agent for a capability then delegate.
+     */
+    autoDelegate(query: CapabilityQuery, skillId: string, args: Record<string, unknown>, options?: {
+        timeout?: number;
+        retries?: number;
+    }): Promise<DelegationResult>;
+    /**
+     * Get the status of a previously delegated task from history.
+     */
+    getStatus(taskId: string): DelegationResult | undefined;
+    /**
+     * Get the full delegation history.
+     */
+    getDelegationHistory(): DelegationResult[];
+    /**
+     * Get observability trace events for delegations (optionally filtered by taskId).
+     */
+    getTraceHistory(taskId?: string): DelegationTraceEvent[];
+    /**
+     * Replay a previously delegated task using its original request payload.
+     */
+    replay(taskId: string, overrides?: Partial<DelegationRequest>): Promise<DelegationResult>;
+    /**
+     * Get delegation stats.
+     */
+    getStats(): {
+        total: number;
+        completed: number;
+        failed: number;
+        timeout: number;
+        rejected: number;
+    };
+    /**
+     * Execute a skill on an agent (local or remote).
+     */
+    private executeOnAgent;
+    /**
+     * Execute via remote A2A JSON-RPC.
+     */
+    private executeRemote;
+    /**
+     * Execute a function with a timeout.
+     */
+    private executeWithTimeout;
+    /**
+     * Get the primary endpoint from a manifest.
+     */
+    private getPrimaryEndpoint;
+    /**
+     * Add a result to history with LRU eviction.
+     */
+    private addToHistory;
+    /**
+     * Emit and store delegation observability traces.
+     */
+    private emitTrace;
+    /**
+     * Sleep utility.
+     */
+    private sleep;
+}
+
+/**
+ * @holoscript/core - Skill Workflow Engine
+ *
+ * DAG-based skill composition and chaining. Validates workflow definitions,
+ * resolves inter-step data dependencies, and executes steps in parallel groups.
+ * Uses topological sort pattern from MicroPhaseDecomposer.
+ *
+ * Part of HoloScript v5.5 "Agents as Universal Orchestrators".
+ */
+/**
+ * Input can be a literal value, a reference to another step's output, or context.
+ */
+type WorkflowInput = {
+    type: 'literal';
+    value: unknown;
+} | {
+    type: 'ref';
+    stepId: string;
+    outputKey: string;
+} | {
+    type: 'context';
+    key: string;
+};
+/**
+ * A single step in a workflow.
+ */
+interface WorkflowStep {
+    /** Unique step identifier */
+    id: string;
+    /** Skill/tool to invoke */
+    skillId: string;
+    /** Input mapping: param name → source */
+    inputs: Record<string, WorkflowInput>;
+    /** Step IDs that must complete first */
+    dependsOn?: string[];
+    /** Per-step timeout in ms */
+    timeout?: number;
+    /** Error handling strategy */
+    onError?: 'fail' | 'skip' | 'fallback';
+    /** Fallback skill if primary fails and onError='fallback' */
+    fallbackSkillId?: string;
+}
+/**
+ * Complete workflow definition.
+ */
+interface WorkflowDefinition {
+    /** Workflow identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Ordered steps (topologically sorted at validation) */
+    steps: WorkflowStep[];
+    /** Initial context data */
+    context?: Record<string, unknown>;
+}
+/**
+ * Validation result for a workflow definition.
+ */
+interface WorkflowValidation {
+    /** Whether the workflow is valid */
+    valid: boolean;
+    /** Validation errors */
+    errors: string[];
+    /** Validation warnings */
+    warnings: string[];
+    /** Execution plan: groups of step IDs that can run in parallel */
+    executionPlan: {
+        groups: string[][];
+        estimatedSteps: number;
+    };
+}
+/**
+ * Result of a single step execution.
+ */
+interface WorkflowStepResult {
+    stepId: string;
+    status: 'completed' | 'failed' | 'skipped';
+    output: Record<string, unknown>;
+    durationMs: number;
+    error?: string;
+}
+/**
+ * Result of a full workflow execution.
+ */
+interface WorkflowResult {
+    workflowId: string;
+    status: 'completed' | 'partial' | 'failed';
+    stepResults: WorkflowStepResult[];
+    totalDurationMs: number;
+}
+/**
+ * Executor function type: takes a skill ID and inputs, returns outputs.
+ */
+type SkillExecutor = (skillId: string, inputs: Record<string, unknown>) => Promise<Record<string, unknown>>;
+/**
+ * Progress callback type.
+ */
+type ProgressCallback = (stepId: string, status: string) => void;
+declare class SkillWorkflowEngine {
+    /**
+     * Validate a workflow definition.
+     */
+    validate(definition: WorkflowDefinition, availableSkills?: string[]): WorkflowValidation;
+    /**
+     * Execute a workflow using the provided executor function.
+     */
+    execute(definition: WorkflowDefinition, executor: SkillExecutor, onProgress?: ProgressCallback): Promise<WorkflowResult>;
+    /**
+     * Execute a single step with optional fallback.
+     */
+    private executeStep;
+    /**
+     * Resolve step inputs from literal values, step outputs, or context.
+     */
+    private resolveInputs;
+    /**
+     * Detect cycles in the step dependency graph.
+     * Returns a cycle description string, or null if no cycles.
+     */
+    private detectCycles;
+    /**
+     * Build parallel execution groups via topological sort.
+     * Each group contains steps that can run concurrently.
+     */
+    private buildExecutionGroups;
+    /**
+     * Get all dependencies for a step (explicit + implicit from ref inputs).
+     */
+    private getAllDependencies;
+}
+
+/**
+ * @holoscript/framework - Orchestrator Agent
+ *
+ * First concrete implementation of BaseAgent from the uAA2++ protocol.
+ * Maps the 7-phase protocol to agent orchestration concerns:
+ *   INTAKE → discover available agents
+ *   REFLECT → match capabilities to task requirements
+ *   EXECUTE → delegate tasks or run workflows
+ *   COMPRESS → summarize execution results
+ *   REINTAKE → check delegation results, update agent status
+ *   GROW → record delegation patterns (what worked/failed)
+ *   EVOLVE → optimize routing preferences
+ *
+ * Part of HoloScript v5.5 "Agents as Universal Orchestrators".
+ */
+
+interface OrchestratorConfig {
+    /** Agent name */
+    name: string;
+    /** Primary domain */
+    domain: string;
+    /** Seed URLs for federated discovery */
+    seedUrls?: string[];
+    /** Whether to auto-discover on intake (default true) */
+    autoDiscovery?: boolean;
+    /** Discovery poll interval in ms */
+    discoveryIntervalMs?: number;
+    /** Custom fetch function (for testing) */
+    fetchFn?: FederatedRegistryConfig['fetchFn'];
+    /** Local tool executor (for testing/integration) */
+    localExecutor?: (skillId: string, args: Record<string, unknown>) => Promise<unknown>;
+}
+interface DelegationPattern {
+    agentId: string;
+    skillId: string;
+    successCount: number;
+    failureCount: number;
+    avgDurationMs: number;
+    lastUsed: number;
+}
+declare class OrchestratorAgent extends BaseAgent {
+    readonly identity: AgentIdentity;
+    private registry;
+    private adapter;
+    private delegator;
+    private workflowEngine;
+    private config;
+    /** Learned delegation patterns (GROW phase) */
+    private patterns;
+    /** Routing preferences (EVOLVE phase) */
+    private preferences;
+    /** Last discovered agents */
+    private lastDiscovery;
+    constructor(config: OrchestratorConfig);
+    intake(input: unknown): Promise<PhaseResult>;
+    reflect(data: unknown): Promise<PhaseResult>;
+    execute(plan: unknown): Promise<PhaseResult>;
+    compress(results: unknown): Promise<PhaseResult>;
+    reintake(compressed: unknown): Promise<PhaseResult>;
+    grow(learnings: unknown): Promise<PhaseResult>;
+    evolve(adaptations: unknown): Promise<PhaseResult>;
+    /**
+     * Delegate a task without running a full cycle.
+     */
+    delegateTask(skillId: string, args: Record<string, unknown>): Promise<DelegationResult>;
+    /**
+     * Run a workflow without running a full cycle.
+     */
+    runWorkflow(definition: WorkflowDefinition): Promise<WorkflowResult>;
+    /**
+     * Get all discovered agents.
+     */
+    getDiscoveredAgents(): AgentManifest[];
+    /**
+     * Get learned patterns.
+     */
+    getPatterns(): DelegationPattern[];
+    /**
+     * Stop polling and cleanup.
+     */
+    shutdown(): void;
+    private taskToQuery;
+    private getPreferredAgents;
+}
+
+export { type A2AAgentCard as A, resetDefaultRegistry as B, type CapabilityMatch as C, DEFAULT_REGISTRY_CONFIG as D, FederatedRegistryAdapter as F, OrchestratorAgent as O, type ProgressCallback as P, type RegistryConfig as R, type SkillExecutor as S, type TaskDelegationConfig as T, type WorkflowDefinition as W, type A2ASkill as a, type A2ATransportAdapter as b, type AgentMatch as c, AgentRegistry as d, CapabilityMatcher as e, type CapabilityQuery as f, type DelegationRequest as g, type DelegationResult as h, type DelegationTraceEvent as i, type DelegationTracePhase as j, type DiscoveryMode as k, type FederatedRegistryConfig as l, type OrchestratorConfig as m, type RegistryEvents as n, SkillWorkflowEngine as o, type SpatialQuery as p, TaskDelegationService as q, type WorkflowInput as r, type WorkflowResult as s, type WorkflowStep as t, type WorkflowStepResult as u, type WorkflowValidation as v, defaultMatcher as w, findAgents as x, findBestAgent as y, getDefaultRegistry as z };