@contractspec/integration.providers-impls 3.0.0 → 3.2.0

package/dist/impls/composio-fallback-resolver.js

@@ -0,0 +1,580 @@
+// @bun
+var __require = import.meta.require;
+
+// src/impls/composio-types.ts
+var INTEGRATION_KEY_TO_TOOLKIT = {
+  payments: "stripe",
+  email: "gmail",
+  calendar: "googlecalendar",
+  sms: "twilio",
+  "messaging.slack": "slack",
+  "messaging.github": "github",
+  "messaging.discord": "discord",
+  "messaging.teams": "microsoft_teams",
+  "analytics.posthog": "posthog",
+  "project-management.linear": "linear",
+  "project-management.jira": "jira",
+  "project-management.notion": "notion",
+  "project-management.asana": "asana",
+  "project-management.trello": "trello",
+  "project-management.monday": "monday",
+  "storage.s3": "aws",
+  "storage.gcs": "google_cloud",
+  "storage.gdrive": "googledrive",
+  "storage.dropbox": "dropbox",
+  "storage.onedrive": "onedrive",
+  "crm.salesforce": "salesforce",
+  "crm.hubspot": "hubspot",
+  "crm.pipedrive": "pipedrive",
+  "database.supabase": "supabase",
+  "vectordb.supabase": "supabase",
+  "ai-llm": "openai"
+};
+var SESSION_TTL_MS = 30 * 60 * 1000;
+function isSessionExpired(session) {
+  return Date.now() - session.createdAt > SESSION_TTL_MS;
+}
+function resolveToolkit(integrationKey) {
+  if (INTEGRATION_KEY_TO_TOOLKIT[integrationKey]) {
+    return INTEGRATION_KEY_TO_TOOLKIT[integrationKey];
+  }
+  for (const [prefix, toolkit] of Object.entries(INTEGRATION_KEY_TO_TOOLKIT)) {
+    if (integrationKey.startsWith(prefix)) {
+      return toolkit;
+    }
+  }
+  const parts = integrationKey.split(".");
+  const last = parts[parts.length - 1];
+  return parts.length > 1 && last ? last : integrationKey;
+}
+
+// src/impls/composio-mcp.ts
+class ComposioMcpProvider {
+  sessions = new Map;
+  config;
+  composioInstance;
+  constructor(config) {
+    this.config = config;
+  }
+  async executeTool(toolName, args) {
+    const userId = args._userId ?? "default";
+    const session = await this.getOrCreateSession(userId);
+    try {
+      const response = await fetch(session.mcpUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...session.mcpHeaders
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: crypto.randomUUID(),
+          method: "tools/call",
+          params: { name: toolName, arguments: args }
+        })
+      });
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `Composio MCP call failed: ${response.status} ${response.statusText}`
+        };
+      }
+      const result = await response.json();
+      if (result.error) {
+        return {
+          success: false,
+          error: result.error.message ?? "Unknown MCP error"
+        };
+      }
+      return { success: true, data: result.result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async searchTools(query) {
+    const session = await this.getOrCreateSession("default");
+    try {
+      const response = await fetch(session.mcpUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...session.mcpHeaders
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: crypto.randomUUID(),
+          method: "tools/list",
+          params: {}
+        })
+      });
+      if (!response.ok)
+        return [];
+      const result = await response.json();
+      const tools = result.result?.tools ?? [];
+      return tools.filter((t) => t.name.toLowerCase().includes(query.toLowerCase()) || (t.description ?? "").toLowerCase().includes(query.toLowerCase())).map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        toolkit: resolveToolkit(t.name.split("_")[0]?.toLowerCase() ?? ""),
+        parameters: t.inputSchema ?? {}
+      }));
+    } catch {
+      return [];
+    }
+  }
+  getMcpConfig(userId) {
+    const session = this.sessions.get(userId);
+    if (!session || isSessionExpired(session))
+      return;
+    return { url: session.mcpUrl, headers: session.mcpHeaders };
+  }
+  async getOrCreateSession(userId) {
+    const existing = this.sessions.get(userId);
+    if (existing && !isSessionExpired(existing)) {
+      return existing;
+    }
+    const client = await this.getClient();
+    const entity = await client.getEntity(userId);
+    const mcpUrl = entity.getMcpUrl();
+    const mcpHeaders = entity.getMcpHeaders();
+    const session = {
+      userId,
+      mcpUrl,
+      mcpHeaders,
+      createdAt: Date.now()
+    };
+    this.sessions.set(userId, session);
+    return session;
+  }
+  async getClient() {
+    if (this.composioInstance)
+      return this.composioInstance;
+    const { Composio } = await import("@composio/core");
+    this.composioInstance = new Composio({
+      apiKey: this.config.apiKey,
+      ...this.config.baseUrl ? { baseUrl: this.config.baseUrl } : {}
+    });
+    return this.composioInstance;
+  }
+}
+
+// src/impls/composio-sdk.ts
+class ComposioSdkProvider {
+  config;
+  client;
+  constructor(config) {
+    this.config = config;
+  }
+  async executeTool(toolName, args) {
+    const client = await this.getClient();
+    const userId = args._userId ?? "default";
+    try {
+      const entity = await client.getEntity(userId);
+      const result = await entity.execute(toolName, args);
+      return { success: true, data: result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async searchTools(query) {
+    const client = await this.getClient();
+    try {
+      const tools = await client.actions.list({ query, limit: 20 });
+      return tools.map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        toolkit: t.appName ?? "",
+        parameters: t.parameters ?? {}
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getConnectedAccounts(userId) {
+    const client = await this.getClient();
+    try {
+      const entity = await client.getEntity(userId);
+      const connections = await entity.getConnections();
+      return connections.map((c) => ({
+        id: c.id,
+        appName: c.appName,
+        status: c.status
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getMcpConfig(userId) {
+    const client = await this.getClient();
+    try {
+      const entity = await client.getEntity(userId);
+      return {
+        url: entity.getMcpUrl(),
+        headers: entity.getMcpHeaders()
+      };
+    } catch {
+      return;
+    }
+  }
+  async getClient() {
+    if (this.client)
+      return this.client;
+    const { Composio } = await import("@composio/core");
+    this.client = new Composio({
+      apiKey: this.config.apiKey,
+      ...this.config.baseUrl ? { baseUrl: this.config.baseUrl } : {}
+    });
+    return this.client;
+  }
+}
+
+// src/impls/composio-proxies.ts
+function composioToolName(toolkit, action) {
+  return `${toolkit.toUpperCase()}_${action.toUpperCase()}`;
+}
+function unwrapResult(result, fallback) {
+  if (!result.success) {
+    throw new Error(`Composio tool execution failed: ${result.error}`);
+  }
+  return result.data ?? fallback;
+}
+
+class ComposioMessagingProxy {
+  proxy;
+  toolkit;
+  constructor(proxy, toolkit) {
+    this.proxy = proxy;
+    this.toolkit = toolkit;
+  }
+  async sendMessage(input) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "SEND_MESSAGE"), {
+      channel: input.channelId,
+      thread_ts: input.threadId,
+      text: input.text,
+      recipient: input.recipientId
+    });
+    const data = unwrapResult(result, {});
+    return {
+      id: String(data.id ?? data.ts ?? crypto.randomUUID()),
+      providerMessageId: data.ts,
+      status: "sent",
+      sentAt: new Date
+    };
+  }
+  async updateMessage(messageId, input) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "UPDATE_MESSAGE"), {
+      message_id: messageId,
+      channel: input.channelId,
+      text: input.text
+    });
+    const data = unwrapResult(result, {});
+    return {
+      id: String(data.id ?? messageId),
+      status: "sent",
+      sentAt: new Date
+    };
+  }
+}
+
+class ComposioEmailProxy {
+  proxy;
+  toolkit;
+  constructor(proxy, toolkit) {
+    this.proxy = proxy;
+    this.toolkit = toolkit;
+  }
+  async sendEmail(message) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "SEND_EMAIL"), {
+      to: message.to.map((a) => a.email).join(","),
+      cc: message.cc?.map((a) => a.email).join(","),
+      bcc: message.bcc?.map((a) => a.email).join(","),
+      subject: message.subject,
+      body: message.htmlBody ?? message.textBody ?? "",
+      from: message.from.email
+    });
+    const data = unwrapResult(result, {});
+    return {
+      id: String(data.id ?? data.messageId ?? crypto.randomUUID()),
+      providerMessageId: data.messageId,
+      queuedAt: new Date
+    };
+  }
+}
+
+class ComposioPaymentsProxy {
+  proxy;
+  toolkit;
+  constructor(proxy, toolkit) {
+    this.proxy = proxy;
+    this.toolkit = toolkit;
+  }
+  async createCustomer(input) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "CREATE_CUSTOMER"), { email: input.email, name: input.name, description: input.description });
+    const data = unwrapResult(result, {});
+    return {
+      id: String(data.id ?? crypto.randomUUID()),
+      email: data.email ?? input.email,
+      name: data.name ?? input.name
+    };
+  }
+  async getCustomer(customerId) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "GET_CUSTOMER"), { customer_id: customerId });
+    if (!result.success)
+      return null;
+    const data = result.data;
+    if (!data)
+      return null;
+    return {
+      id: String(data.id ?? customerId),
+      email: data.email,
+      name: data.name
+    };
+  }
+  async createPaymentIntent(input) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "CREATE_PAYMENT_INTENT"), {
+      amount: input.amount.amount,
+      currency: input.amount.currency,
+      customer_id: input.customerId,
+      description: input.description
+    });
+    const data = unwrapResult(result, {});
+    return {
+      id: String(data.id ?? crypto.randomUUID()),
+      amount: input.amount,
+      status: data.status ?? "requires_payment_method",
+      customerId: input.customerId,
+      clientSecret: data.client_secret
+    };
+  }
+  async capturePayment(paymentIntentId, input) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "CAPTURE_PAYMENT"), { payment_intent_id: paymentIntentId, amount: input?.amount?.amount });
+    const data = unwrapResult(result, {});
+    return {
+      id: paymentIntentId,
+      amount: input?.amount ?? { amount: 0, currency: "usd" },
+      status: data.status ?? "succeeded"
+    };
+  }
+  async cancelPaymentIntent(paymentIntentId) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "CANCEL_PAYMENT_INTENT"), { payment_intent_id: paymentIntentId });
+    const data = unwrapResult(result, {});
+    return {
+      id: paymentIntentId,
+      amount: { amount: 0, currency: "usd" },
+      status: data.status ?? "canceled"
+    };
+  }
+  async refundPayment(input) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "REFUND_PAYMENT"), {
+      payment_intent_id: input.paymentIntentId,
+      amount: input.amount?.amount,
+      reason: input.reason
+    });
+    const data = unwrapResult(result, {});
+    return {
+      id: String(data.id ?? crypto.randomUUID()),
+      paymentIntentId: input.paymentIntentId,
+      amount: input.amount ?? { amount: 0, currency: "usd" },
+      status: "succeeded"
+    };
+  }
+  async listInvoices(_query) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "LIST_INVOICES"), { customer_id: _query?.customerId, limit: _query?.limit });
+    if (!result.success)
+      return [];
+    const items = result.data ?? [];
+    return items.map((i) => ({
+      id: String(i.id),
+      status: i.status ?? "open",
+      amountDue: {
+        amount: Number(i.amount_due ?? 0),
+        currency: String(i.currency ?? "usd")
+      }
+    }));
+  }
+  async listTransactions(_query) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "LIST_TRANSACTIONS"), { customer_id: _query?.customerId, limit: _query?.limit });
+    if (!result.success)
+      return [];
+    const items = result.data ?? [];
+    return items.map((i) => ({
+      id: String(i.id),
+      amount: {
+        amount: Number(i.amount ?? 0),
+        currency: String(i.currency ?? "usd")
+      },
+      type: "capture",
+      status: "succeeded",
+      createdAt: new Date
+    }));
+  }
+}
+
+class ComposioProjectManagementProxy {
+  proxy;
+  toolkit;
+  constructor(proxy, toolkit) {
+    this.proxy = proxy;
+    this.toolkit = toolkit;
+  }
+  async createWorkItem(input) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "CREATE_ISSUE"), {
+      title: input.title,
+      description: input.description,
+      priority: input.priority,
+      assignee_id: input.assigneeId,
+      project_id: input.projectId,
+      labels: input.tags
+    });
+    const data = unwrapResult(result, {});
+    return {
+      id: String(data.id ?? data.key ?? crypto.randomUUID()),
+      title: input.title,
+      url: data.url,
+      status: data.status,
+      priority: input.priority,
+      tags: input.tags,
+      projectId: input.projectId
+    };
+  }
+  async createWorkItems(items) {
+    return Promise.all(items.map((item) => this.createWorkItem(item)));
+  }
+}
+
+class ComposioCalendarProxy {
+  proxy;
+  toolkit;
+  constructor(proxy, toolkit) {
+    this.proxy = proxy;
+    this.toolkit = toolkit;
+  }
+  async listEvents(query) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "LIST_EVENTS"), {
+      calendar_id: query.calendarId,
+      time_min: query.timeMin?.toISOString(),
+      time_max: query.timeMax?.toISOString(),
+      max_results: query.maxResults
+    });
+    if (!result.success)
+      return { events: [] };
+    const items = result.data ?? [];
+    return {
+      events: items.map((e) => ({
+        id: String(e.id),
+        calendarId: query.calendarId,
+        title: String(e.summary ?? e.title ?? ""),
+        start: new Date(String(e.start ?? Date.now())),
+        end: new Date(String(e.end ?? Date.now()))
+      }))
+    };
+  }
+  async createEvent(input) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "CREATE_EVENT"), {
+      calendar_id: input.calendarId,
+      summary: input.title,
+      description: input.description,
+      location: input.location,
+      start: input.start.toISOString(),
+      end: input.end.toISOString(),
+      attendees: input.attendees?.map((a) => a.email)
+    });
+    const data = unwrapResult(result, {});
+    return {
+      id: String(data.id ?? crypto.randomUUID()),
+      calendarId: input.calendarId,
+      title: input.title,
+      start: input.start,
+      end: input.end
+    };
+  }
+  async updateEvent(calendarId, eventId, input) {
+    const result = await this.proxy.executeTool(composioToolName(this.toolkit, "UPDATE_EVENT"), {
+      calendar_id: calendarId,
+      event_id: eventId,
+      summary: input.title,
+      description: input.description,
+      start: input.start?.toISOString(),
+      end: input.end?.toISOString()
+    });
+    const data = unwrapResult(result, {});
+    return {
+      id: eventId,
+      calendarId,
+      title: String(data.summary ?? input.title ?? ""),
+      start: input.start ?? new Date,
+      end: input.end ?? new Date
+    };
+  }
+  async deleteEvent(calendarId, eventId) {
+    await this.proxy.executeTool(composioToolName(this.toolkit, "DELETE_EVENT"), { calendar_id: calendarId, event_id: eventId });
+  }
+}
+
+class ComposioGenericProxy {
+  proxy;
+  toolkit;
+  constructor(proxy, toolkit) {
+    this.proxy = proxy;
+    this.toolkit = toolkit;
+  }
+  async executeTool(action, args) {
+    return this.proxy.executeTool(composioToolName(this.toolkit, action), args);
+  }
+  async searchTools(query) {
+    return this.proxy.searchTools(query);
+  }
+  getToolkit() {
+    return this.toolkit;
+  }
+}
+
+// src/impls/composio-fallback-resolver.ts
+class ComposioFallbackResolver {
+  mcpProvider;
+  sdkProvider;
+  preferredTransport;
+  constructor(config) {
+    this.mcpProvider = new ComposioMcpProvider(config);
+    this.sdkProvider = new ComposioSdkProvider(config);
+    this.preferredTransport = config.preferredTransport;
+  }
+  canHandle(_integrationKey) {
+    return true;
+  }
+  createMessagingProxy(context) {
+    const toolkit = resolveToolkit(context.spec.meta.key);
+    return new ComposioMessagingProxy(this.getProxy(), toolkit);
+  }
+  createEmailProxy(context) {
+    const toolkit = resolveToolkit(context.spec.meta.key);
+    return new ComposioEmailProxy(this.getProxy(), toolkit);
+  }
+  createPaymentsProxy(context) {
+    const toolkit = resolveToolkit(context.spec.meta.key);
+    return new ComposioPaymentsProxy(this.getProxy(), toolkit);
+  }
+  createProjectManagementProxy(context) {
+    const toolkit = resolveToolkit(context.spec.meta.key);
+    return new ComposioProjectManagementProxy(this.getProxy(), toolkit);
+  }
+  createCalendarProxy(context) {
+    const toolkit = resolveToolkit(context.spec.meta.key);
+    return new ComposioCalendarProxy(this.getProxy(), toolkit);
+  }
+  createGenericProxy(context) {
+    const toolkit = resolveToolkit(context.spec.meta.key);
+    return new ComposioGenericProxy(this.getProxy(), toolkit);
+  }
+  getProxy() {
+    return this.preferredTransport === "sdk" ? this.sdkProvider : this.mcpProvider;
+  }
+}
+export {
+  ComposioFallbackResolver
+};

package/dist/impls/composio-mcp.d.ts

@@ -0,0 +1,22 @@
+import type { ComposioConfig, ComposioToolProxy, ComposioToolResult, ComposioToolDescriptor } from './composio-types';
+/**
+ * Composio MCP transport provider.
+ *
+ * Creates Composio sessions and exposes tools via the MCP protocol,
+ * leveraging the existing MCP client infrastructure in lib.ai-agent.
+ * Sessions are cached per userId with a 30-minute TTL.
+ */
+export declare class ComposioMcpProvider implements ComposioToolProxy {
+    private readonly sessions;
+    private readonly config;
+    private composioInstance;
+    constructor(config: ComposioConfig);
+    executeTool(toolName: string, args: Record<string, unknown>): Promise<ComposioToolResult>;
+    searchTools(query: string): Promise<ComposioToolDescriptor[]>;
+    getMcpConfig(userId: string): {
+        url: string;
+        headers: Record<string, string>;
+    } | undefined;
+    private getOrCreateSession;
+    private getClient;
+}