@tenex-chat/backend 0.9.1

package/src/tools/implementations/agents_discover.ts

@@ -0,0 +1,121 @@
+import type { ToolExecutionContext } from "@/tools/types";
+import { getNDK } from "@/nostr";
+import { NDKAgentDiscovery } from "@/services/agents";
+import type { AISdkTool } from "@/tools/types";
+import { logger } from "@/utils/logger";
+import { tool } from "ai";
+import { z } from "zod";
+const agentsDiscoverSchema = z.object({
+    searchText: z.string().nullable().describe("Text to search for in agent name/description/role"),
+    limit: z.coerce.number().default(50).describe("Maximum number of agents to return"),
+});
+
+type AgentsDiscoverInput = z.infer<typeof agentsDiscoverSchema>;
+type AgentsDiscoverOutput = {
+    markdown: string;
+    agentsFound: number;
+};
+
+/**
+ * Format discovered agents as markdown
+ */
+function formatAgentsAsMarkdown(
+    agents: Array<{
+        id: string;
+        title: string;
+        role: string;
+        description?: string;
+        useCriteria?: string;
+        authorPubkey: string;
+        createdAt?: number;
+    }>
+): string {
+    if (agents.length === 0) {
+        return "## No agents found\n\nNo agents match your search criteria. Try broadening your search or check back later.";
+    }
+
+    const lines: string[] = [];
+    lines.push("# Agent Discovery Results");
+    lines.push(`\nFound **${agents.length}** available agent${agents.length === 1 ? "" : "s"}:\n`);
+
+    for (const [index, agent] of agents.entries()) {
+        lines.push(`## ${index + 1}. ${agent.title}`);
+        lines.push(`nostr:${agent.id}`);
+        lines.push("");
+
+        lines.push("---");
+        lines.push("");
+    }
+
+    return lines.join("\n");
+}
+
+/**
+ * Core implementation of the agents_discover functionality
+ * Shared between AI SDK and legacy Tool interfaces
+ */
+async function executeAgentsDiscover(input: AgentsDiscoverInput): Promise<AgentsDiscoverOutput> {
+    const { searchText, limit = 50 } = input;
+
+    const ndk = getNDK();
+    const discovery = new NDKAgentDiscovery(ndk);
+
+    // Discover agents with specified filters
+    const agents = await discovery.discoverAgents({
+        searchText: searchText ?? undefined,
+    });
+
+    // Format results with bech32 encoded IDs
+    let results = agents.map((agent) => {
+        // Get bech32 encoded ID from the NDKAgentDefinition event
+        const bech32Id = agent.encode();
+
+        return {
+            id: bech32Id,
+            title: agent.title || "Unnamed Agent",
+            role: agent.role || "assistant",
+            description: agent.description,
+            useCriteria: agent.useCriteria,
+            authorPubkey: agent.pubkey,
+            createdAt: agent.created_at,
+        };
+    });
+
+    // Apply limit if specified
+    if (limit && results.length > limit) {
+        results = results.slice(0, limit);
+    }
+
+    logger.info(`Returning ${results.length} AgentDefinition events after limiting`);
+
+    // Format as markdown
+    const markdown = formatAgentsAsMarkdown(results);
+
+    return {
+        markdown,
+        agentsFound: results.length,
+    };
+}
+
+/**
+ * Create an AI SDK tool for discovering agents
+ * This is the primary implementation
+ */
+export function createAgentsDiscoverTool(_context: ToolExecutionContext): AISdkTool {
+    return tool({
+        description:
+            "Discover agent definition events; these are agent definitions that can be useful to be installed in the project. Use this when trying to discover NEW possible agents to add to the project NOT to see the list of current agents in the project.",
+        inputSchema: agentsDiscoverSchema,
+        execute: async (input: AgentsDiscoverInput) => {
+            try {
+                return await executeAgentsDiscover(input);
+            } catch (error) {
+                logger.error("Failed to discover agents", { error });
+                throw new Error(
+                    `Failed to discover agents: ${error instanceof Error ? error.message : String(error)}`,
+                    { cause: error }
+                );
+            }
+        },
+    }) as AISdkTool;
+}

package/src/tools/implementations/agents_hire.ts

