chat-agent-toolkit 1.2.2 → 1.2.3

package/src/memory/storage/drizzle-storage.ts

@@ -14,15 +14,40 @@ import type {
 } from "../types";
 
 /**
- * Drizzle-based storage adapter
+ * The Drizzle table passed to {@link DrizzleMemoryStorage} must expose these
+ * columns (see {@link createMemorySchema} for the expected shape).
+ */
+export interface MemoryTable {
+  id: any;
+  user_id: any;
+  memory_type: any;
+  content: any;
+  importance: any;
+  access_count: any;
+  metadata: any;
+  created_at: any;
+  updated_at: any;
+}
+
+/**
+ * Drizzle-based storage adapter.
+ *
+ * Pass the Drizzle database instance and the memory table object defined in
+ * your schema (not a table-name string) so queries reference real columns:
+ *
+ * ```ts
+ * import { sqliteTable, text, integer, real } from "drizzle-orm/sqlite-core";
+ * const userMemories = sqliteTable("user_memories", { ... });
+ * const storage = new DrizzleMemoryStorage(db, userMemories);
+ * ```
  */
 export class DrizzleMemoryStorage implements IMemoryStorage {
   private db: any;
-  private tableName: string;
+  private table: MemoryTable & Record<string, any>;
 
-  constructor(db: any, tableName: string = "user_memories") {
+  constructor(db: any, table: MemoryTable & Record<string, any>) {
     this.db = db;
-    this.tableName = tableName;
+    this.table = table;
   }
 
   /**
@@ -36,7 +61,7 @@ export class DrizzleMemoryStorage implements IMemoryStorage {
     metadata?: Record<string, any>,
   ): Promise<string> {
     const result = await this.db
-      .insert(this.tableName)
+      .insert(this.table)
       .values({
         user_id: userId,
         memory_type: memoryType,
@@ -47,7 +72,7 @@ export class DrizzleMemoryStorage implements IMemoryStorage {
         created_at: new Date(),
         updated_at: new Date(),
       })
-      .returning({ id: "id" });
+      .returning({ id: this.table.id });
 
     return result[0]?.id;
   }
@@ -61,31 +86,35 @@ export class DrizzleMemoryStorage implements IMemoryStorage {
     limit: number = 10,
     options: MemorySearchOptions = {},
   ): Promise<MemoryRecord[]> {
-    const conditions = [eq("user_id", userId)];
+    const conditions = [eq(this.table.user_id, userId)];
 
     if (query && query.trim()) {
-      conditions.push(like("content", `%${query}%`));
+      conditions.push(like(this.table.content, `%${query}%`));
     }
 
     if (options.memoryType) {
-      conditions.push(eq("memory_type", options.memoryType));
+      conditions.push(eq(this.table.memory_type, options.memoryType));
     }
 
     const results = await this.db
       .select({
-        id: "id",
-        user_id: "user_id",
-        memory_type: "memory_type",
-        content: "content",
-        importance: "importance",
-        access_count: "access_count",
-        metadata: "metadata",
-        created_at: "created_at",
-        updated_at: "updated_at",
+        id: this.table.id,
+        user_id: this.table.user_id,
+        memory_type: this.table.memory_type,
+        content: this.table.content,
+        importance: this.table.importance,
+        access_count: this.table.access_count,
+        metadata: this.table.metadata,
+        created_at: this.table.created_at,
+        updated_at: this.table.updated_at,
       })
-      .from(this.tableName)
+      .from(this.table)
       .where(and(...conditions))
-      .orderBy(desc("importance"), desc("access_count"), desc("updated_at"))
+      .orderBy(
+        desc(this.table.importance),
+        desc(this.table.access_count),
+        desc(this.table.updated_at),
+      )
       .limit(Math.min(limit, 50)); // Cap at 50 for performance
 
     return results as MemoryRecord[];
@@ -110,13 +139,15 @@ export class DrizzleMemoryStorage implements IMemoryStorage {
       return [];
     }
 
-    const conditions = searchTerms.map((term) => like("content", `%${term}%`));
+    const conditions = searchTerms.map((term) =>
+      like(this.table.content, `%${term}%`),
+    );
 
     const results = await this.db
       .select()
-      .from(this.tableName)
-      .where(and(eq("user_id", userId), or(...conditions)))
-      .orderBy(desc("importance"), desc("updated_at"))
+      .from(this.table)
+      .where(and(eq(this.table.user_id, userId), or(...conditions)))
+      .orderBy(desc(this.table.importance), desc(this.table.updated_at))
       .limit(limit);
 
     return results as MemoryRecord[];
@@ -134,7 +165,7 @@ export class DrizzleMemoryStorage implements IMemoryStorage {
 
     if (updates.access_count !== undefined) {
       if (typeof updates.access_count === "object" && updates.access_count.increment) {
-        updateData.access_count = sql`access_count + ${updates.access_count.increment}`;
+        updateData.access_count = sql`${this.table.access_count} + ${updates.access_count.increment}`;
       } else {
         updateData.access_count = updates.access_count;
       }
@@ -148,14 +179,14 @@ export class DrizzleMemoryStorage implements IMemoryStorage {
       updateData.metadata = updates.metadata;
     }
 
-    await this.db.update(this.tableName).set(updateData).where(eq("id", id));
+    await this.db.update(this.table).set(updateData).where(eq(this.table.id, id));
   }
 
   /**
    * Delete a memory record
    */
   async deleteMemory(id: string): Promise<void> {
-    await this.db.delete(this.tableName).where(eq("id", id));
+    await this.db.delete(this.table).where(eq(this.table.id, id));
   }
 
   /**
@@ -164,8 +195,8 @@ export class DrizzleMemoryStorage implements IMemoryStorage {
   async getMemoryById(id: string): Promise<MemoryRecord | null> {
     const results = await this.db
       .select()
-      .from(this.tableName)
-      .where(eq("id", id))
+      .from(this.table)
+      .where(eq(this.table.id, id))
       .limit(1);
 
     return (results[0] as MemoryRecord) || null;

package/src/memory/storage/in-memory-storage.ts

@@ -11,7 +11,7 @@
  * - Conflict resolution
  */
 
-import { generateLanguageResponse } from "write-language";
+import { writeLanguageResponse } from "write-language";
 import type { IMemoryStorage } from "./storage-interface";
 import type {
   MemoryRecord,
@@ -422,7 +422,7 @@ export class SimpleMemory {
     conversationText: string,
   ): Promise<ExtractedFact[]> {
     try {
-      const { extract: factsResponse } = await generateLanguageResponse({
+      const { extract: factsResponse } = await writeLanguageResponse({
         agent: "remember-facts",
         chat_history: conversationText,
         provider: "groq",

package/src/memory/storage/storage-interface.ts

@@ -10,7 +10,7 @@ import type {
   MemoryType,
   MemorySearchOptions,
   MemoryUpdate,
-} from "./types";
+} from "../types";
 
 /**
  * Storage interface that any database adapter must implement

package/src/models/types.ts

@@ -1,4 +1,4 @@
 /**
  * @fileoverview Re-export model types from config directory
  */
-export type { Model, ConfigModelProvider } from "../config/config-types";
+export type { Model, ConfigModelProvider, MinimalProvider } from "../config/config-types";

package/src/tools/{composio-mastra.ts → open-connector-mastra.ts}

@@ -1,34 +1,34 @@
 /**
- * @fileoverview Composio + Mastra Integration
+ * @fileoverview OpenConnector + Mastra Integration
  *
- * Connects Composio's MCP endpoint to Mastra agents.
- * Composio provides the tools, Mastra provides the agent framework.
+ * Connects OpenConnector's MCP endpoint to Mastra agents.
+ * OpenConnector provides the tools, Mastra provides the agent framework.
  *
  * Architecture:
- * 1. Create Composio Tool Router session → Get MCP URL + headers
- * 2. Configure Mastra MCPClient with URL + headers
+ * 1. Connect to OpenConnector Worker URL at /mcp/sse
+ * 2. Configure Mastra MCPClient with URL + auth headers
  * 3. Get tools with mcp.listTools() or mcp.listToolsets()
  * 4. Create Mastra Agent with tools
  * 5. Execute agent.generate() with multi-step tool calling
  *
- * @see https://composio.dev/toolkits/composio/framework/mastra-ai
+ * @see https://github.com/OpenSourceAGI/open-connector
  */
 
-import { Composio } from '@composio/core';
 import { Agent } from '@mastra/core/agent';
 import { MCPClient } from '@mastra/mcp';
-import type { Tool } from '@mastra/core';
 
 /**
- * Configuration for Composio + Mastra integration
+ * Configuration for OpenConnector + Mastra integration
  */
-export interface ComposioMastraConfig {
-  /** Composio API key */
-  composioApiKey: string;
+export interface OpenConnectorMastraConfig {
+  /** OpenConnector admin token */
+  adminToken: string;
+  /** Base URL of the deployed OpenConnector Worker */
+  baseUrl: string;
   /** User ID for scoping the session */
   userId: string;
-  /** Toolkits to enable */
-  toolkits: string[];
+  /** Apps to enable */
+  apps: string[];
   /** Agent configuration */
   agent: {
     id: string;
@@ -42,67 +42,36 @@ export interface ComposioMastraConfig {
 }
 
 /**
- * Composio + Mastra session manager
+ * OpenConnector + Mastra session manager
  * Handles MCP connection lifecycle and agent creation
  */
-export class ComposioMastraSession {
-  private composio: Composio;
+export class OpenConnectorMastraSession {
   private mcpClient: MCPClient | null = null;
   private agent: Agent | null = null;
-  private sessionEndpoint: { url: string; headers: Record<string, string> } | null =
-    null;
 
-  constructor(private config: ComposioMastraConfig) {
-    this.composio = new Composio({
-      apiKey: config.composioApiKey,
-    });
-  }
-
-  /**
-   * Create Composio Tool Router session
-   * Returns MCP endpoint URL + auth headers
-   */
-  private async createSession() {
-    if (this.sessionEndpoint) {
-      return this.sessionEndpoint;
-    }
-
-    // Create Composio session with specified toolkits
-    const session = await this.composio.toolsets.create({
-      userId: this.config.userId,
-      toolkits: this.config.toolkits,
-    });
-
-    this.sessionEndpoint = {
-      url: session.mcp.url,
-      headers: {
-        'x-api-key': this.config.composioApiKey,
-        ...session.mcp.headers,
-      },
-    };
-
-    return this.sessionEndpoint;
-  }
+  constructor(private config: OpenConnectorMastraConfig) {}
 
   /**
    * Get or create Mastra MCP client
-   * Connects to Composio's MCP endpoint via HTTP
+   * Connects to OpenConnector's MCP endpoint via HTTP
    */
   async getMCPClient(): Promise<MCPClient> {
     if (this.mcpClient) {
       return this.mcpClient;
     }
 
-    const endpoint = await this.createSession();
+    const mcpUrl = `${this.config.baseUrl}/mcp/sse`;
 
     // Create Mastra MCP client
     this.mcpClient = new MCPClient({
-      id: `composio-${this.config.userId}`,
+      id: `open-connector-${this.config.userId}`,
       servers: {
-        composio: {
-          url: new URL(endpoint.url),
+        openconnector: {
+          url: new URL(mcpUrl),
           requestInit: {
-            headers: endpoint.headers,
+            headers: {
+              Authorization: `Bearer ${this.config.adminToken}`,
+            },
           },
         },
       },
@@ -112,16 +81,16 @@ export class ComposioMastraSession {
   }
 
   /**
-   * Get tools from Composio MCP
+   * Get tools from OpenConnector MCP
    * Use for static agent setup (same tools for all requests)
    */
-  async getTools(): Promise<Record<string, Tool>> {
+  async getTools() {
     const mcp = await this.getMCPClient();
     return await mcp.listTools();
   }
 
   /**
-   * Get toolsets from Composio MCP
+   * Get toolsets from OpenConnector MCP
    * Use for dynamic per-request tool configuration
    */
   async getToolsets() {
@@ -130,7 +99,7 @@ export class ComposioMastraSession {
   }
 
   /**
-   * Create or get Mastra agent with Composio tools
+   * Create or get Mastra agent with OpenConnector tools
    * Agent is cached and reused across generate() calls
    */
   async getAgent(): Promise<Agent> {
@@ -163,7 +132,8 @@ export class ComposioMastraSession {
     prompt: string,
     options?: {
       maxSteps?: number;
-      context?: Record<string, any>;
+      /** Extra context messages passed to the agent (model messages) */
+      context?: any[];
     }
   ) {
     const agent = await this.getAgent();
@@ -184,20 +154,20 @@ export class ComposioMastraSession {
       this.mcpClient = null;
     }
     this.agent = null;
-    this.sessionEndpoint = null;
   }
 }
 
 /**
- * Quick helper to create a Composio + Mastra agent
+ * Quick helper to create an OpenConnector + Mastra agent
  * For one-off usage without session management
  *
  * @example
  * ```ts
- * const result = await createComposioMastraAgent({
- *   composioApiKey: process.env.COMPOSIO_API_KEY!,
+ * const result = await createOpenConnectorMastraAgent({
+ *   adminToken: process.env.OPEN_CONNECTOR_ADMIN_TOKEN!,
+ *   baseUrl: 'https://open-connector.example.workers.dev',
  *   userId: 'user-123',
- *   toolkits: ['GMAIL', 'SLACK'],
+ *   apps: ['gmail', 'slack'],
  *   agent: {
  *     id: 'email-agent',
  *     name: 'Email Assistant',
@@ -207,20 +177,23 @@ export class ComposioMastraSession {
  * }).generate('Check my unread emails');
  * ```
  */
-export async function createComposioMastraAgent(config: ComposioMastraConfig) {
-  const session = new ComposioMastraSession(config);
+export async function createOpenConnectorMastraAgent(
+  config: OpenConnectorMastraConfig
+) {
+  const session = new OpenConnectorMastraSession(config);
   await session.getAgent(); // Initialize
   return session;
 }
 
 /**
- * Create Mastra agent with dynamic per-request toolsets
+ * Create Mastra agent with dynamic per-request apps
  * Better for multi-user scenarios where tools vary per request
  *
  * @example
  * ```ts
- * const agent = await createDynamicComposioAgent({
- *   composioApiKey: process.env.COMPOSIO_API_KEY!,
+ * const agent = await createDynamicOpenConnectorAgent({
+ *   adminToken: process.env.OPEN_CONNECTOR_ADMIN_TOKEN!,
+ *   baseUrl: 'https://open-connector.example.workers.dev',
  *   agent: {
  *     id: 'dynamic-agent',
  *     name: 'Dynamic Assistant',
@@ -229,16 +202,17 @@ export async function createComposioMastraAgent(config: ComposioMastraConfig) {
  *   },
  * });
  *
- * // Each request can have different userId/toolkits
+ * // Each request can have different userId/apps
  * const result = await agent.generate({
  *   userId: 'user-123',
- *   toolkits: ['GMAIL'],
+ *   apps: ['gmail'],
  *   prompt: 'Check emails',
  * });
  * ```
  */
-export async function createDynamicComposioAgent(config: {
-  composioApiKey: string;
+export async function createDynamicOpenConnectorAgent(config: {
+  adminToken: string;
+  baseUrl: string;
   agent: {
     id: string;
     name: string;
@@ -247,33 +221,24 @@ export async function createDynamicComposioAgent(config: {
     maxSteps?: number;
   };
 }) {
-  const composio = new Composio({
-    apiKey: config.composioApiKey,
-  });
-
   return {
     async generate(params: {
       userId: string;
-      toolkits: string[];
+      apps: string[];
       prompt: string;
       maxSteps?: number;
     }) {
-      // Create session for this user/toolkits
-      const session = await composio.toolsets.create({
-        userId: params.userId,
-        toolkits: params.toolkits,
-      });
+      const mcpUrl = `${config.baseUrl}/mcp/sse`;
 
       // Connect MCP client
       const mcp = new MCPClient({
-        id: `composio-${params.userId}`,
+        id: `open-connector-${params.userId}`,
         servers: {
-          composio: {
-            url: new URL(session.mcp.url),
+          openconnector: {
+            url: new URL(mcpUrl),
             requestInit: {
               headers: {
-                'x-api-key': config.composioApiKey,
-                ...session.mcp.headers,
+                Authorization: `Bearer ${config.adminToken}`,
               },
             },
           },
@@ -284,18 +249,18 @@ export async function createDynamicComposioAgent(config: {
         // Get toolsets for this request
         const toolsets = await mcp.listToolsets();
 
-        // Create agent with dynamic toolsets
+        // Create agent; toolsets are provided per-request at generate time
         const agent = new Agent({
           id: config.agent.id,
           name: config.agent.name,
           instructions: config.agent.instructions,
           model: config.agent.model,
-          toolsets,
         });
 
-        // Execute
+        // Execute with dynamic toolsets
         return await agent.generate(params.prompt, {
           maxSteps: params.maxSteps || config.agent.maxSteps || 5,
+          toolsets,
         });
       } finally {
         await mcp.disconnect();

package/src/tools/open-connector-mcp.ts

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview OpenConnector MCP Integration for AI SDK v5
+ *
+ * OpenConnector is a self-hosted Cloudflare Workers integration platform
+ * that provides OAuth-managed access to 100+ apps. This module creates
+ * MCP clients connected to OpenConnector's HTTP endpoints, fetches
+ * available tools, and passes them to AI SDK models.
+ *
+ * Architecture:
+ * 1. Connect to OpenConnector Worker URL at /mcp/sse
+ * 2. Authenticate with admin token via Authorization header
+ * 3. Fetch tools with client.tools()
+ * 4. Pass to streamText/generateText
+ *
+ * @see https://github.com/OpenSourceAGI/open-connector
+ */
+
+import { createMCPClient } from '@ai-sdk/mcp';
+import type { MCPClient } from '@ai-sdk/mcp';
+import type { ToolSet } from 'ai';
+
+/**
+ * Configuration for OpenConnector MCP session
+ */
+export interface OpenConnectorMCPConfig {
+  /** OpenConnector admin token (OPEN_CONNECTOR_ADMIN_TOKEN) */
+  adminToken: string;
+  /** Base URL of the deployed OpenConnector Worker */
+  baseUrl: string;
+  /** User ID to scope the session */
+  userId: string;
+  /** Apps to enable (e.g., ['gmail', 'notion', 'slack']) */
+  apps: string[];
+}
+
+/**
+ * OpenConnector MCP session wrapper
+ * Manages the lifecycle of MCP client connections to OpenConnector
+ */
+export class OpenConnectorMCPSession {
+  private client: MCPClient | null = null;
+
+  constructor(private config: OpenConnectorMCPConfig) {}
+
+  /**
+   * Get or create the MCP client connection
+   * Uses HTTP SSE transport as provided by OpenConnector
+   */
+  async getClient(): Promise<MCPClient> {
+    if (this.client) {
+      return this.client;
+    }
+
+    // Construct MCP endpoint URL
+    const mcpUrl = `${this.config.baseUrl}/mcp/sse`;
+
+    // Connect to OpenConnector MCP endpoint via HTTP
+    this.client = await createMCPClient({
+      transport: {
+        type: 'http',
+        url: mcpUrl,
+        headers: {
+          Authorization: `Bearer ${this.config.adminToken}`,
+        },
+        redirect: 'error',
+      },
+    });
+
+    return this.client;
+  }
+
+  /**
+   * Get all available tools from OpenConnector MCP
+   * These tools can be passed directly to streamText/generateText
+   *
+   * @returns Tools object compatible with AI SDK
+   */
+  async getTools(): Promise<ToolSet> {
+    const client = await this.getClient();
+    return (await client.tools()) as ToolSet;
+  }
+
+  /**
+   * Close the MCP connection
+   * Should be called after request completion or in finally block
+   */
+  async close() {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+    }
+  }
+
+  /**
+   * Health check for the OpenConnector Worker
+   */
+  async healthCheck(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.config.baseUrl}/health`, {
+        headers: {
+          Authorization: `Bearer ${this.config.adminToken}`,
+        },
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+}
+
+/**
+ * Helper function to create a one-shot OpenConnector MCP session
+ * For quick tool usage without managing session lifecycle
+ *
+ * @example
+ * ```ts
+ * const tools = await getOpenConnectorTools({
+ *   adminToken: process.env.OPEN_CONNECTOR_ADMIN_TOKEN!,
+ *   baseUrl: 'https://open-connector.example.workers.dev',
+ *   userId: 'user-123',
+ *   apps: ['gmail', 'slack'],
+ * });
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Check my unread emails',
+ *   tools,
+ * });
+ * ```
+ */
+export async function getOpenConnectorTools(
+  config: OpenConnectorMCPConfig
+): Promise<ToolSet> {
+  const session = new OpenConnectorMCPSession(config);
+  try {
+    return await session.getTools();
+  } finally {
+    await session.close();
+  }
+}
+
+/**
+ * Create a reusable OpenConnector MCP session
+ * Better for multiple requests with the same apps
+ *
+ * @example
+ * ```ts
+ * const session = await createOpenConnectorSession({
+ *   adminToken: process.env.OPEN_CONNECTOR_ADMIN_TOKEN!,
+ *   baseUrl: 'https://open-connector.example.workers.dev',
+ *   userId: 'user-123',
+ *   apps: ['gmail', 'notion'],
+ * });
+ *
+ * try {
+ *   const tools = await session.getTools();
+ *   const result = await streamText({ model, messages, tools });
+ * } finally {
+ *   await session.close();
+ * }
+ * ```
+ */
+export async function createOpenConnectorSession(
+  config: OpenConnectorMCPConfig
+): Promise<OpenConnectorMCPSession> {
+  const session = new OpenConnectorMCPSession(config);
+  // Pre-initialize the connection
+  await session.getClient();
+  return session;
+}