adaptive-memory-multi-model-router 2.15.3 → 2.15.4

package/integrations/browser-use/index.ts

@@ -1,145 +0,0 @@
-/**
- * A3M Router + browser-use Integration
- * 
- * Provides intelligent LLM routing for browser automation tasks.
- * - Routes to cheapest capable model automatically
- * - Stealth mode for anti-detection
- * - Parallel ensemble for reliable extraction
- */
-
-import { A3MRouter, BrowserConfig } from 'adaptive-memory-multi-model-router';
-
-export interface BrowserUseA3MConfig extends BrowserConfig {
-  /**
-   * Enable stealth mode to minimize bot detection
-   * @default false
-   */
-  stealth?: boolean;
-  
-  /**
-   * Number of providers to run in parallel for ensemble voting
-   * @default 1
-   */
-  parallelEnsemble?: number;
-  
-  /**
-   * Enable browser-specific optimizations
-   * @default true
-   */
-  browserOptimized?: boolean;
-  
-  /**
-   * Preferred models for browser tasks (in order of preference)
-   */
-  preferredBrowserModels?: string[];
-}
-
-/**
- * Get a browser-use compatible LLM wrapper from A3M Router
- */
-export function getBrowserUseLLM(config: BrowserUseA3MConfig) {
-  const a3m = new A3MRouter({
-    model: config.model || 'auto',
-    stealth: config.stealth || false,
-    parallelEnsemble: config.parallelEnsemble || 1,
-    providers: config.providers,
-  });
-
-  // Return a wrapper that's compatible with browser-use's LLM interface
-  return {
-    a3m,
-    
-    // Browser-use compatible interface
-    async chat(messages: any[]) {
-      const lastMessage = messages[messages.length - 1];
-      
-      const result = await a3m.route({
-        task: lastMessage.content,
-        context: 'browser_automation',
-      });
-      
-      return {
-        choices: [{
-          message: {
-            role: 'assistant',
-            content: result.content,
-          },
-        }],
-      };
-    },
-    
-    // Get routing stats for monitoring
-    getStats() {
-      return a3m.getStats();
-    },
-    
-    // Get cost for last N requests
-    getCost() {
-      return a3m.getCost();
-    },
-  };
-}
-
-/**
- * Create an A3M Router optimized for browser automation tasks
- */
-export function createBrowserAutomationRouter(config: BrowserUseA3MConfig) {
-  const router = new A3MRouter({
-    model: config.model || 'auto',
-    stealth: config.stealth || true,
-    parallelEnsemble: config.parallelEnsemble || 3,
-    browserOptimized: config.browserOptimized !== false,
-    providers: config.providers || ['openai', 'anthropic', 'google', 'groq'],
-  });
-
-  return {
-    router,
-    
-    /**
-     * Route a browser task to the optimal provider
-     */
-    async routeTask(task: string, context?: string) {
-      return router.route({
-        task,
-        context: context || 'browser_automation',
-      });
-    },
-    
-    /**
-     * Extract structured data from a page
-     */
-    async extractData(pageSchema: any, html: string) {
-      return router.route({
-        task: `Extract structured data from this HTML matching the schema: ${JSON.stringify(pageSchema)}`,
-        context: 'data_extraction',
-      });
-    },
-    
-    /**
-     * Fill a form with optimal model selection
-     */
-    async fillForm(formSchema: any, data: any) {
-      return router.route({
-        task: `Fill this form with data: ${JSON.stringify(data)}. Form schema: ${JSON.stringify(formSchema)}`,
-        context: 'form_filling',
-      });
-    },
-    
-    /**
-     * Get stealth routing configuration
-     */
-    getStealthConfig() {
-      return {
-        stealth: config.stealth || true,
-        proxyRotation: true,
-        humanizeTiming: true,
-        randomizeUserAgent: true,
-      };
-    },
-  };
-}
-
-export default {
-  getBrowserUseLLM,
-  createBrowserAutomationRouter,
-};

package/integrations/browser-use/package.json

@@ -1,34 +0,0 @@
-{
-  "name": "a3m-browser-use",
-  "version": "1.0.0",
-  "description": "A3M Router integration for browser-use - cost-optimized browser automation",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "adaptive-memory-multi-model-router": "^2.14.0",
-    "browser-use": "^0.12.0"
-  },
-  "peerDependencies": {
-    "browser-use": "^0.12.0"
-  },
-  "keywords": [
-    "browser-use",
-    "a3m",
-    "llm",
-    "router",
-    "browser-automation",
-    "cost-optimization",
-    "stealth",
-    "anti-detection"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Das-rebel/a3m-router"
-  },
-  "author": "Subhojit Das",
-  "license": "MIT"
-}

package/integrations/browser-use/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "examples"]
-}

package/integrations/mcp-browser/README.md

