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

package/packages/a3m-vercel-ai/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "a3m-vercel-ai",
+  "version": "0.1.0",
+  "description": "A3M Router provider for Vercel AI SDK - intelligent cost-based routing with parallel execution",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "ai": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "ai": "^3.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "vercel",
+    "ai",
+    "sdk",
+    "router",
+    "llm",
+    "cost-optimization",
+    "a3m"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Das-rebel/a3m-router"
+  }
+}

package/packages/a3m-vercel-ai/src/a3m-language-model.ts

@@ -0,0 +1,381 @@
+/**
+ * A3M Router Language Model for Vercel AI SDK (v3)
+ * 
+ * Implements the LanguageModelV1 interface from @ai-sdk/provider
+ */
+
+import {
+  LanguageModelV1,
+  LanguageModelV1CallOptions,
+  LanguageModelV1CallWarning,
+  LanguageModelV1FinishReason,
+  LanguageModelV1ProviderMetadata,
+  LanguageModelV1StreamPart,
+  LanguageModelV1FunctionToolCall,
+} from '@ai-sdk/provider';
+import type { A3MRouterConfig } from './types';
+
+/**
+ * Convert Vercel AI SDK prompt format to OpenAI format for A3M
+ */
+function convertMessages(
+  prompt: LanguageModelV1CallOptions['prompt']
+): Array<{ role: 'user' | 'assistant' | 'system'; content: string }> {
+  const result: Array<{ role: 'user' | 'assistant' | 'system'; content: string }> = [];
+  
+  // Handle string prompts
+  if (typeof prompt === 'string') {
+    return [{ role: 'user', content: prompt }];
+  }
+  
+  // messages is an array of prompt parts
+  for (const part of prompt) {
+    if (part.role === 'system') {
+      result.push({ role: 'system', content: part.content });
+    } else if (part.role === 'user') {
+      if (typeof part.content === 'string') {
+        result.push({ role: 'user', content: part.content });
+      } else if (Array.isArray(part.content)) {
+        const textContent = part.content
+          .filter((p): p is { type: 'text'; text: string } => p.type === 'text')
+          .map(p => p.text)
+          .join('\n');
+        result.push({ role: 'user', content: textContent });
+      }
+    } else if (part.role === 'assistant') {
+      if (typeof part.content === 'string') {
+        result.push({ role: 'assistant', content: part.content });
+      } else if (Array.isArray(part.content)) {
+        const textContent = part.content
+          .filter((p): p is { type: 'text'; text: string } => p.type === 'text')
+          .map(p => p.text)
+          .join('\n');
+        result.push({ role: 'assistant', content: textContent });
+      }
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Create an A3M Router Language Model for Vercel AI SDK
+ */
+export function createA3MLanguageModel(config: A3MRouterConfig = {}) {
+  const baseURL = config.baseURL || 'http://localhost:8787';
+  const apiKey = config.apiKey || 'not-needed';
+  
+  const model: LanguageModelV1 = {
+    specificationVersion: 'v1',
+    provider: 'a3m',
+    modelId: 'auto',
+    defaultObjectGenerationMode: undefined,
+    
+    async doGenerate(options: LanguageModelV1CallOptions): Promise<{
+      text?: string;
+      toolCalls?: LanguageModelV1FunctionToolCall[];
+      finishReason: LanguageModelV1FinishReason;
+      usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+      };
+      rawCall: {
+        rawPrompt: unknown;
+        rawSettings: Record<string, unknown>;
+      };
+      warnings?: LanguageModelV1CallWarning[];
+      providerMetadata?: LanguageModelV1ProviderMetadata;
+    }> {
+      const messages = convertMessages(options.prompt);
+      
+      // Extract system prompt if present
+      const systemMessages = messages.filter(m => m.role === 'system');
+      const nonSystemMessages = messages.filter(m => m.role !== 'system');
+      const system = systemMessages.map(m => m.content).join('\n');
+      
+      // Build the request body for A3M
+      const requestBody: Record<string, unknown> = {
+        model: 'auto',
+        messages: nonSystemMessages.length > 0 ? nonSystemMessages : [{ role: 'user', content: ' ' }],
+      };
+      
+      if (system) {
+        requestBody.system = system;
+      }
+      
+      if (options.temperature !== undefined) {
+        requestBody.temperature = options.temperature;
+      }
+      
+      if (options.maxTokens !== undefined) {
+        requestBody.max_tokens = options.maxTokens;
+      }
+      
+      if (options.topP !== undefined) {
+        requestBody.top_p = options.topP;
+      }
+      
+      if (options.stopSequences !== undefined) {
+        requestBody.stop = options.stopSequences;
+      }
+      
+      if (config.parallelEnsemble) {
+        requestBody.parallel = config.parallelCount || 3;
+      }
+      
+      if (config.stealth) {
+        requestBody.stealth = true;
+      }
+      
+      try {
+        // Call A3M Router
+        const response = await fetch(`${baseURL}/v1/chat/completions`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+          },
+          body: JSON.stringify(requestBody),
+        });
+        
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`A3M Router error: ${response.status} ${error}`);
+        }
+        
+        const data = await response.json() as {
+          choices: Array<{
+            message: { 
+              content?: string;
+              tool_calls?: Array<{
+                id: string;
+                function: { name: string; arguments: string };
+              }>;
+            };
+            finish_reason: string;
+          }>;
+          usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+          };
+          _meta?: {
+            provider: string;
+            cost: number;
+          };
+        };
+        
+        const choice = data.choices[0];
+        
+        return {
+          text: choice.message.content || undefined,
+          toolCalls: choice.message.tool_calls?.map(tc => ({
+            toolCallType: 'function' as const,
+            toolCallId: tc.id,
+            toolName: tc.function.name,
+            args: tc.function.arguments,
+          })),
+          finishReason: (choice.finish_reason as LanguageModelV1FinishReason) || 'stop',
+          usage: {
+            promptTokens: data.usage?.prompt_tokens || 0,
+            completionTokens: data.usage?.completion_tokens || 0,
+            totalTokens: data.usage?.total_tokens || 0,
+          },
+          rawCall: {
+            rawPrompt: messages,
+            rawSettings: requestBody,
+          },
+          providerMetadata: data._meta ? {
+            a3m: {
+              provider: data._meta.provider,
+              cost: data._meta.cost,
+            },
+          } : undefined,
+        };
+      } catch (error) {
+        throw new Error(
+          `A3M Router generation failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    },
+    
+    doStream(options: LanguageModelV1CallOptions) {
+      const messages = convertMessages(options.prompt);
+      
+      // Extract system prompt if present
+      const systemMessages = messages.filter(m => m.role === 'system');
+      const nonSystemMessages = messages.filter(m => m.role !== 'system');
+      const system = systemMessages.map(m => m.content).join('\n');
+      
+      const requestBody: Record<string, unknown> = {
+        model: 'auto',
+        messages: nonSystemMessages.length > 0 ? nonSystemMessages : [{ role: 'user', content: ' ' }],
+        stream: true,
+      };
+      
+      if (system) {
+        requestBody.system = system;
+      }
+      
+      if (options.temperature !== undefined) {
+        requestBody.temperature = options.temperature;
+      }
+      
+      if (options.maxTokens !== undefined) {
+        requestBody.max_tokens = options.maxTokens;
+      }
+      
+      if (config.parallelEnsemble) {
+        requestBody.parallel = config.parallelCount || 3;
+      }
+      
+      if (config.stealth) {
+        requestBody.stealth = true;
+      }
+      
+      let attemptCount = 0;
+      const maxAttempts = 3;
+      
+      const doStream = async (): Promise<{
+        stream: ReadableStream<LanguageModelV1StreamPart>;
+        rawCall: { rawPrompt: unknown; rawSettings: Record<string, unknown> };
+      }> => {
+        attemptCount++;
+        
+        try {
+          const response = await fetch(`${baseURL}/v1/chat/completions`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(requestBody),
+          });
+          
+          if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`A3M Router streaming error: ${response.status} ${error}`);
+          }
+          
+          if (!response.body) {
+            throw new Error('A3M Router: no response body');
+          }
+          
+          const stream = new ReadableStream<LanguageModelV1StreamPart>({
+            async start(controller) {
+              const reader = response.body!.getReader();
+              const decoder = new TextDecoder();
+              let buffer = '';
+              
+              try {
+                while (true) {
+                  const { done, value } = await reader.read();
+                  
+                  if (done) {
+                    controller.close();
+                    break;
+                  }
+                  
+                  buffer += decoder.decode(value, { stream: true });
+                  const lines = buffer.split('\n');
+                  buffer = lines.pop() || '';
+                  
+                  for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                      const data = line.slice(6);
+                      
+                      if (data === '[DONE]') {
+                        controller.close();
+                        return;
+                      }
+                      
+                      try {
+                        const parsed = JSON.parse(data);
+                        
+                        // Handle chat completion chunks
+                        if (parsed.choices?.[0]?.delta?.content) {
+                          const chunk = parsed.choices[0].delta.content;
+                          controller.enqueue({
+                            type: 'text-delta',
+                            textDelta: chunk,
+                          } as LanguageModelV1StreamPart);
+                        }
+                        
+                        // Handle tool call start
+                        if (parsed.choices?.[0]?.delta?.tool_calls?.[0]) {
+                          const toolCall = parsed.choices[0].delta.tool_calls[0];
+                          if (toolCall.id) {
+                            controller.enqueue({
+                              type: 'tool-call',
+                              toolCallType: 'function',
+                              toolCallId: toolCall.id,
+                              toolName: toolCall.function?.name || '',
+                              args: toolCall.function?.arguments || '',
+                            } as LanguageModelV1StreamPart);
+                          }
+                        }
+                        
+                        // Handle tool call delta
+                        if (parsed.choices?.[0]?.delta?.tool_calls?.[0]?.function?.arguments) {
+                          const argsDelta = parsed.choices[0].delta.tool_calls[0].function.arguments;
+                          if (argsDelta) {
+                            controller.enqueue({
+                              type: 'tool-call-delta',
+                              toolCallType: 'function',
+                              toolCallId: parsed.choices[0].delta.tool_calls[0].id,
+                              toolName: parsed.choices[0].delta.tool_calls[0].function?.name || '',
+                              argsTextDelta: argsDelta,
+                            } as LanguageModelV1StreamPart);
+                          }
+                        }
+                        
+                        // Handle finish
+                        if (parsed.choices?.[0]?.finish_reason) {
+                          controller.enqueue({
+                            type: 'finish',
+                            finishReason: parsed.choices[0].finish_reason as LanguageModelV1FinishReason,
+                            usage: {
+                              promptTokens: parsed.usage?.prompt_tokens || 0,
+                              completionTokens: parsed.usage?.completion_tokens || 0,
+                            },
+                          } as LanguageModelV1StreamPart);
+                        }
+                      } catch {
+                        // Skip malformed JSON
+                      }
+                    }
+                  }
+                }
+              } catch (streamError) {
+                controller.error(streamError);
+              }
+            },
+          });
+          
+          return {
+            stream,
+            rawCall: {
+              rawPrompt: messages,
+              rawSettings: requestBody,
+            },
+          };
+        } catch (error) {
+          if (attemptCount < maxAttempts) {
+            await new Promise(resolve => setTimeout(resolve, 1000 * attemptCount));
+            return doStream();
+          }
+          throw error;
+        }
+      };
+      
+      return new Promise((resolve, reject) => {
+        doStream()
+          .then(resolve)
+          .catch(reject);
+      });
+    },
+  };
+  
+  return model;
+}

package/packages/a3m-vercel-ai/src/index.ts

@@ -0,0 +1,104 @@
+/**
+ * @a3m/vercel-ai - A3M Router Provider for Vercel AI SDK
+ * 
+ * Drop-in replacement that routes to the cheapest capable provider
+ * with parallel execution, caching, and automatic fallback.
+ * 
+ * @example
+ * ```typescript
+ * import { createA3MProvider } from '@a3m/vercel-ai';
+ * import { generateText } from 'ai';
+ * 
+ * const a3m = createA3MProvider();
+ * 
+ * const { text } = await generateText({
+ *   model: a3m('auto'),
+ *   prompt: 'What is the capital of France?',
+ * });
+ * ```
+ */
+
+export type { A3MRouterConfig, A3MRouteResponse, A3MStreamChunk } from './types';
+export { createA3MLanguageModel } from './a3m-language-model';
+
+import type { LanguageModelV1 } from '@ai-sdk/provider';
+import type { A3MRouterConfig } from './types';
+import { createA3MLanguageModel } from './a3m-language-model';
+
+/**
+ * A3M Router provider for Vercel AI SDK
+ */
+export interface A3MProvider {
+  name: 'a3m';
+  /**
+   * Returns an A3M language model.
+   * 
+   * @param modelId - Use 'auto' for automatic routing, or specify a model like 'gpt-4', 'claude-3', etc.
+   */
+  (modelId: string): LanguageModelV1;
+}
+
+/**
+ * Create an A3M Router provider for Vercel AI SDK
+ */
+export function createA3MProvider(config: A3MRouterConfig = {}): A3MProvider {
+  const languageModel = createA3MLanguageModel(config);
+  
+  const provider = Object.assign(
+    (modelId: string) => {
+      // Return the language model - A3M handles model selection internally
+      return languageModel;
+    },
+    {
+      name: 'a3m' as const,
+      // Allow accessing config for introspection
+      __config: config,
+    }
+  );
+  
+  return provider;
+}
+
+/**
+ * Example usage with Next.js App Router
+ * 
+ * ```typescript
+ * // app/api/chat/route.ts
+ * import { createA3MProvider } from '@a3m/vercel-ai';
+ * import { generateText } from 'ai';
+ * 
+ * const a3m = createA3MProvider({
+ *   parallelEnsemble: true,
+ * });
+ * 
+ * export async function POST(req: Request) {
+ *   const { messages } = await req.json();
+ *   
+ *   const result = await generateText({
+ *     model: a3m('auto'),
+ *     messages,
+ *   });
+ *   
+ *   return Response.json(result);
+ * }
+ * ```
+ */
+
+/**
+ * Example usage with streaming
+ * 
+ * ```typescript
+ * import { createA3MProvider } from '@a3m/vercel-ai';
+ * import { streamText } from 'ai';
+ * 
+ * const a3m = createA3MProvider();
+ * 
+ * const result = await streamText({
+ *   model: a3m('auto'),
+ *   prompt: 'Write a story about a robot...',
+ * });
+ * 
+ * // Stream to response
+ * return result.toDataStreamResponse();
+ * ```
+ */

package/packages/a3m-vercel-ai/src/types.ts

@@ -0,0 +1,116 @@
+/**
+ * A3M Router configuration for Vercel AI SDK
+ */
+
+export interface A3MRouterConfig {
+  /**
+   * A3M Router endpoint
+   * @default 'http://localhost:8787'
+   */
+  baseURL?: string;
+
+  /**
+   * API key for A3M Router
+   * @default 'not-needed' for local
+   */
+  apiKey?: string;
+
+  /**
+   * Enable parallel ensemble execution
+   * Runs multiple providers and picks the best result
+   * @default false
+   */
+  parallelEnsemble?: boolean;
+
+  /**
+   * Number of providers to run in parallel when parallelEnsemble is true
+   * @default 3
+   */
+  parallelCount?: number;
+
+  /**
+   * Enable stealth mode (anti-detection for browser automation)
+   * @default false
+   */
+  stealth?: boolean;
+
+  /**
+   * Cache configuration
+   */
+  cache?: {
+    enabled?: boolean;
+    ttl?: number; // seconds
+  };
+
+  /**
+   * Provider configuration
+   * Maps provider names to their API keys
+   */
+  providers?: Record<string, {
+    apiKey: string;
+    /** Override the base URL for this provider */
+    baseURL?: string;
+  }>;
+
+  /**
+   * Cost limits per provider
+   */
+  budgetLimits?: Record<string, {
+    maxCostPerRequest?: number;
+    maxRequestsPerMinute?: number;
+  }>;
+}
+
+/**
+ * A3M Router response from /route or /generate
+ */
+export interface A3MRouteResponse {
+  /** The generated content */
+  content: string;
+
+  /** The provider that was selected */
+  provider: string;
+
+  /** The model that was used */
+  model: string;
+
+  /** Cost in USD */
+  cost: number;
+
+  /** Latency in ms */
+  latencyMs: number;
+
+  /** Token usage */
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+
+  /** Confidence score (0-1) */
+  confidence?: number;
+
+  /** Finish reason */
+  finishReason?: 'stop' | 'length' | 'error';
+}
+
+/**
+ * A3M Router streaming response chunk
+ */
+export interface A3MStreamChunk {
+  /** The delta content */
+  delta: string;
+
+  /** Provider that responded */
+  provider: string;
+
+  /** Whether this is the final chunk */
+  done: boolean;
+
+  /** Token usage (only on final chunk) */
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+}

package/packages/a3m-vercel-ai/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}