@nordsym/apiclaw 1.0.0 → 1.1.0

package/src/index.ts

@@ -18,14 +18,17 @@ import {
   Tool,
 } from '@modelcontextprotocol/sdk/types.js';
 
-import { discoverAPIs, getAPIDetails, getCategories, getAllAPIs, getAPICount } from './discovery.js';
+import { discoverAPIs, getAPIDetails, getCategories, getAllAPIs } from './discovery.js';
 import { 
   getAgentCredits, 
   addCredits, 
   purchaseAPIAccess, 
   getBalanceSummary,
-  getAgentPurchases 
+  getAgentPurchases,
+  getProvidersWithRealCredentials 
 } from './credits.js';
+import { hasRealCredentials } from './credentials.js';
+import { executeAPICall, getConnectedProviders } from './execute.js';
 
 // Default agent ID for MVP (in production, this would come from auth)
 const DEFAULT_AGENT_ID = 'agent_default';
@@ -34,22 +37,27 @@ const DEFAULT_AGENT_ID = 'agent_default';
 const tools: Tool[] = [
   {
     name: 'discover_apis',
-    description: 'Search 1400+ APIs based on what you need to do. Describe your use case naturally.',
+    description: 'Search for APIs based on what you need to do. Describe your use case naturally.',
     inputSchema: {
       type: 'object',
       properties: {
         query: {
           type: 'string',
-          description: 'Natural language query describing what you need (e.g., "send SMS", "weather data", "payment processing", "text to speech")'
+          description: 'Natural language query describing what you need (e.g., "send SMS to Sweden", "search the web", "generate speech from text")'
         },
         category: {
           type: 'string',
-          description: 'Filter by category (use list_categories to see all)'
+          description: 'Filter by category: communication, search, ai',
+          enum: ['communication', 'search', 'ai']
         },
         max_results: {
           type: 'number',
-          description: 'Maximum number of results to return (default: 10)',
-          default: 10
+          description: 'Maximum number of results to return (default: 5)',
+          default: 5
+        },
+        region: {
+          type: 'string',
+          description: 'Filter by region (e.g., "SE", "EU", "global")'
         }
       },
       required: ['query']
@@ -129,6 +137,36 @@ const tools: Tool[] = [
       type: 'object',
       properties: {}
     }
+  },
+  {
+    name: 'call_api',
+    description: 'Execute an API call through APIClaw Instant Connect. No API keys needed - we handle authentication.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        provider: {
+          type: 'string',
+          description: 'Provider ID (e.g., "46elks", "brave_search", "resend", "openrouter", "elevenlabs", "twilio")'
+        },
+        action: {
+          type: 'string',
+          description: 'Action to perform (e.g., "send_sms", "search", "send_email", "chat", "text_to_speech")'
+        },
+        params: {
+          type: 'object',
+          description: 'Parameters for the action. Varies by provider/action.'
+        }
+      },
+      required: ['provider', 'action', 'params']
+    }
+  },
+  {
+    name: 'list_connected',
+    description: 'List all APIs available for Instant Connect (no API key needed).',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
   }
 ];
 
