Give Your Agent Access to Every Tool

import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
import { registrySearchTool } from '@tpmjs/registry-search';
import { registryExecuteTool } from '@tpmjs/registry-execute';

const result = streamText({
  model: openai('gpt-4.1-mini'),
  tools: {
    // Your existing tools
    weather: weatherTool,
    database: databaseTool,

    // TPMJS registry access
    registrySearch: registrySearchTool,
    registryExecute: registryExecuteTool,
  },
  system: `You have access to thousands of tools via the TPMJS registry.
Use registrySearch to find tools, then registryExecute to run them.`,
  prompt: 'Search for web scraping tools and scrape https://example.com',
});

{
  "query": "web scraping",
  "matchCount": 3,
  "tools": [
    {
      "toolId": "@firecrawl/ai-sdk::scrapeTool",
      "name": "scrapeTool",
      "package": "@firecrawl/ai-sdk",
      "description": "Scrape any website into clean markdown",
      "category": "web-scraping",
      "requiredEnvVars": ["FIRECRAWL_API_KEY"],
      "healthStatus": "HEALTHY",
      "qualityScore": 0.9
    }
  ]
}

// Execute a web search tool
const result = await registryExecuteTool.execute({
  toolId: '@exalabs/ai-sdk::webSearch',
  params: { query: 'latest AI news' },
  env: { EXA_API_KEY: 'your-api-key' },
});

// Result:
// {
//   toolId: '@exalabs/ai-sdk::webSearch',
//   executionTimeMs: 1234,
//   output: { results: [...] }
// }

{
  "toolId": "@exalabs/ai-sdk::webSearch",
  "executionTimeMs": 1234,
  "output": { ... }
}

import { tool } from 'ai';
import { registryExecuteTool } from '@tpmjs/registry-execute';

// Pre-configure your API keys
const API_KEYS: Record<string, string> = {
  FIRECRAWL_API_KEY: process.env.FIRECRAWL_API_KEY!,
  EXA_API_KEY: process.env.EXA_API_KEY!,
};

// Create a wrapped version that auto-injects keys
export const registryExecute = tool({
  description: registryExecuteTool.description,
  parameters: registryExecuteTool.parameters,
  execute: async ({ toolId, params }) => {
    return registryExecuteTool.execute({ toolId, params, env: API_KEYS });
  },
});

import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
import { registrySearchTool } from '@tpmjs/registry-search';
import { registryExecute } from './tools';  // Your wrapped version

const result = streamText({
  model: openai('gpt-4.1-mini'),
  tools: {
    registrySearch: registrySearchTool,
    registryExecute,  // Keys are auto-injected
  },
  system: `You have access to the TPMJS tool registry.
Use registrySearch to find tools, then registryExecute to run them.`,
  prompt: 'Scrape https://example.com and summarize the content',
});

https://tpmjs.com/api/mcp/{username}/{collection-slug}/http

curl "https://tpmjs.com/api/tools?category=web-scraping&limit=10"

curl "https://tpmjs.com/api/tools/search?q=scrape%20website%20to%20markdown"

{
  "success": true,
  "query": "scrape website to markdown",
  "results": {
    "total": 5,
    "tools": [
      {
        "id": "clx...",
        "name": "scrapeTool",
        "description": "Scrape any website into clean markdown",
        "package": {
          "npmPackageName": "@firecrawl/ai-sdk",
          "category": "web-scraping",
          "env": ["FIRECRAWL_API_KEY"]
        }
      }
    ]
  }
}

{
  "params": {
    "url": "https://example.com"
  },
  "env": {
    "FIRECRAWL_API_KEY": "your-api-key"
  }
}

curl -X POST "https://tpmjs.com/api/tools/execute/@firecrawl/ai-sdk/scrapeTool" \
  -H "Content-Type: application/json" \
  -d '{
    "params": { "url": "https://example.com" },
    "env": { "FIRECRAWL_API_KEY": "your-key" }
  }'

{
  "success": true,
  "result": {
    "markdown": "# Example Domain\n\nThis domain is for use...",
    "metadata": {
      "title": "Example Domain",
      "url": "https://example.com"
    }
  },
  "executionTimeMs": 1234
}

