@elevasis/core 0.7.1 → 0.8.2

package/src/execution/engine/tools/integration/server/adapters/gmail/gmail-adapter.ts

@@ -1,210 +1,210 @@
-import type { gmail_v1 } from '@googleapis/gmail'
-import type { BaseIntegrationAdapter } from '../../../base-integration-adapter'
-import { ToolingError } from '../../../../types'
-import type { ExecutionContext } from '../../../../../base/types'
-
-/**
- * Gmail credentials format
- * Stored in credentials table, encrypted
- */
-interface GmailCredentials {
-  type: 'oauth2' | 'service-account'
-  // OAuth2 credentials
-  clientId?: string
-  clientSecret?: string
-  refreshToken?: string
-  // Service account credentials
-  serviceAccountKey?: Record<string, unknown>
-}
-
-/**
- * Send email parameters
- */
-interface SendEmailParams {
-  to: string
-  subject: string
-  body: string
-  cc?: string
-  from?: string
-}
-
-/**
- * Send email result
- */
-interface SendEmailResult {
-  messageId: string
-  threadId: string
-}
-
-/**
- * Gmail adapter for sending emails via Gmail API
- *
- * Supported methods:
- * - sendEmail: Send email message
- *
- * @example
- * const adapter = new GmailAdapter()
- * const result = await adapter.call('sendEmail', {
- *   to: 'user@example.com',
- *   subject: 'Hello',
- *   body: 'This is a test email'
- * }, {
- *   type: 'oauth2',
- *   clientId: '...',
- *   clientSecret: '...',
- *   refreshToken: '...'
- * })
- */
-export class GmailAdapter implements BaseIntegrationAdapter {
-  readonly name = 'gmail'
-
-  /**
-   * Call Gmail API method
-   * @param method - Method name (e.g., 'sendEmail')
-   * @param params - Method parameters
-   * @param credentials - OAuth2 or service account credentials
-   * @param context - Execution context for logging and tracing
-   */
-  async call(
-    method: string,
-    params: unknown,
-    credentials: Record<string, unknown>,
-    context?: ExecutionContext
-  ): Promise<unknown> {
-    // Validate credentials format
-    if (!this.validateCredentials(credentials)) {
-      throw new ToolingError(
-        'credentials_invalid',
-        'Invalid Gmail credentials',
-        { integration: 'gmail', method }
-      )
-    }
-    const gmailCreds = credentials as unknown as GmailCredentials
-
-    // Create authenticated Gmail client
-    const gmail = await this.createClient(gmailCreds)
-
-    // Route to method handler
-    switch (method) {
-      case 'sendEmail':
-        return this.sendEmail(gmail, params as SendEmailParams, context)
-      default:
-        throw new ToolingError(
-          'method_not_found',
-          `Unknown method: ${method}`,
-          { integration: 'gmail', method }
-        )
-    }
-  }
-
-  /**
-   * Create authenticated Gmail client (lazy loads @googleapis/gmail SDK)
-   */
-  private async createClient(creds: GmailCredentials): Promise<gmail_v1.Gmail> {
-    const { gmail } = await import('@googleapis/gmail')
-    const { OAuth2Client, GoogleAuth } = await import('googleapis-common')
-
-    if (creds.type === 'oauth2') {
-      const auth = new OAuth2Client(
-        creds.clientId,
-        creds.clientSecret
-      )
-      auth.setCredentials({ refresh_token: creds.refreshToken })
-
-      return gmail({ version: 'v1', auth })
-    } else {
-      // Service account (for workspace-wide access)
-      const auth = new GoogleAuth({
-        credentials: creds.serviceAccountKey,
-        scopes: ['https://www.googleapis.com/auth/gmail.send']
-      })
-
-      return gmail({ version: 'v1', auth: await auth.getClient() as any })
-    }
-  }
-
-  /**
-   * Send email via Gmail API
-   */
-  private async sendEmail(
-    gmail: gmail_v1.Gmail,
-    params: SendEmailParams,
-    context?: ExecutionContext
-  ): Promise<SendEmailResult> {
-    // Validate params
-    if (!params.to || !params.subject || !params.body) {
-      throw new ToolingError(
-        'validation_error',
-        'Missing required fields: to, subject, body',
-        { params }
-      )
-    }
-
-    // Build RFC 2822 formatted message
-    const messageParts = [
-      `To: ${params.to}`,
-      `Subject: ${params.subject}`,
-      params.cc ? `Cc: ${params.cc}` : '',
-      'Content-Type: text/html; charset=utf-8',
-      '',
-      params.body
-    ]
-    const message = messageParts.filter(Boolean).join('\n')
-
-    // Base64 encode (URL-safe)
-    const encodedMessage = Buffer.from(message)
-      .toString('base64')
-      .replace(/\+/g, '-')
-      .replace(/\//g, '_')
-      .replace(/=+$/, '')
-
-    try {
-      const response = await gmail.users.messages.send({
-        userId: 'me',
-        requestBody: {
-          raw: encodedMessage
-        }
-      })
-
-      if (context?.logger) {
-        console.log('[GmailAdapter] Email sent:', {
-          organizationId: context.organizationId,
-          executionId: context.executionId,
-          to: params.to,
-          subject: params.subject,
-          messageId: response.data.id,
-          threadId: response.data.threadId
-        })
-      }
-
-      return {
-        messageId: response.data.id!,
-        threadId: response.data.threadId!
-      }
-    } catch (error: any) {
-      throw new ToolingError(
-        'api_error',
-        `Gmail API error: ${error.message}`,
-        { statusCode: error.code, details: error }
-      )
-    }
-  }
-
-  /**
-   * Validate credentials structure
-   * Required by BaseIntegrationAdapter interface
-   */
-  validateCredentials(creds: Record<string, unknown>): boolean {
-    if (!creds.type) {
-      return false
-    }
-
-    if (creds.type === 'oauth2') {
-      return !!(creds.clientId && creds.clientSecret && creds.refreshToken)
-    } else if (creds.type === 'service-account') {
-      return !!creds.serviceAccountKey
-    }
-
-    return false
-  }
-}
+import type { gmail_v1 } from '@googleapis/gmail'
+import type { BaseIntegrationAdapter } from '../../../base-integration-adapter'
+import { ToolingError } from '../../../../types'
+import type { ExecutionContext } from '../../../../../base/types'
+
+/**
+ * Gmail credentials format
+ * Stored in credentials table, encrypted
+ */
+interface GmailCredentials {
+  type: 'oauth2' | 'service-account'
+  // OAuth2 credentials
+  clientId?: string
+  clientSecret?: string
+  refreshToken?: string
+  // Service account credentials
+  serviceAccountKey?: Record<string, unknown>
+}
+
+/**
+ * Send email parameters
+ */
+interface SendEmailParams {
+  to: string
+  subject: string
+  body: string
+  cc?: string
+  from?: string
+}
+
+/**
+ * Send email result
+ */
+interface SendEmailResult {
+  messageId: string
+  threadId: string
+}
+
+/**
+ * Gmail adapter for sending emails via Gmail API
+ *
+ * Supported methods:
+ * - sendEmail: Send email message
+ *
+ * @example
+ * const adapter = new GmailAdapter()
+ * const result = await adapter.call('sendEmail', {
+ *   to: 'user@example.com',
+ *   subject: 'Hello',
+ *   body: 'This is a test email'
+ * }, {
+ *   type: 'oauth2',
+ *   clientId: '...',
+ *   clientSecret: '...',
+ *   refreshToken: '...'
+ * })
+ */
+export class GmailAdapter implements BaseIntegrationAdapter {
+  readonly name = 'gmail'
+
+  /**
+   * Call Gmail API method
+   * @param method - Method name (e.g., 'sendEmail')
+   * @param params - Method parameters
+   * @param credentials - OAuth2 or service account credentials
+   * @param context - Execution context for logging and tracing
+   */
+  async call(
+    method: string,
+    params: unknown,
+    credentials: Record<string, unknown>,
+    context?: ExecutionContext
+  ): Promise<unknown> {
+    // Validate credentials format
+    if (!this.validateCredentials(credentials)) {
+      throw new ToolingError(
+        'credentials_invalid',
+        'Invalid Gmail credentials',
+        { integration: 'gmail', method }
+      )
+    }
+    const gmailCreds = credentials as unknown as GmailCredentials
+
+    // Create authenticated Gmail client
+    const gmail = await this.createClient(gmailCreds)
+
+    // Route to method handler
+    switch (method) {
+      case 'sendEmail':
+        return this.sendEmail(gmail, params as SendEmailParams, context)
+      default:
+        throw new ToolingError(
+          'method_not_found',
+          `Unknown method: ${method}`,
+          { integration: 'gmail', method }
+        )
+    }
+  }
+
+  /**
+   * Create authenticated Gmail client (lazy loads @googleapis/gmail SDK)
+   */
+  private async createClient(creds: GmailCredentials): Promise<gmail_v1.Gmail> {
+    const { gmail } = await import('@googleapis/gmail')
+    const { OAuth2Client, GoogleAuth } = await import('googleapis-common')
+
+    if (creds.type === 'oauth2') {
+      const auth = new OAuth2Client(
+        creds.clientId,
+        creds.clientSecret
+      )
+      auth.setCredentials({ refresh_token: creds.refreshToken })
+
+      return gmail({ version: 'v1', auth })
+    } else {
+      // Service account (for workspace-wide access)
+      const auth = new GoogleAuth({
+        credentials: creds.serviceAccountKey,
+        scopes: ['https://www.googleapis.com/auth/gmail.send']
+      })
+
+      return gmail({ version: 'v1', auth: await auth.getClient() as any })
+    }
+  }
+
+  /**
+   * Send email via Gmail API
+   */
+  private async sendEmail(
+    gmail: gmail_v1.Gmail,
+    params: SendEmailParams,
+    context?: ExecutionContext
+  ): Promise<SendEmailResult> {
+    // Validate params
+    if (!params.to || !params.subject || !params.body) {
+      throw new ToolingError(
+        'validation_error',
+        'Missing required fields: to, subject, body',
+        { params }
+      )
+    }
+
+    // Build RFC 2822 formatted message
+    const messageParts = [
+      `To: ${params.to}`,
+      `Subject: ${params.subject}`,
+      params.cc ? `Cc: ${params.cc}` : '',
+      'Content-Type: text/html; charset=utf-8',
+      '',
+      params.body
+    ]
+    const message = messageParts.filter(Boolean).join('\n')
+
+    // Base64 encode (URL-safe)
+    const encodedMessage = Buffer.from(message)
+      .toString('base64')
+      .replace(/\+/g, '-')
+      .replace(/\//g, '_')
+      .replace(/=+$/, '')
+
+    try {
+      const response = await gmail.users.messages.send({
+        userId: 'me',
+        requestBody: {
+          raw: encodedMessage
+        }
+      })
+
+      if (context?.logger) {
+        console.log('[GmailAdapter] Email sent:', {
+          organizationId: context.organizationId,
+          executionId: context.executionId,
+          to: params.to,
+          subject: params.subject,
+          messageId: response.data.id,
+          threadId: response.data.threadId
+        })
+      }
+
+      return {
+        messageId: response.data.id!,
+        threadId: response.data.threadId!
+      }
+    } catch (error: any) {
+      throw new ToolingError(
+        'api_error',
+        `Gmail API error: ${error.message}`,
+        { statusCode: error.code, details: error }
+      )
+    }
+  }
+
+  /**
+   * Validate credentials structure
+   * Required by BaseIntegrationAdapter interface
+   */
+  validateCredentials(creds: Record<string, unknown>): boolean {
+    if (!creds.type) {
+      return false
+    }
+
+    if (creds.type === 'oauth2') {
+      return !!(creds.clientId && creds.clientSecret && creds.refreshToken)
+    } else if (creds.type === 'service-account') {
+      return !!creds.serviceAccountKey
+    }
+
+    return false
+  }
+}

package/src/execution/engine/tools/integration/server/adapters/gmail/gmail-tools.ts

@@ -1,104 +1,104 @@
-import { z } from 'zod'
-import { createIntegrationTool } from '../../../tool'
-import type { Tool } from '../../../../types'
-
-/**
- * Create Gmail send email tool
- *
- * Creates a tool that sends emails via Gmail API using organization credentials.
- * Supports both OAuth2 and service account authentication, as well as mock credentials for testing.
- *
- * @param credentialName - Name of credential in credentials table
- * @returns Tool that sends email via Gmail
- *
- * @example
- * // Create tool for support email account
- * const sendEmail = createGmailSendEmailTool('support-gmail')
- *
- * // In agent definition:
- * export const emailAgentDefinition: AgentDefinition = {
- *   config: {
- *     resourceId: 'email-agent',
- *     name: 'Email Agent',
- *     description: 'Sends emails on behalf of users'
- *   },
- *   tools: [sendEmail],
- *   // ...
- * }
- *
- * @example
- * // Create multiple tools for different accounts
- * const sendSupportEmail = createGmailSendEmailTool('support-gmail')
- * const sendSalesEmail = createGmailSendEmailTool('sales-gmail')
- *
- * // Use in agent with multiple email accounts
- * tools: [sendSupportEmail, sendSalesEmail]
- */
-export function createGmailSendEmailTool(credentialName: string): Tool {
-  return createIntegrationTool({
-    name: 'gmail_sendEmail',
-    description: 'Send an email via Gmail API',
-
-    inputSchema: z.object({
-      to: z.string().email().describe('Recipient email address'),
-      subject: z.string().describe('Email subject line'),
-      body: z.string().describe('Email body (HTML supported)'),
-      cc: z.string().email().optional().describe('Optional CC recipient'),
-      from: z.string().optional().describe('Optional sender display name (defaults to "me")')
-    }),
-
-    outputSchema: z.object({
-      messageId: z.string().describe('Gmail message ID'),
-      threadId: z.string().describe('Gmail thread ID')
-    }),
-
-    integration: 'gmail' as const,
-    method: 'sendEmail' as const,
-    credentialName: credentialName
-  })
-}
-
-/**
- * Create Gmail send email tool with custom name
- *
- * Allows creating multiple Gmail tools with different names for the same organization.
- * Useful when you want to distinguish between different email accounts in tool naming.
- *
- * @param toolName - Custom name for the tool (e.g., 'send_support_email')
- * @param credentialName - Name of credential in credentials table
- * @returns Tool that sends email via Gmail
- *
- * @example
- * const sendSupportEmail = createGmailSendEmailToolNamed(
- *   'send_support_email',
- *   'support-gmail'
- * )
- *
- * const sendSalesEmail = createGmailSendEmailToolNamed(
- *   'send_sales_email',
- *   'sales-gmail'
- * )
- */
-export function createGmailSendEmailToolNamed(toolName: string, credentialName: string): Tool {
-  return createIntegrationTool({
-    name: toolName,
-    description: `Send an email via Gmail API using ${credentialName} credentials`,
-
-    inputSchema: z.object({
-      to: z.string().email().describe('Recipient email address'),
-      subject: z.string().describe('Email subject line'),
-      body: z.string().describe('Email body (HTML supported)'),
-      cc: z.string().email().optional().describe('Optional CC recipient'),
-      from: z.string().optional().describe('Optional sender display name (defaults to "me")')
-    }),
-
-    outputSchema: z.object({
-      messageId: z.string().describe('Gmail message ID'),
-      threadId: z.string().describe('Gmail thread ID')
-    }),
-
-    integration: 'gmail' as const,
-    method: 'sendEmail' as const,
-    credentialName: credentialName
-  })
-}
+import { z } from 'zod'
+import { createIntegrationTool } from '../../../tool'
+import type { Tool } from '../../../../types'
+
+/**
+ * Create Gmail send email tool
+ *
+ * Creates a tool that sends emails via Gmail API using organization credentials.
+ * Supports both OAuth2 and service account authentication, as well as mock credentials for testing.
+ *
+ * @param credentialName - Name of credential in credentials table
+ * @returns Tool that sends email via Gmail
+ *
+ * @example
+ * // Create tool for support email account
+ * const sendEmail = createGmailSendEmailTool('support-gmail')
+ *
+ * // In agent definition:
+ * export const emailAgentDefinition: AgentDefinition = {
+ *   config: {
+ *     resourceId: 'email-agent',
+ *     name: 'Email Agent',
+ *     description: 'Sends emails on behalf of users'
+ *   },
+ *   tools: [sendEmail],
+ *   // ...
+ * }
+ *
+ * @example
+ * // Create multiple tools for different accounts
+ * const sendSupportEmail = createGmailSendEmailTool('support-gmail')
+ * const sendSalesEmail = createGmailSendEmailTool('sales-gmail')
+ *
+ * // Use in agent with multiple email accounts
+ * tools: [sendSupportEmail, sendSalesEmail]
+ */
+export function createGmailSendEmailTool(credentialName: string): Tool {
+  return createIntegrationTool({
+    name: 'gmail_sendEmail',
+    description: 'Send an email via Gmail API',
+
+    inputSchema: z.object({
+      to: z.string().email().describe('Recipient email address'),
+      subject: z.string().describe('Email subject line'),
+      body: z.string().describe('Email body (HTML supported)'),
+      cc: z.string().email().optional().describe('Optional CC recipient'),
+      from: z.string().optional().describe('Optional sender display name (defaults to "me")')
+    }),
+
+    outputSchema: z.object({
+      messageId: z.string().describe('Gmail message ID'),
+      threadId: z.string().describe('Gmail thread ID')
+    }),
+
+    integration: 'gmail' as const,
+    method: 'sendEmail' as const,
+    credentialName: credentialName
+  })
+}
+
+/**
+ * Create Gmail send email tool with custom name
+ *
+ * Allows creating multiple Gmail tools with different names for the same organization.
+ * Useful when you want to distinguish between different email accounts in tool naming.
+ *
+ * @param toolName - Custom name for the tool (e.g., 'send_support_email')
+ * @param credentialName - Name of credential in credentials table
+ * @returns Tool that sends email via Gmail
+ *
+ * @example
+ * const sendSupportEmail = createGmailSendEmailToolNamed(
+ *   'send_support_email',
+ *   'support-gmail'
+ * )
+ *
+ * const sendSalesEmail = createGmailSendEmailToolNamed(
+ *   'send_sales_email',
+ *   'sales-gmail'
+ * )
+ */
+export function createGmailSendEmailToolNamed(toolName: string, credentialName: string): Tool {
+  return createIntegrationTool({
+    name: toolName,
+    description: `Send an email via Gmail API using ${credentialName} credentials`,
+
+    inputSchema: z.object({
+      to: z.string().email().describe('Recipient email address'),
+      subject: z.string().describe('Email subject line'),
+      body: z.string().describe('Email body (HTML supported)'),
+      cc: z.string().email().optional().describe('Optional CC recipient'),
+      from: z.string().optional().describe('Optional sender display name (defaults to "me")')
+    }),
+
+    outputSchema: z.object({
+      messageId: z.string().describe('Gmail message ID'),
+      threadId: z.string().describe('Gmail thread ID')
+    }),
+
+    integration: 'gmail' as const,
+    method: 'sendEmail' as const,
+    credentialName: credentialName
+  })
+}