import { z } from 'zod';
import type { RegistryApiClient } from '../client/api.js';
export const lookupInputSchema = z.object({
agentId: z.string().uuid().optional().describe('UUID of the agent to lookup'),
domain: z.string().optional().describe('Domain/origin of the agent to lookup'),
query: z.string().optional().describe('Search query to discover agents'),
capabilities: z.array(z.string()).optional().describe('Filter by capabilities'),
}).refine(
(data) => data.agentId || data.domain || data.query,
{ message: 'Must provide agentId, domain, or query' }
);
export type LookupInput = z.infer<typeof lookupInputSchema>;
export interface LookupResult {
found: boolean;
agent?: {
id: string;
name: string;
description: string | null;
visibility: string;
status: string;
domain: string | null;
capabilities: string[] | null;
keys: Array<{
id: string;
publicKey: string;
status: string;
label: string | null;
}>;
};
agents?: Array<{
id: string;
name: string;
description: string | null;
domain: string | null;
capabilities: string[] | null;
}>;
total?: number;
hasMore?: boolean;
error?: string;
}
/**
* Look up an agent by ID, domain, or search query.
*
* - By ID: Returns the specific agent with that UUID
* - By domain: Returns the agent registered for that domain
* - By query: Searches public agents and returns matches
*/
export async function lookup(
input: LookupInput,
client: RegistryApiClient
): Promise<LookupResult> {
try {
// Lookup by ID
if (input.agentId) {
const agent = await client.lookupById(input.agentId);
return {
found: true,
agent: {
id: agent.id,
name: agent.name,
description: agent.description,
visibility: agent.visibility,
status: agent.status,
domain: agent.domain,
capabilities: agent.capabilities,
keys: agent.keys.map((k) => ({
id: k.id,
publicKey: k.public_key,
status: k.status,
label: k.label,
})),
},
};
}
// Lookup by domain
if (input.domain) {
const agent = await client.lookupByDomain(input.domain);
return {
found: true,
agent: {
id: agent.id,
name: agent.name,
description: agent.description,
visibility: agent.visibility,
status: agent.status,
domain: agent.domain,
capabilities: agent.capabilities,
keys: agent.keys.map((k) => ({
id: k.id,
publicKey: k.public_key,
status: k.status,
label: k.label,
})),
},
};
}
// Discovery search
if (input.query || input.capabilities) {
const result = await client.discover({
query: input.query,
capabilities: input.capabilities,
});
return {
found: result.data.length > 0,
agents: result.data.map((a) => ({
id: a.id,
name: a.name,
description: a.description,
domain: a.domain,
capabilities: a.capabilities,
})),
total: result.total,
hasMore: result.hasMore,
};
}
return {
found: false,
error: 'No search criteria provided',
};
} catch (error) {
return {
found: false,
error: error instanceof Error ? error.message : 'Unknown error',
};
}
}
export const lookupTool = {
name: 'agents_registry_lookup',
description: 'Look up an agent by ID, domain, or search for agents by name/capabilities',
inputSchema: {
type: 'object' as const,
properties: {
agentId: {
type: 'string',
description: 'UUID of the agent to lookup',
},
domain: {
type: 'string',
description: 'Domain/origin of the agent to lookup',
},
query: {
type: 'string',
description: 'Search query to discover agents by name or description',
},
capabilities: {
type: 'array',
items: { type: 'string' },
description: 'Filter results by required capabilities',
},
},
required: [] as string[],
},
};