@@ -159,9 +197,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'discover_apis': {
         const query = args?.query as string;
         const category = args?.category as string | undefined;
-        const maxResults = (args?.max_results as number) || 10;
+        const maxResults = (args?.max_results as number) || 5;
+        const region = args?.region as string | undefined;
 
-        const results = discoverAPIs(query, { category, maxResults });
+        const results = discoverAPIs(query, { category, maxResults, region });
 
         if (results.length === 0) {
           return {
@@ -171,8 +210,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 text: JSON.stringify({
                   status: 'no_results',
                   message: `No APIs found matching "${query}". Try broader terms or check available categories with list_categories.`,
-                  total_apis: getAPICount(),
-                  available_categories: getCategories().slice(0, 20)
+                  available_categories: getCategories()
                 }, null, 2)
               }
             ]
@@ -187,17 +225,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 status: 'success',
                 query,
                 results_count: results.length,
-                total_apis: getAPICount(),
                 results: results.map(r => ({
-                  id: r.api.id,
-                  name: r.api.name,
-                  description: r.api.description,
-                  category: r.api.category,
-                  auth: r.api.auth,
-                  https: r.api.https,
-                  link: r.api.link,
-                  pricing: r.api.pricing,
-                  keywords: r.api.keywords,
+                  id: r.provider.id,
+                  name: r.provider.name,
+                  description: r.provider.description,
+                  category: r.provider.category,
+                  capabilities: r.provider.capabilities,
+                  pricing_model: r.provider.pricing.model,
+                  has_free_tier: r.provider.pricing.free_tier,
+                  agent_success_rate: r.provider.agent_success_rate,
                   relevance_score: r.relevance_score,
                   match_reasons: r.match_reasons
                 }))
@@ -274,12 +310,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                   provider: apiId,
                   amount_paid_usd: amountUsd,
                   credits_received: result.purchase!.credits_purchased,
-                  status: result.purchase!.status
+                  status: result.purchase!.status,
+                  real_credentials: hasRealCredentials(apiId)
                 },
                 credentials: result.purchase!.credentials,
                 access: {
-                  link: api?.link,
-                  auth: api?.auth
+                  base_url: api?.base_url,
+                  docs_url: api?.docs_url,
+                  auth_type: api?.auth_type
                 }
               }, null, 2)
             }
@@ -301,11 +339,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 balance_usd: summary.credits.balance_usd,
                 currency: summary.credits.currency,
                 total_spent_usd: summary.total_spent_usd,
+                real_credential_providers: summary.real_credentials_available,
                 active_purchases: summary.active_purchases.map(p => ({
                   id: p.id,
                   provider: p.provider_id,
-                  credits_remaining: p.credits_purchased, // Would track actual usage in production
-                  status: p.status
+                  credits_remaining: p.credits_purchased,
+                  status: p.status,
+                  real_credentials: hasRealCredentials(p.provider_id)
                 }))
               }, null, 2)
             }
@@ -335,10 +375,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'list_categories': {
         const categories = getCategories();
-        const categoryCounts: Record<string, number> = {};
+        const apisByCategory: Record<string, string[]> = {};
         
         for (const cat of categories) {
-          categoryCounts[cat] = getAllAPIs().filter(a => a.category === cat).length;
+          apisByCategory[cat] = getAllAPIs()
+            .filter(a => a.category === cat)
+            .map(a => a.id);
         }
 
         return {
@@ -347,9 +389,49 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               type: 'text',
               text: JSON.stringify({
                 status: 'success',
-                total_apis: getAPICount(),
-                category_count: categories.length,
-                categories: categoryCounts
+                categories: apisByCategory
+              }, null, 2)
+            }
+          ]
+        };
+      }
+
+      case 'call_api': {
+        const provider = args?.provider as string;
+        const action = args?.action as string;
+        const params = (args?.params as Record<string, any>) || {};
+
+        const result = await executeAPICall(provider, action, params);
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                status: result.success ? 'success' : 'error',
+                provider: result.provider,
+                action: result.action,
+                ...(result.success ? { data: result.data } : { error: result.error }),
+                ...(result.cost !== undefined ? { cost_sek: result.cost } : {})
+              }, null, 2)
+            }
+          ],
+          isError: !result.success
+        };
+      }
+
+      case 'list_connected': {
+        const connected = getConnectedProviders();
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                status: 'success',
+                message: 'These APIs are available for Instant Connect - no API key needed!',
+                connected_providers: connected,
+                usage: 'Use call_api with provider, action, and params to execute calls.'
               }, null, 2)
             }
           ]

package/src/proxy.ts

@@ -0,0 +1,24 @@
+/**
+ * APIClaw Proxy - Fallback to hosted API when no local credentials
+ */
+
+const PROXY_BASE = "https://adventurous-avocet-799.convex.site/proxy";
+
+export async function callProxy(provider: string, params: any): Promise<any> {
+  const url = `${PROXY_BASE}/${provider}`;
+  
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(params),
+  });
+
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({ error: "Proxy request failed" })) as { error?: string };
+    throw new Error(errorData.error || `Proxy error: ${response.status}`);
+  }
+
+  return response.json();
+}
+
+export const PROXY_PROVIDERS = ["openrouter", "brave_search", "resend", "elevenlabs"];