Method refreshAgentSnapshots

server/src/crawler.ts:498–604

* Probe every known agent to refresh capability + health snapshots in the DB, * and fill in agent type for any that are still `unknown`. The registry * page reads these snapshot tables instead of calling agents live, so this * pass is the materialization step that keeps the public API fast.

(agents: Agent[])

   * CapabilityDiscovery; inferTypeFromProfile collapses them to one.
   */
  private async refreshAgentSnapshots(agents: Agent[]): Promise<void> {
    log.debug('Refreshing agent health + capability snapshots');

    const allAgents = await this.federatedIndex.listAllAgents();
    const knownTypes = new Map<string, string>();
    for (const a of allAgents) {
      if (a.type && a.type !== 'unknown') {
        knownTypes.set(a.url, a.type);
      }
    }

    // Build one probe entry per unique URL; prefer registered-agent metadata
    // (name/protocol) when we have it, else derive from URL.
    const pausedUrls = await this.getPausedAgentUrls();
    const seen = new Set<string>();
    const toProbe: Agent[] = [];
    for (const src of [...agents, ...allAgents.map(a => ({
      name: a.name || a.url,
      url: a.url,
      type: (a.type as Agent['type']) || 'unknown',
      protocol: (a.protocol as 'mcp' | 'a2a') || 'mcp',
      description: '',
      mcp_endpoint: a.url,
      contact: { name: '', email: '', website: '' },
      added_date: new Date().toISOString().split('T')[0],
    } satisfies Agent))]) {
      if (seen.has(src.url) || pausedUrls.has(src.url)) continue;
      seen.add(src.url);
      toProbe.push(src);
    }

    if (toProbe.length === 0) {
      log.debug('No agents to probe');
      return;
    }

    const CONCURRENCY = 5;
    const PROBE_TIMEOUT_MS = 10000;
    let typesUpdated = 0;
    let snapshotsWritten = 0;
    let failed = 0;

    for (let i = 0; i < toProbe.length; i += CONCURRENCY) {
      const batch = toProbe.slice(i, i + CONCURRENCY);
      const results = await Promise.allSettled(
        batch.map(async (agent) => {
          const profile = await Promise.race([
            this.capabilityDiscovery.discoverCapabilities(agent),
            new Promise<never>((_, reject) =>
              setTimeout(() => reject(new Error('Probe timeout')), PROBE_TIMEOUT_MS)
            ),
          ]);

          const inferredType = this.capabilityDiscovery.inferTypeFromProfile(profile);
          const effectiveType = knownTypes.get(agent.url) || inferredType;
          const agentForHealth: Agent = { ...agent, type: effectiveType as Agent['type'], protocol: profile.protocol };

          const [health, stats] = await Promise.all([