@@ -1,177 +0,0 @@
-# A3M Router MCP Server for Browser Automation
-
-**Use A3M's intelligent routing as an MCP server for AI agents.**
-
-This integration exposes A3M Router's capabilities via the Model Context Protocol (MCP), enabling AI agents (Claude Desktop, Cursor, Codex, n8n, etc.) to use intelligent LLM routing for browser automation tasks.
-
-## What is MCP?
-
-The [Model Context Protocol](https://modelcontextprotocol.io/) is an open standard for connecting AI assistants to external tools and data sources. MCP servers expose capabilities as "tools" that AI agents can call.
-
-## Installation
-
-```bash
-npm install a3m-mcp-browser
-# or
-npx a3m-mcp-browser
-```
-
-## Setup
-
-### Claude Desktop
-
-Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
-
-```json
-{
-  "mcpServers": {
-    "a3m-browser": {
-      "command": "npx",
-      "args": ["a3m-mcp-browser"]
-    }
-  }
-}
-```
-
-### Cursor
-
-Settings → MCP → Add new server:
-
-```json
-{
-  "name": "a3m-browser",
-  "command": "npx",
-  "args": ["a3m-mcp-browser"]
-}
-```
-
-### n8n
-
-Add MCP Trigger node with server config above.
-
-## Available Tools
-
-### `route_for_browser_task`
-
-Route a browser task to the optimal LLM provider.
-
-```json
-{
-  "task": "Extract all job listings from this page including title, company, and apply URL",
-  "context": "web_scraping"
-}
-```
-
-**Context options:**
-- `web_scraping` - Data extraction from web pages
-- `form_filling` - Filling out web forms
-- `form_analysis` - Analyzing form structure
-- `content_generation` - Generating content for web
-- `decision_making` - Making decisions based on page content
-
-### `extract_form_data`
-
-Extract structured data from a web page.
-
-```json
-{
-  "page_html": "<html>...</html>",
-  "schema": {
-    "name": "string",
-    "email": "string",
-    "jobs": "array"
-  }
-}
-```
-
-### `fill_form_intelligently`
-
-Get optimal values to fill a form field.
-
-```json
-{
-  "field_name": "email",
-  "field_type": "email",
-  "user_profile": {
-    "email": "user@example.com"
-  }
-}
-```
-
-### `get_stealth_routing`
-
-Get routing configuration optimized for stealth.
-
-```json
-{
-  "minimize_detection": true,
-  "provider_rotation": true
-}
-```
-
-## Example Workflow
-
-### Claude Desktop
-
-```
-You: Use A3M to extract all job listings from linkedin.com/jobs/search?q=marketing
-
-Claude: I'll use the A3M router to extract the job data...
-
-[Calls route_for_browser_task with task="Extract all job listings..."]
-
-Claude: I found 25 jobs. Here's the first few:
-
-1. **Head of Marketing** @ TechCorp
-   - URL: https://linkedin.com/jobs/view/123
-   - Location: Bengaluru
-   - Posted: 2 days ago
-
-2. **VP Growth** @ StartupXYZ
-   - URL: https://linkedin.com/jobs/view/456
-   - Location: Mumbai
-   - Posted: 5 days ago
-```
-
-### Cursor
-
-```
-User: Fill out this job application form using my resume data
-
-Cursor: I'll use A3M to intelligently fill the form...
-
-[Calls fill_form_intelligently for each field]
-
-[Calls route_for_browser_task to verify form completion]
-```
-
-## Cost Savings
-
-| Task Type | Without A3M | With A3M | Savings |
-|-----------|-------------|----------|---------|
-| Form filling | $0.03/task | $0.002/task | 93% |
-| Data extraction | $0.01/task | $0.003/task | 70% |
-| Page analysis | $0.02/task | $0.005/task | 75% |
-
-## Features
-
-- **Automatic routing** - Routes to cheapest capable model
-- **Stealth mode** - Minimize bot detection
-- **Parallel ensemble** - Run multiple providers for reliability
-- **Fallback handling** - Automatic retry on failure
-- **Cost tracking** - Monitor spending per task
-
-## Configuration
-
-```json
-{
-  "model": "auto",
-  "stealth": true,
-  "parallelEnsemble": 3,
-  "providers": ["openai", "anthropic", "google", "groq"]
-}
-```
-
-## License
-
-MIT - Same as A3M Router

package/integrations/mcp-browser/package.json

@@ -1,38 +0,0 @@
-{
-  "name": "a3m-mcp-browser",
-  "version": "1.0.0",
-  "description": "A3M Router MCP server for browser automation",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "a3m-mcp-browser": "dist/index.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsc && node dist/index.js"
-  },
-  "dependencies": {
-    "adaptive-memory-multi-model-router": "^2.14.0",
-    "@modelcontextprotocol/sdk": "^0.5.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "a3m",
-    "browser-automation",
-    "llm-routing",
-    "claude",
-    "cursor",
-    "n8n"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Das-rebel/a3m-router"
-  },
-  "author": "Subhojit Das",
-  "license": "MIT"
-}

package/integrations/mcp-browser/src/index.ts

