prepia 1.0.0

package/src/client/adapters.mjs

@@ -0,0 +1,483 @@
+/**
+ * Prepia Agent Adapters
+ * Universal connectors for popular AI agent frameworks
+ * Each adapter wraps PrepiClient for framework-specific usage
+ */
+
+import { PrepiClient, prepiConnect } from './index.mjs';
+
+/**
+ * Base adapter with common functionality
+ */
+class BaseAdapter {
+  constructor(config = {}) {
+    this.client = typeof config === 'string' ? prepiConnect(config) : new PrepiClient(config);
+    this.name = 'base';
+  }
+
+  async init() { await this.client.connect(); }
+  async shutdown() { this.client.disconnect(); }
+}
+
+// ═══════════════════════════════════════════════════
+// 🔌 OPENCLAW ADAPTER
+// ═══════════════════════════════════════════════════
+
+/**
+ * OpenClaw Skill Integration
+ * Drop this into an OpenClaw skill to use Prepia
+ */
+export class OpenClawAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super({ ...config, agentType: 'openclaw' });
+    this.name = 'openclaw';
+  }
+
+  /**
+   * Process a task the OpenClaw way — returns structured result
+   * @param {string} task - User's request
+   * @param {Object} context - OpenClaw session context
+   * @returns {Promise<{ answer: string, sources: Array, tokensSaved: number }>}
+   */
+  async process(task, context = {}) {
+    const result = await this.client.task({
+      description: task,
+      context: {
+        sessionId: context.sessionKey,
+        userId: context.userId,
+        channel: context.channel,
+      },
+      mode: this._detectMode(task),
+    });
+
+    return {
+      answer: result.data?.answer || result.data?.output || '',
+      sources: result.data?.sources || [],
+      tokensSaved: result.data?.metrics?.tokensSaved || 0,
+      cached: result.data?.cached || false,
+      phases: result.data?.phases || [],
+    };
+  }
+
+  /**
+   * Auto-detect the best processing mode
+   * @param {string} task
+   * @returns {string}
+   */
+  _detectMode(task) {
+    const lower = task.toLowerCase();
+    // Simple factual questions → flash
+    if (/^(what|who|when|where|how much|how many|convert|calculate)\b/i.test(lower) && task.length < 100) {
+      return 'flash';
+    }
+    // Complex research → shot with tools
+    if (/research|analyze|compare|investigate|find out|look up/i.test(lower)) {
+      return 'shot';
+    }
+    return 'shot';
+  }
+
+  /**
+   * Format result for OpenClaw response
+   * @param {Object} result
+   * @returns {string}
+   */
+  formatResponse(result) {
+    let response = result.answer;
+    if (result.cached) response += '\n\n📦 _Served from cache_';
+    if (result.tokensSaved > 0) response += `\n⚡ _${result.tokensSaved} tokens saved by Prepia_`;
+    return response;
+  }
+}
+
+// ═══════════════════════════════════════════════════
+// 🤖 AUTO-GPT ADAPTER
+// ═══════════════════════════════════════════════════
+
+/**
+ * AutoGPT / AgentGPT integration
+ */
+export class AutoGPTAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super({ ...config, agentType: 'autogpt' });
+    this.name = 'autogpt';
+    this.goalStack = [];
+  }
+
+  /**
+   * Execute a step in the AutoGPT goal loop
+   * @param {string} goal - Current goal
+   * @param {Object} context - Agent context (thoughts, memories, etc.)
+   * @returns {Promise<{ command: string, args: Object, reasoning: string }>}
+   */
+  async executeStep(goal, context = {}) {
+    const result = await this.client.task({
+      description: goal,
+      mode: 'shot',
+      context: {
+        previousThoughts: context.thoughts || [],
+        memories: context.memories || [],
+        constraints: context.constraints || [],
+      },
+      tools: ['web-search', 'calculator', 'file-ops'],
+    });
+
+    return {
+      command: result.data?.suggestedAction || 'respond',
+      args: result.data?.actionArgs || {},
+      reasoning: result.data?.reasoning || result.data?.answer || '',
+      confidence: result.data?.confidence || 0.8,
+    };
+  }
+
+  /**
+   * Research a topic before acting
+   * @param {string} topic
+   * @returns {Promise<Object>}
+   */
+  async research(topic) {
+    return this.client.task({
+      description: `Research: ${topic}`,
+      mode: 'shot',
+      tools: ['web-search', 'web-scraper'],
+    });
+  }
+}
+
+// ═══════════════════════════════════════════════════
+// 🚢 CREWAI ADAPTER
+// ═══════════════════════════════════════════════════
+
+/**
+ * CrewAI integration — Prepia as a crew member
+ */
+export class CrewAIAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super({ ...config, agentType: 'crewai' });
+    this.name = 'crewai';
+  }
+
+  /**
+   * Create a Prepia-powered crew agent
+   * @param {Object} agentConfig
+   * @returns {Object} Agent-like object for CrewAI
+   */
+  createAgent(agentConfig = {}) {
+    const adapter = this;
+    return {
+      role: agentConfig.role || 'Research Analyst',
+      goal: agentConfig.goal || 'Gather and analyze information efficiently',
+      backstory: agentConfig.backstory || 'Powered by Prepia middleware for optimized AI tasks',
+      tools: agentConfig.tools || ['web-search', 'calculator'],
+
+      /**
+       * CrewAI calls this to execute a task
+       */
+      async executeTask(taskDescription) {
+        const result = await adapter.client.task({
+          description: taskDescription,
+          mode: 'shot',
+          context: { role: agentConfig.role },
+        });
+        return result.data?.answer || result.data?.output || '';
+      },
+
+      /**
+       * CrewAI calls this for delegation
+       */
+      async delegateTask(taskDescription, targetRole) {
+        return adapter.client.task({
+          description: taskDescription,
+          mode: 'shot',
+          context: { delegatedTo: targetRole },
+        });
+      },
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════
+// 🔗 LANGCHAIN ADAPTER
+// ═══════════════════════════════════════════════════
+
+/**
+ * LangChain integration — Prepia as a tool/chain
+ */
+export class LangChainAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super({ ...config, agentType: 'langchain' });
+    this.name = 'langchain';
+  }
+
+  /**
+   * Create a LangChain-compatible tool
+   * @param {string} name - Tool name
+   * @param {string} description - Tool description
+   * @returns {Object} LangChain Tool-like object
+   */
+  createTool(name = 'prepia', description = 'AI-powered research and task execution') {
+    const adapter = this;
+    return {
+      name,
+      description,
+      schema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'The task or question to process' },
+        },
+        required: ['query'],
+      },
+      async _call(input) {
+        const query = typeof input === 'string' ? input : input.query;
+        const result = await adapter.client.task({
+          description: query,
+          mode: 'shot',
+        });
+        return result.data?.answer || result.data?.output || JSON.stringify(result.data);
+      },
+    };
+  }
+
+  /**
+   * Create a LangChain-compatible chain
+   * @returns {Object} Chain-like object
+   */
+  createChain() {
+    const adapter = this;
+    return {
+      async invoke(input) {
+        const query = typeof input === 'string' ? input : input.input || input.query;
+        const result = await adapter.client.task({
+          description: query,
+          mode: 'shot',
+        });
+        return { output: result.data?.answer || result.data?.output || '' };
+      },
+      async batch(inputs) {
+        return Promise.all(inputs.map(input => this.invoke(input)));
+      },
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════
+// 🦜 SEMANTIC KERNEL ADAPTER
+// ═══════════════════════════════════════════════════
+
+/**
+ * Microsoft Semantic Kernel integration
+ */
+export class SemanticKernelAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super({ ...config, agentType: 'semantic-kernel' });
+    this.name = 'semantic-kernel';
+  }
+
+  /**
+   * Create a Semantic Kernel function
+   * @param {string} functionName
+   * @returns {Object}
+   */
+  createFunction(functionName = 'PrepiaTask') {
+    const adapter = this;
+    return {
+      name: functionName,
+      description: 'Execute a task using Prepia middleware',
+      parameters: [
+        { name: 'task', type: 'string', description: 'Task to execute', required: true },
+        { name: 'mode', type: 'string', description: 'Processing mode', required: false },
+      ],
+      async invoke(args) {
+        const result = await adapter.client.task({
+          description: args.task,
+          mode: args.mode || 'shot',
+        });
+        return result.data?.answer || result.data?.output || '';
+      },
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════
+// 🐍 PYTHON BRIDGE ADAPTER
+// ═══════════════════════════════════════════════════
+
+/**
+ * For Python-based agents (AutoGen, CrewAI Python, custom)
+ * Generates a Python client that communicates with Prepia via HTTP
+ */
+export class PythonBridgeAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super({ ...config, agentType: 'python' });
+    this.name = 'python-bridge';
+  }
+
+  /**
+   * Generate Python client code
+   * @returns {string} Python source code for the client
+   */
+  generatePythonClient() {
+    const host = this.client.host;
+    const port = this.client.port;
+    return `
+"""
+PrepiPy - Python client for Prepia middleware
+Auto-generated by Prepia Universal Adapter
+"""
+import json
+import urllib.request
+import urllib.error
+
+class PrepiClient:
+    def __init__(self, host="${host}", port=${port}, api_key=None, timeout=300):
+        self.base_url = f"http://{host}:{port}"
+        self.api_key = api_key
+        self.timeout = timeout
+
+    def _request(self, method, path, body=None):
+        url = f"{self.base_url}{path}"
+        headers = {"Content-Type": "application/json", "X-Prepia-Agent-Type": "python"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        data = json.dumps(body).encode() if body else None
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return json.loads(resp.read().decode())
+        except urllib.error.HTTPError as e:
+            error_data = json.loads(e.read().decode())
+            raise Exception(error_data.get("error", f"HTTP {e.code}"))
+
+    def task(self, description, mode="shot", **kwargs):
+        body = {"description": description, "mode": mode, "agentType": "python", **kwargs}
+        return self._request("POST", "/api/task", body)
+
+    def quick(self, query):
+        return self.task(query, mode="flash")
+
+    def health(self):
+        return self._request("GET", "/api/health")
+
+    def analytics(self):
+        return self._request("GET", "/api/analytics")
+
+# Quick usage:
+# prepi = PrepiClient()
+# result = prepi.task("Research top 5 phones")
+# print(result["data"]["answer"])
+`;
+  }
+}
+
+// ═══════════════════════════════════════════════════
+// 🌐 GENERIC REST ADAPTER
+// ═══════════════════════════════════════════════════
+
+/**
+ * For any agent that can make HTTP requests
+ * Provides a simple REST-like interface
+ */
+export class RestAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super({ ...config, agentType: 'rest-client' });
+    this.name = 'rest';
+  }
+
+  /**
+   * Get OpenAPI-compatible spec for Prepia
+   * @returns {Object}
+   */
+  getOpenAPISpec() {
+    return {
+      openapi: '3.0.0',
+      info: {
+        title: 'Prepia API',
+        version: '1.0.0',
+        description: 'AI middleware that reduces LLM calls by 80-95%',
+      },
+      servers: [{ url: this.client.baseUrl }],
+      paths: {
+        '/api/task': {
+          post: {
+            summary: 'Submit a task',
+            requestBody: {
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: {
+                      description: { type: 'string' },
+                      mode: { type: 'string', enum: ['flash', 'shot', 'stream'] },
+                      tools: { type: 'array', items: { type: 'string' } },
+                      cache: { type: 'boolean' },
+                    },
+                    required: ['description'],
+                  },
+                },
+              },
+            },
+            responses: {
+              200: { description: 'Task result' },
+              429: { description: 'Rate limited' },
+              500: { description: 'Server error' },
+            },
+          },
+        },
+        '/api/health': {
+          get: { summary: 'Health check', responses: { 200: { description: 'OK' } } },
+        },
+        '/api/analytics': {
+          get: { summary: 'Usage analytics', responses: { 200: { description: 'Analytics data' } } },
+        },
+      },
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════
+// 🏭 ADAPTER FACTORY
+// ═══════════════════════════════════════════════════
+
+const ADAPTERS = {
+  openclaw: OpenClawAdapter,
+  autogpt: AutoGPTAdapter,
+  crewai: CrewAIAdapter,
+  langchain: LangChainAdapter,
+  'semantic-kernel': SemanticKernelAdapter,
+  python: PythonBridgeAdapter,
+  rest: RestAdapter,
+};
+
+/**
+ * Create an adapter for a specific agent framework
+ * @param {string} framework - Framework name
+ * @param {Object} config - Connection config
+ * @returns {BaseAdapter}
+ */
+export function createAdapter(framework, config = {}) {
+  const AdapterClass = ADAPTERS[framework.toLowerCase()];
+  if (!AdapterClass) {
+    throw new Error(`Unknown framework: ${framework}. Available: ${Object.keys(ADAPTERS).join(', ')}`);
+  }
+  return new AdapterClass(config);
+}
+
+/**
+ * List all available adapters
+ * @returns {string[]}
+ */
+export function listAdapters() {
+  return Object.keys(ADAPTERS);
+}
+
+export default {
+  OpenClawAdapter,
+  AutoGPTAdapter,
+  CrewAIAdapter,
+  LangChainAdapter,
+  SemanticKernelAdapter,
+  PythonBridgeAdapter,
+  RestAdapter,
+  createAdapter,
+  listAdapters,
+};