@elevasis/core 0.22.0 → 0.24.0

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

@@ -1,103 +1,103 @@
-import { z } from 'zod'
-import type { Tool } from '../../../../types'
-import { createIntegrationTool } from '../../../tool'
-import { EmailSchema } from '../../../../../../../platform/utils/validation'
-
-/**
- * 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: EmailSchema.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'
+import { EmailSchema } from '../../../../../../../platform/utils/validation'
+
+/**
+ * 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: EmailSchema.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/send-email/index.test.ts

@@ -1,88 +1,88 @@
-/**
- * Resend sendEmail — idempotency-key regression tests
- *
- * Guards the Idempotency-Key header plumbing added as part of the
- * cache-as-contract-leak fix. Platform-internal retries (TypeError /
- * ReferenceError reclassified as platform_internal) must be safe for write
- * tools — Resend dedupes server-side when the same Idempotency-Key arrives.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { sendEmail } from './index'
-import type { ResendCredentials, SendEmailParams } from '../utils/types'
-
-const credentials: ResendCredentials = { apiKey: 're_test_123' }
-const baseParams: SendEmailParams = {
-  from: 'Test <test@elevasis.io>',
-  to: 'recipient@example.com',
-  subject: 'Hello',
-  html: '<p>Hi</p>'
-}
-
-function mockResendOk(): ReturnType<typeof vi.fn> {
-  const fetchMock = vi.fn(async () =>
-    Promise.resolve(
-      new Response(JSON.stringify({ id: 'email_abc' }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' }
-      })
-    )
-  )
-  ;(globalThis as unknown as { fetch: typeof fetch }).fetch = fetchMock as unknown as typeof fetch
-  return fetchMock
-}
-
-describe('Resend sendEmail — idempotency key', () => {
-  let originalFetch: typeof fetch
-
-  beforeEach(() => {
-    originalFetch = globalThis.fetch
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('omits the Idempotency-Key header when idempotencyKey is not provided', async () => {
-    const fetchMock = mockResendOk()
-
-    await sendEmail(credentials, baseParams)
-
-    expect(fetchMock).toHaveBeenCalledOnce()
-    const init = fetchMock.mock.calls[0][1] as RequestInit
-    const headers = init.headers as Record<string, string>
-    expect(headers['Idempotency-Key']).toBeUndefined()
-    // Sanity check: required headers are still present
-    expect(headers.Authorization).toBe('Bearer re_test_123')
-    expect(headers['Content-Type']).toBe('application/json')
-  })
-
-  it('passes idempotencyKey through as the Idempotency-Key header', async () => {
-    const fetchMock = mockResendOk()
-
-    await sendEmail(credentials, { ...baseParams, idempotencyKey: 'wf-exec-001-step-send-approval' })
-
-    const init = fetchMock.mock.calls[0][1] as RequestInit
-    const headers = init.headers as Record<string, string>
-    expect(headers['Idempotency-Key']).toBe('wf-exec-001-step-send-approval')
-  })
-
-  it('sends the same Idempotency-Key on caller-driven retries (regression: platform_internal retries must dedupe)', async () => {
-    const fetchMock = mockResendOk()
-
-    const params: SendEmailParams = { ...baseParams, idempotencyKey: 'stable-key-xyz' }
-
-    // Simulate two calls with identical params (e.g. caller retries after a
-    // platform_internal failure). Both must carry the same Idempotency-Key
-    // so Resend collapses them into a single send.
-    await sendEmail(credentials, params)
-    await sendEmail(credentials, params)
-
-    expect(fetchMock).toHaveBeenCalledTimes(2)
-
-    const firstHeaders = (fetchMock.mock.calls[0][1] as RequestInit).headers as Record<string, string>
-    const secondHeaders = (fetchMock.mock.calls[1][1] as RequestInit).headers as Record<string, string>
-    expect(firstHeaders['Idempotency-Key']).toBe('stable-key-xyz')
-    expect(secondHeaders['Idempotency-Key']).toBe('stable-key-xyz')
-  })
-})
+/**
+ * Resend sendEmail — idempotency-key regression tests
+ *
+ * Guards the Idempotency-Key header plumbing added as part of the
+ * cache-as-contract-leak fix. Platform-internal retries (TypeError /
+ * ReferenceError reclassified as platform_internal) must be safe for write
+ * tools — Resend dedupes server-side when the same Idempotency-Key arrives.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { sendEmail } from './index'
+import type { ResendCredentials, SendEmailParams } from '../utils/types'
+
+const credentials: ResendCredentials = { apiKey: 're_test_123' }
+const baseParams: SendEmailParams = {
+  from: 'Test <test@elevasis.io>',
+  to: 'recipient@example.com',
+  subject: 'Hello',
+  html: '<p>Hi</p>'
+}
+
+function mockResendOk(): ReturnType<typeof vi.fn> {
+  const fetchMock = vi.fn(async () =>
+    Promise.resolve(
+      new Response(JSON.stringify({ id: 'email_abc' }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' }
+      })
+    )
+  )
+  ;(globalThis as unknown as { fetch: typeof fetch }).fetch = fetchMock as unknown as typeof fetch
+  return fetchMock
+}
+
+describe('Resend sendEmail — idempotency key', () => {
+  let originalFetch: typeof fetch
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('omits the Idempotency-Key header when idempotencyKey is not provided', async () => {
+    const fetchMock = mockResendOk()
+
+    await sendEmail(credentials, baseParams)
+
+    expect(fetchMock).toHaveBeenCalledOnce()
+    const init = fetchMock.mock.calls[0][1] as RequestInit
+    const headers = init.headers as Record<string, string>
+    expect(headers['Idempotency-Key']).toBeUndefined()
+    // Sanity check: required headers are still present
+    expect(headers.Authorization).toBe('Bearer re_test_123')
+    expect(headers['Content-Type']).toBe('application/json')
+  })
+
+  it('passes idempotencyKey through as the Idempotency-Key header', async () => {
+    const fetchMock = mockResendOk()
+
+    await sendEmail(credentials, { ...baseParams, idempotencyKey: 'wf-exec-001-step-send-approval' })
+
+    const init = fetchMock.mock.calls[0][1] as RequestInit
+    const headers = init.headers as Record<string, string>
+    expect(headers['Idempotency-Key']).toBe('wf-exec-001-step-send-approval')
+  })
+
+  it('sends the same Idempotency-Key on caller-driven retries (regression: platform_internal retries must dedupe)', async () => {
+    const fetchMock = mockResendOk()
+
+    const params: SendEmailParams = { ...baseParams, idempotencyKey: 'stable-key-xyz' }
+
+    // Simulate two calls with identical params (e.g. caller retries after a
+    // platform_internal failure). Both must carry the same Idempotency-Key
+    // so Resend collapses them into a single send.
+    await sendEmail(credentials, params)
+    await sendEmail(credentials, params)
+
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+
+    const firstHeaders = (fetchMock.mock.calls[0][1] as RequestInit).headers as Record<string, string>
+    const secondHeaders = (fetchMock.mock.calls[1][1] as RequestInit).headers as Record<string, string>
+    expect(firstHeaders['Idempotency-Key']).toBe('stable-key-xyz')
+    expect(secondHeaders['Idempotency-Key']).toBe('stable-key-xyz')
+  })
+})