@@ -0,0 +1,127 @@
+import type { AISdkTool, ToolExecutionContext } from "@/tools/types";
+import { loadAgentIntoRegistry } from "@/agents/agent-loader";
+import { getNDK } from "@/nostr";
+import { getProjectContext } from "@/services/projects";
+import { logger } from "@/utils/logger";
+import { normalizeNostrIdentifier } from "@/utils/nostr-entity-parser";
+import { filterAndRelaySetFromBech32 } from "@nostr-dev-kit/ndk";
+import { tool } from "ai";
+import { z } from "zod";
+const agentsHireSchema = z.object({
+    eventId: z.string().describe("The event ID of the Agent Definition Event to hire"),
+    slug: z
+        .string()
+        .nullable()
+        .describe("Optional custom slug for the agent (defaults to normalized name)"),
+});
+
+type AgentsHireInput = z.infer<typeof agentsHireSchema>;
+type AgentsHireOutput = {
+    success: boolean;
+    message?: string;
+    error?: string;
+    agent?: {
+        slug: string;
+        name: string;
+        role?: string;
+        pubkey: string;
+        eventId?: string;
+    };
+};
+
+/**
+ * Core implementation of the agents_hire functionality
+ * Shared between AI SDK and legacy Tool interfaces
+ */
+async function executeAgentsHire(
+    input: AgentsHireInput,
+    _context: ToolExecutionContext
+): Promise<AgentsHireOutput> {
+    const { eventId: rawEventId, slug } = input;
+
+    if (!rawEventId) {
+        return {
+            success: false,
+            error: "Event ID is required to hire an agent",
+        };
+    }
+
+    // Normalize the event ID using our utility
+    const eventId = normalizeNostrIdentifier(rawEventId);
+    if (!eventId) {
+        return {
+            success: false,
+            error: `Invalid event ID format: "${rawEventId}". Please provide a valid Nostr event ID in bech32 format (e.g., nevent1...) or hex format.`,
+        };
+    }
+
+    // Get NDK instance for validation and fetching
+    const ndk = getNDK();
+
+    // Additional validation for bech32 format
+    if (eventId.startsWith("nevent1") || eventId.startsWith("note1")) {
+        try {
+            filterAndRelaySetFromBech32(eventId, ndk);
+        } catch {
+            return {
+                success: false,
+                error: `Invalid event ID format: "${eventId}". Please provide a valid Nostr event ID.`,
+            };
+        }
+    }
+
+    // Get project context
+    const projectContext = getProjectContext();
+
+    // Load the agent into the registry (handles storage, Nostr fetch, project association)
+    const agent = await loadAgentIntoRegistry(
+        eventId,
+        projectContext.agentRegistry,
+        slug || undefined
+    );
+
+    // Note: We don't update the project event here because:
+    // 1. The project event is signed by the user, not the agents
+    // 2. The backend doesn't have the user's private key
+    // 3. The agent is already installed in ~/.tenex/agents/<pubkey>.json
+    // 4. The user can update their project event from the client if needed
+
+    logger.info(`Successfully hired agent "${agent.name}" (${agent.eventId})`);
+    logger.info(`  Slug: ${agent.slug}`);
+    logger.info(`  Pubkey: ${agent.pubkey}`);
+
+    return {
+        success: true,
+        message: `Successfully hired agent "${agent.name}"`,
+        agent: {
+            slug: agent.slug,
+            name: agent.name,
+            role: agent.role,
+            pubkey: agent.pubkey,
+            eventId: agent.eventId,
+        },
+    };
+}
+
+/**
+ * Create an AI SDK tool for hiring agents
+ * This is the primary implementation
+ */
+export function createAgentsHireTool(context: ToolExecutionContext): AISdkTool {
+    return tool({
+        description:
+            "Hire (add) a new agent from the Nostr network to the current project using its event ID",
+        inputSchema: agentsHireSchema,
+        execute: async (input: AgentsHireInput) => {
+            try {
+                return await executeAgentsHire(input, context);
+            } catch (error) {
+                logger.error("Failed to hire agent", { error });
+                throw new Error(
+                    `Failed to hire agent: ${error instanceof Error ? error.message : String(error)}`,
+                    { cause: error }
+                );
+            }
+        },
+    }) as AISdkTool;
+}

package/src/tools/implementations/agents_list.ts

@@ -0,0 +1,96 @@
+import type { ToolExecutionContext } from "@/tools/types";
+import { getProjectContext } from "@/services/projects";
+import type { AISdkTool } from "@/tools/types";
+import { logger } from "@/utils/logger";
+import { tool } from "ai";
+import { z } from "zod";
+const agentsListSchema = z.object({
+    verbose: z
+        .boolean()
+        .nullable()
+        .describe("Whether to include full instructions and details (default: false)"),
+});
+
+type AgentsListInput = z.infer<typeof agentsListSchema>;
+
+type AgentInfo = {
+    slug: string;
+    name: string;
+    role: string;
+    description?: string;
+    instructions?: string;
+    useCriteria?: string;
+    tools?: string[];
+    eventId?: string;
+    pubkey: string;
+};
+
+type AgentsListOutput = {
+    success: boolean;
+    message?: string;
+    error?: string;
+    agents: AgentInfo[];
+    summary?: {
+        total: number;
+    };
+};
+
+/**
+ * Core implementation of the agents_list functionality
+ */
+async function executeAgentsList(input: AgentsListInput): Promise<AgentsListOutput> {
+    const { verbose = false } = input;
+
+    // Get agents from project context
+    const projectCtx = getProjectContext();
+    const agentInstances = projectCtx.agentRegistry.getAllAgents();
+
+    const agents: AgentInfo[] = agentInstances.map((agent) => ({
+        slug: agent.slug,
+        name: agent.name,
+        role: agent.role,
+        description: agent.description,
+        instructions: verbose ? agent.instructions : undefined,
+        useCriteria: agent.useCriteria,
+        tools: agent.tools,
+        eventId: agent.eventId,
+        pubkey: agent.pubkey,
+    }));
+
+    // Sort agents by name
+    agents.sort((a, b) => a.name.localeCompare(b.name));
+
+    logger.info(`Listed ${agents.length} agents`);
+
+    return {
+        success: true,
+        message: `Found ${agents.length} agents`,
+        agents,
+        summary: {
+            total: agents.length,
+        },
+    };
+}
+
+/**
+ * Create an AI SDK tool for listing agents
+ * This is the primary implementation
+ */
+export function createAgentsListTool(_context: ToolExecutionContext): AISdkTool {
+    return tool({
+        description:
+            "List all available agents in the project, including their system prompts and configurations",
+        inputSchema: agentsListSchema,
+        execute: async (input: AgentsListInput) => {
+            try {
+                return await executeAgentsList(input);
+            } catch (error) {
+                logger.error("Failed to list agents", { error });
+                throw new Error(
+                    `Failed to list agents: ${error instanceof Error ? error.message : String(error)}`,
+                    { cause: error }
+                );
+            }
+        },
+    }) as AISdkTool;
+}