@elevasis/core 0.7.1 → 0.8.2

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

@@ -1,102 +1,102 @@
-import { z } from 'zod'
-import type { Tool } from '../../../../types'
-import { createIntegrationTool } from '../../../tool'
-
-/**
- * Create a tool that verifies email addresses via MillionVerifier
- *
- * @param credentialName - Name of the MillionVerifier credential to use
- * @returns Tool instance
- *
- * @example
- * ```typescript
- * const tool = createMillionVerifierVerifyEmailTool('elevasis-millionverifier')
- * const result = await tool.execute({
- *   email: 'john@example.com'
- * }, context)
- * // result.result: 'ok' | 'catch_all' | 'unknown' | 'error' | 'disposable' | 'invalid'
- * // result.quality: 'good' | 'bad' | 'risky' | ''
- * ```
- */
-export function createMillionVerifierVerifyEmailTool(credentialName: string): Tool {
-  return createIntegrationTool({
-    name: 'millionverifier_verify_email',
-    description: `Verify email address deliverability using MillionVerifier.
-
-Use this tool to validate if an email address is real and can receive emails before
-adding it to a campaign. MillionVerifier is highly accurate and fast (160 req/s).
-
-Result codes:
-- ok (1): Email is valid and deliverable
-- catch_all (2): Domain accepts all email (cannot confirm individual mailbox) - FREE
-- unknown (3): Result could not be determined - FREE
-- error (4): Verification error
-- disposable (5): Disposable/temporary email address
-- invalid (6): Email address is invalid
-
-Quality signals:
-- good: Safe to send
-- risky: May bounce or flag spam filter
-- bad: Do not send
-
-Credits are only deducted for ok, invalid, and disposable results.
-
-Returns full verification details including free/role detection and suggested correction.`,
-    inputSchema: z.object({
-      email: z.string().email().describe('Email address to verify')
-    }),
-    outputSchema: z.object({
-      email: z.string().describe('Verified email address'),
-      quality: z.enum(['', 'good', 'bad', 'risky']).describe('Quality signal for sending decision'),
-      result: z.enum(['ok', 'catch_all', 'unknown', 'error', 'disposable', 'invalid']).describe('Verification result'),
-      resultCode: z
-        .number()
-        .describe('Numeric result code (1=ok, 2=catch_all, 3=unknown, 4=error, 5=disposable, 6=invalid)'),
-      subresult: z.string().describe('Detailed sub-result (e.g., ok, no_mailbox, dns_no_mx)'),
-      free: z.boolean().describe('Whether this is a free email provider (Gmail, Yahoo, etc.)'),
-      role: z.boolean().describe('Whether this is a role-based address (info@, support@, etc.)'),
-      didYouMean: z.string().describe('Suggested correction if email looks like a typo (empty if none)'),
-      credits: z.number().describe('Remaining credits after this verification'),
-      executionTime: z.number().describe('Time taken to verify in milliseconds'),
-      error: z.string().describe('Error message when result is error (empty otherwise)'),
-      liveMode: z.boolean().describe('Whether the verification was performed in live mode')
-    }),
-    integration: 'millionverifier' as const,
-    method: 'verifyEmail' as const,
-    credentialName
-  })
-}
-
-/**
- * Create a tool that checks remaining MillionVerifier credits
- *
- * @param credentialName - Name of the MillionVerifier credential to use
- * @returns Tool instance
- *
- * @example
- * ```typescript
- * const tool = createMillionVerifierCheckCreditsTool('elevasis-millionverifier')
- * const result = await tool.execute({}, context)
- * // result.credits: 5000
- * ```
- */
-export function createMillionVerifierCheckCreditsTool(credentialName: string): Tool {
-  return createIntegrationTool({
-    name: 'millionverifier_check_credits',
-    description: `Check remaining MillionVerifier verification credits.
-
-Use this tool to monitor credit balance before running large verification batches.
-
-Returns current credits, bulk credits, renewing credits, and plan tier.`,
-    inputSchema: z.object({}),
-    outputSchema: z.object({
-      credits: z.number().describe('Remaining single-verification credits'),
-      bulkCredits: z.number().describe('Remaining bulk verification credits'),
-      renewingCredits: z.number().describe('Credits that will renew on next billing cycle'),
-      plan: z.number().describe('Current plan tier')
-    }),
-    integration: 'millionverifier' as const,
-    method: 'checkCredits' as const,
-    credentialName
-  })
-}
+import { z } from 'zod'
+import type { Tool } from '../../../../types'
+import { createIntegrationTool } from '../../../tool'
+
+/**
+ * Create a tool that verifies email addresses via MillionVerifier
+ *
+ * @param credentialName - Name of the MillionVerifier credential to use
+ * @returns Tool instance
+ *
+ * @example
+ * ```typescript
+ * const tool = createMillionVerifierVerifyEmailTool('elevasis-millionverifier')
+ * const result = await tool.execute({
+ *   email: 'john@example.com'
+ * }, context)
+ * // result.result: 'ok' | 'catch_all' | 'unknown' | 'error' | 'disposable' | 'invalid'
+ * // result.quality: 'good' | 'bad' | 'risky' | ''
+ * ```
+ */
+export function createMillionVerifierVerifyEmailTool(credentialName: string): Tool {
+  return createIntegrationTool({
+    name: 'millionverifier_verify_email',
+    description: `Verify email address deliverability using MillionVerifier.
+
+Use this tool to validate if an email address is real and can receive emails before
+adding it to a campaign. MillionVerifier is highly accurate and fast (160 req/s).
+
+Result codes:
+- ok (1): Email is valid and deliverable
+- catch_all (2): Domain accepts all email (cannot confirm individual mailbox) - FREE
+- unknown (3): Result could not be determined - FREE
+- error (4): Verification error
+- disposable (5): Disposable/temporary email address
+- invalid (6): Email address is invalid
+
+Quality signals:
+- good: Safe to send
+- risky: May bounce or flag spam filter
+- bad: Do not send
+
+Credits are only deducted for ok, invalid, and disposable results.
+
+Returns full verification details including free/role detection and suggested correction.`,
+    inputSchema: z.object({
+      email: z.string().email().describe('Email address to verify')
+    }),
+    outputSchema: z.object({
+      email: z.string().describe('Verified email address'),
+      quality: z.enum(['', 'good', 'bad', 'risky']).describe('Quality signal for sending decision'),
+      result: z.enum(['ok', 'catch_all', 'unknown', 'error', 'disposable', 'invalid']).describe('Verification result'),
+      resultCode: z
+        .number()
+        .describe('Numeric result code (1=ok, 2=catch_all, 3=unknown, 4=error, 5=disposable, 6=invalid)'),
+      subresult: z.string().describe('Detailed sub-result (e.g., ok, no_mailbox, dns_no_mx)'),
+      free: z.boolean().describe('Whether this is a free email provider (Gmail, Yahoo, etc.)'),
+      role: z.boolean().describe('Whether this is a role-based address (info@, support@, etc.)'),
+      didYouMean: z.string().describe('Suggested correction if email looks like a typo (empty if none)'),
+      credits: z.number().describe('Remaining credits after this verification'),
+      executionTime: z.number().describe('Time taken to verify in milliseconds'),
+      error: z.string().describe('Error message when result is error (empty otherwise)'),
+      liveMode: z.boolean().describe('Whether the verification was performed in live mode')
+    }),
+    integration: 'millionverifier' as const,
+    method: 'verifyEmail' as const,
+    credentialName
+  })
+}
+
+/**
+ * Create a tool that checks remaining MillionVerifier credits
+ *
+ * @param credentialName - Name of the MillionVerifier credential to use
+ * @returns Tool instance
+ *
+ * @example
+ * ```typescript
+ * const tool = createMillionVerifierCheckCreditsTool('elevasis-millionverifier')
+ * const result = await tool.execute({}, context)
+ * // result.credits: 5000
+ * ```
+ */
+export function createMillionVerifierCheckCreditsTool(credentialName: string): Tool {
+  return createIntegrationTool({
+    name: 'millionverifier_check_credits',
+    description: `Check remaining MillionVerifier verification credits.
+
+Use this tool to monitor credit balance before running large verification batches.
+
+Returns current credits, bulk credits, renewing credits, and plan tier.`,
+    inputSchema: z.object({}),
+    outputSchema: z.object({
+      credits: z.number().describe('Remaining single-verification credits'),
+      bulkCredits: z.number().describe('Remaining bulk verification credits'),
+      renewingCredits: z.number().describe('Credits that will renew on next billing cycle'),
+      plan: z.number().describe('Current plan tier')
+    }),
+    integration: 'millionverifier' as const,
+    method: 'checkCredits' as const,
+    credentialName
+  })
+}