@@ -1,297 +0,0 @@
-/**
- * A3M Router MCP Server for Browser Automation
- * 
- * Exposes A3M's intelligent LLM routing as MCP tools for AI agents.
- */
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import { A3MRouter } from 'adaptive-memory-multi-model-router';
-
-// Initialize A3M Router
-const router = new A3MRouter({
-  model: 'auto',
-  stealth: true,
-  parallelEnsemble: 3,
-  browserOptimized: true,
-  providers: ['openai', 'anthropic', 'google', 'groq'],
-});
-
-// Create MCP server
-const server = new Server(
-  {
-    name: 'a3m-browser',
-    version: '1.0.0',
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
-
-// Define available tools
-const tools = [
-  {
-    name: 'route_for_browser_task',
-    description: 'Route a browser automation task to the optimal LLM provider. Best for: web scraping, form filling, content extraction, page analysis.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        task: {
-          type: 'string',
-          description: 'The browser automation task to route',
-        },
-        context: {
-          type: 'string',
-          enum: ['web_scraping', 'form_filling', 'form_analysis', 'content_generation', 'decision_making'],
-          description: 'Type of browser task',
-          default: 'web_scraping',
-        },
-      },
-      required: ['task'],
-    },
-  },
-  {
-    name: 'extract_form_data',
-    description: 'Extract structured data from a web page HTML.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        page_html: {
-          type: 'string',
-          description: 'The HTML content of the page',
-        },
-        schema: {
-          type: 'object',
-          description: 'JSON schema describing what to extract',
-        },
-      },
-      required: ['page_html', 'schema'],
-    },
-  },
-  {
-    name: 'fill_form_intelligently',
-    description: 'Determine the best value to fill a form field with, based on user profile.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        field_name: {
-          type: 'string',
-          description: 'Name of the form field',
-        },
-        field_type: {
-          type: 'string',
-          description: 'Type of field (text, email, phone, etc.)',
-        },
-        user_profile: {
-          type: 'object',
-          description: 'User profile data to fill from',
-        },
-      },
-      required: ['field_name', 'field_type', 'user_profile'],
-    },
-  },
-  {
-    name: 'get_stealth_routing',
-    description: 'Get routing configuration optimized for stealth (minimizing bot detection).',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        minimize_detection: {
-          type: 'boolean',
-          description: 'Enable stealth mode',
-          default: true,
-        },
-      },
-    },
-  },
-  {
-    name: 'get_cost_stats',
-    description: 'Get cost statistics for routing decisions.',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-];
-
-// List tools handler
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return { tools };
-});
-
-// Call tool handler
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-
-  try {
-    switch (name) {
-      case 'route_for_browser_task': {
-        const { task, context = 'web_scraping' } = args as {
-          task: string;
-          context?: string;
-        };
-        
-        const result = await router.route({
-          task,
-          context: context as any,
-        });
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({
-                content: result.content,
-                provider: result.provider,
-                model: result.model,
-                cost: result.cost,
-              }, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'extract_form_data': {
-        const { page_html, schema } = args as {
-          page_html: string;
-          schema: any;
-        };
-        
-        const result = await router.route({
-          task: `Extract structured data from this HTML matching the schema: ${JSON.stringify(schema)}`,
-          context: 'data_extraction',
-        });
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: result.content,
-            },
-          ],
-        };
-      }
-
-      case 'fill_form_intelligently': {
-        const { field_name, field_type, user_profile } = args as {
-          field_name: string;
-          field_type: string;
-          user_profile: any;
-        };
-        
-        // Map field types to profile keys
-        const fieldMappings: Record<string, string> = {
-          'first name': 'firstName',
-          'last name': 'lastName',
-          'email': 'email',
-          'phone': 'phone',
-          'name': 'fullName',
-        };
-        
-        const profileKey = fieldMappings[field_name.toLowerCase()] || field_name.toLowerCase();
-        let value = user_profile[profileKey];
-        
-        if (!value) {
-          // Try common variations
-          const variations = [
-            field_name.replace(/\s+/g, ''),
-            field_name.replace(/\s+/g, '_'),
-            field_name.toLowerCase(),
-          ];
-          for (const v of variations) {
-            if (user_profile[v]) {
-              value = user_profile[v];
-              break;
-            }
-          }
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({
-                field: field_name,
-                suggested_value: value || '',
-                provider: 'profile_lookup',
-              }, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'get_stealth_routing': {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({
-                stealth: true,
-                proxy_rotation: true,
-                humanize_timing: true,
-                randomize_user_agent: true,
-                recommended_providers: ['anthropic', 'google'],
-                avoid_providers: ['openai-gpt4'], // Rate limited sites
-              }, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'get_cost_stats': {
-        const stats = router.getStats();
-        const cost = router.getCost();
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({
-                total_requests: stats.totalRequests,
-                total_cost: cost.total,
-                average_cost_per_request: cost.total / (stats.totalRequests || 1),
-                by_provider: cost.byProvider,
-              }, null, 2),
-            },
-          ],
-        };
-      }
-
-      default:
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Unknown tool: ${name}`,
-            },
-          ],
-          isError: true,
-        };
-    }
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-});
-
-// Start server
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('A3M Browser MCP Server running on stdio');
-}
-
-main().catch(console.error);