import { streamText, tool } from 'ai';
import { openai } from '@ai-sdk/openai';
import { registrySearchTool } from '@tpmjs/registry-search';
import { registryExecuteTool } from '@tpmjs/registry-execute';

// Pre-configure API keys for tool execution
const API_KEYS: Record<string, string> = {
  FIRECRAWL_API_KEY: process.env.FIRECRAWL_API_KEY!,
  EXA_API_KEY: process.env.EXA_API_KEY!,
  OPENAI_API_KEY: process.env.OPENAI_API_KEY!,
};

// Wrapped execute tool with pre-configured keys
const registryExecute = tool({
  description: registryExecuteTool.description,
  parameters: registryExecuteTool.parameters,
  execute: async ({ toolId, params }) => {
    return registryExecuteTool.execute({ toolId, params, env: API_KEYS });
  },
});

// System prompt for Omega-like behavior
const SYSTEM_PROMPT = `You are an AI assistant with access to thousands of tools via the TPMJS registry.

## Available Tools
- registrySearch: Search the registry to find tools for any task
- registryExecute: Execute any tool by its toolId

## Workflow
1. When given a task, first search for relevant tools
2. Review the results - each tool has: toolId, name, description, requiredEnvVars
3. Execute tools with appropriate parameters
4. Synthesize results into a helpful response

## Best Practices
- Search first when unsure what tools exist
- Execute tools to get real results (not just descriptions)
- Handle errors gracefully - suggest alternatives if a tool fails
- Be efficient - don't search repeatedly for the same thing`;

// Auto-discover tools based on user message
async function discoverTools(message: string) {
  const response = await fetch(
    `https://tpmjs.com/api/tools/search?q=${encodeURIComponent(message)}&limit=10`
  );
  const data = await response.json();
  return data.results?.tools || [];
}

// Main agent function
async function runAgent(userMessage: string) {
  // Step 1: Auto-discover relevant tools
  const discoveredTools = await discoverTools(userMessage);
  console.log(`Found ${discoveredTools.length} relevant tools`);

  // Step 2: Create dynamic tool context for the prompt
  const toolContext = discoveredTools.length > 0
    ? `\n\n## Pre-discovered Tools\nBased on your request, these tools may be helpful:\n${
        discoveredTools.map((t: { toolId: string; description: string }) =>
          `- ${t.toolId}: ${t.description}`
        ).join('\n')
      }`
    : '';

  // Step 3: Run the agent with tool access
  const result = await streamText({
    model: openai('gpt-4.1-mini'),
    tools: {
      registrySearch: registrySearchTool,
      registryExecute,
    },
    maxSteps: 10,
    system: SYSTEM_PROMPT + toolContext,
    prompt: userMessage,
  });

  // Step 4: Stream the response
  for await (const chunk of result.textStream) {
    process.stdout.write(chunk);
  }

  return result;
}

// Usage
await runAgent('Scrape https://example.com and summarize the content');

// API Route: POST /api/chat
export async function POST(request: Request) {
  const { message } = await request.json();

  const encoder = new TextEncoder();
  const stream = new ReadableStream({
    async start(controller) {
      // Emit tool discovery event
      const tools = await discoverTools(message);
      controller.enqueue(encoder.encode(
        `event: tools.discovered\ndata: ${JSON.stringify({ tools })}\n\n`
      ));

      // Run agent and stream events
      const result = await streamText({
        model: openai('gpt-4.1-mini'),
        tools: { registrySearch: registrySearchTool, registryExecute },
        maxSteps: 10,
        prompt: message,
        onStepFinish: ({ stepType, toolCalls, toolResults }) => {
          if (stepType === 'tool-result') {
            controller.enqueue(encoder.encode(
              `event: tool.completed\ndata: ${JSON.stringify({ toolCalls, toolResults })}\n\n`
            ));
          }
        },
      });

      // Stream text chunks
      for await (const chunk of result.textStream) {
        controller.enqueue(encoder.encode(
          `event: message.delta\ndata: ${JSON.stringify({ content: chunk })}\n\n`
        ));
      }

      controller.enqueue(encoder.encode(`event: done\ndata: {}\n\n`));
      controller.close();
    },
  });

  return new Response(stream, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      Connection: 'keep-alive',
    },
  });
}