package/src/execution/engine/tools/integration/server/adapters/resend/fetch/get-email/index.ts

@@ -1,102 +1,102 @@
-import { ToolingError } from '../../../../../../types'
-import type { ExecutionContext } from '../../../../../../../base/types'
-import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
-import type { ResendCredentials, GetEmailParams, GetEmailResult, ResendGetEmailResponse } from '../utils/types'
-
-/**
- * Get email status from Resend API
- *
- * @param credentials - Resend API credentials (apiKey)
- * @param params - Email ID to retrieve
- * @param context - Execution context for logging
- * @returns Email details including delivery status
- * @throws ToolingError if retrieval fails
- *
- * @example
- * const result = await getEmail(
- *   { apiKey: 're_xxx' },
- *   { emailId: '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794' },
- *   context
- * )
- * // result.lastEvent: 'sent', 'delivered', 'bounced', 'complained', 'failed'
- */
-export async function getEmail(
-  credentials: ResendCredentials,
-  params: GetEmailParams,
-  context?: ExecutionContext
-): Promise<GetEmailResult> {
-  const { apiKey } = credentials
-  const { emailId } = params
-
-  // Validate required parameters
-  if (!apiKey) {
-    throw new ToolingError('credentials_invalid', 'Resend API credentials must include apiKey', {
-      integration: 'resend',
-      method: 'getEmail'
-    })
-  }
-
-  if (!emailId) {
-    throw new ToolingError('validation_error', 'Email ID is required', { integration: 'resend', method: 'getEmail' })
-  }
-
-  // Build URL
-  const url = `https://api.resend.com/emails/${encodeURIComponent(emailId)}`
-
-  try {
-    // Execute with retry logic
-    const response = await withRetry(async () => {
-      const res = await fetch(url, {
-        method: 'GET',
-        headers: {
-          Authorization: `Bearer ${apiKey}`
-        }
-      })
-
-      // Handle HTTP errors
-      if (!res.ok) {
-        throw await createHttpError(res, {
-          integration: 'resend',
-          method: 'getEmail',
-          organizationId: context?.organizationId
-        })
-      }
-
-      return res
-    }, DEFAULT_RETRY_POLICY)
-
-    // Parse response
-    const result = (await response.json()) as ResendGetEmailResponse
-
-    // Log success
-    if (context?.logger) {
-      context.logger.info(
-        `[ResendAdapter] Email retrieved: organizationId=${context.organizationId} executionId=${context.executionId} emailId=${result.id} lastEvent=${result.last_event}`
-      )
-    }
-
-    // Return standardized result (camelCase)
-    return {
-      id: result.id,
-      to: result.to,
-      from: result.from,
-      subject: result.subject,
-      lastEvent: result.last_event,
-      createdAt: result.created_at
-    }
-  } catch (error) {
-    // Re-throw ToolingError as-is
-    if (error instanceof ToolingError) {
-      throw error
-    }
-
-    // Wrap unknown errors
-    throw new ToolingError('api_error', `Failed to get email from Resend: ${(error as Error).message}`, {
-      integration: 'resend',
-      method: 'getEmail',
-      organizationId: context?.organizationId,
-      emailId,
-      originalError: error
-    })
-  }
-}
+import { ToolingError } from '../../../../../../types'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { ResendCredentials, GetEmailParams, GetEmailResult, ResendGetEmailResponse } from '../utils/types'
+
+/**
+ * Get email status from Resend API
+ *
+ * @param credentials - Resend API credentials (apiKey)
+ * @param params - Email ID to retrieve
+ * @param context - Execution context for logging
+ * @returns Email details including delivery status
+ * @throws ToolingError if retrieval fails
+ *
+ * @example
+ * const result = await getEmail(
+ *   { apiKey: 're_xxx' },
+ *   { emailId: '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794' },
+ *   context
+ * )
+ * // result.lastEvent: 'sent', 'delivered', 'bounced', 'complained', 'failed'
+ */
+export async function getEmail(
+  credentials: ResendCredentials,
+  params: GetEmailParams,
+  context?: ExecutionContext
+): Promise<GetEmailResult> {
+  const { apiKey } = credentials
+  const { emailId } = params
+
+  // Validate required parameters
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Resend API credentials must include apiKey', {
+      integration: 'resend',
+      method: 'getEmail'
+    })
+  }
+
+  if (!emailId) {
+    throw new ToolingError('validation_error', 'Email ID is required', { integration: 'resend', method: 'getEmail' })
+  }
+
+  // Build URL
+  const url = `https://api.resend.com/emails/${encodeURIComponent(emailId)}`
+
+  try {
+    // Execute with retry logic
+    const response = await withRetry(async () => {
+      const res = await fetch(url, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      })
+
+      // Handle HTTP errors
+      if (!res.ok) {
+        throw await createHttpError(res, {
+          integration: 'resend',
+          method: 'getEmail',
+          organizationId: context?.organizationId
+        })
+      }
+
+      return res
+    }, DEFAULT_RETRY_POLICY)
+
+    // Parse response
+    const result = (await response.json()) as ResendGetEmailResponse
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[ResendAdapter] Email retrieved: organizationId=${context.organizationId} executionId=${context.executionId} emailId=${result.id} lastEvent=${result.last_event}`
+      )
+    }
+
+    // Return standardized result (camelCase)
+    return {
+      id: result.id,
+      to: result.to,
+      from: result.from,
+      subject: result.subject,
+      lastEvent: result.last_event,
+      createdAt: result.created_at
+    }
+  } catch (error) {
+    // Re-throw ToolingError as-is
+    if (error instanceof ToolingError) {
+      throw error
+    }
+
+    // Wrap unknown errors
+    throw new ToolingError('api_error', `Failed to get email from Resend: ${(error as Error).message}`, {
+      integration: 'resend',
+      method: 'getEmail',
+      organizationId: context?.organizationId,
+      emailId,
+      originalError: error
+    })
+  }
+}