@elevasis/core 0.1.0

package/src/execution/engine/tools/platform/acquisition/list-tools.ts

@@ -0,0 +1,148 @@
+/**
+ * Acquisition List Platform Tools
+ *
+ * Platform tools for managing acquisition lists. Lists work like Google Sheets tabs,
+ * organizing contacts into logical groups.
+ *
+ * Multi-tenancy: All operations are scoped by organizationId from ExecutionContext.
+ * Agents cannot specify organizationId - it is always derived from the execution context.
+ */
+
+import { z } from 'zod'
+import { getToolServices } from '../../registry'
+import { serviceUnavailable } from '../../types'
+import type { Tool } from '../../types'
+import {
+  CreateListInputSchema,
+  UpdateListInputSchema,
+  DeleteListInputSchema,
+  ListOutputSchema,
+  ListArrayOutputSchema,
+  DeleteResultSchema
+} from './types'
+
+/**
+ * Create a new acquisition list
+ *
+ * Creates a list for organizing contacts. Lists are organization-scoped
+ * and ordered by creation date (newest first) when retrieved.
+ */
+export function createAcqListCreateTool(): Tool {
+  return {
+    name: 'acq_list_create',
+    description: 'Create a new acquisition list for organizing contacts. Lists work like Google Sheets tabs.',
+    inputSchema: CreateListInputSchema,
+    outputSchema: ListOutputSchema,
+    execute: async ({ input, executionContext }) => {
+      const leadService = getToolServices().leadService
+      if (!leadService) throw serviceUnavailable('LeadService')
+      if (!executionContext?.organizationId) throw serviceUnavailable('ExecutionContext', { reason: 'organizationId required for multi-tenant isolation' })
+
+      const typedInput = input as { name: string; description?: string }
+
+      const result = await leadService.createList({
+        organizationId: executionContext.organizationId,
+        name: typedInput.name,
+        description: typedInput.description
+      })
+
+      return {
+        id: result.id,
+        organizationId: result.organizationId,
+        name: result.name,
+        description: result.description,
+        createdAt: result.createdAt.toISOString()
+      }
+    }
+  }
+}
+
+/**
+ * Update an existing acquisition list
+ *
+ * Updates list metadata (name and/or description). The list must exist
+ * and belong to the organization.
+ */
+export function createAcqListUpdateTool(): Tool {
+  return {
+    name: 'acq_list_update',
+    description: 'Update an existing acquisition list metadata (name or description).',
+    inputSchema: UpdateListInputSchema,
+    outputSchema: ListOutputSchema,
+    execute: async ({ input, executionContext }) => {
+      const leadService = getToolServices().leadService
+      if (!leadService) throw serviceUnavailable('LeadService')
+      if (!executionContext?.organizationId) throw serviceUnavailable('ExecutionContext', { reason: 'organizationId required for multi-tenant isolation' })
+
+      const typedInput = input as { id: string; name?: string; description?: string }
+
+      const result = await leadService.updateList(typedInput.id, {
+        name: typedInput.name,
+        description: typedInput.description
+      })
+
+      return {
+        id: result.id,
+        organizationId: result.organizationId,
+        name: result.name,
+        description: result.description,
+        createdAt: result.createdAt.toISOString()
+      }
+    }
+  }
+}
+
+/**
+ * Delete an acquisition list
+ *
+ * Deletes a list. Contacts in this list will have their list_ids updated
+ * to remove this list reference. The list must belong to the organization.
+ */
+export function createAcqListDeleteTool(): Tool {
+  return {
+    name: 'acq_list_delete',
+    description: 'Delete an acquisition list. Contacts in this list will have their list_ids updated to remove this list.',
+    inputSchema: DeleteListInputSchema,
+    outputSchema: DeleteResultSchema,
+    execute: async ({ input, executionContext }) => {
+      const leadService = getToolServices().leadService
+      if (!leadService) throw serviceUnavailable('LeadService')
+      if (!executionContext?.organizationId) throw serviceUnavailable('ExecutionContext', { reason: 'organizationId required for multi-tenant isolation' })
+
+      const typedInput = input as { id: string }
+
+      await leadService.deleteList(typedInput.id, executionContext.organizationId)
+      return { success: true }
+    }
+  }
+}
+
+/**
+ * List all acquisition lists for the organization
+ *
+ * Returns all lists ordered by creation date (newest first).
+ * No input parameters required - organization is derived from context.
+ */
+export function createAcqListListTool(): Tool {
+  return {
+    name: 'acq_list_list',
+    description: 'List all acquisition lists for the organization. Returns lists ordered by creation date (newest first).',
+    inputSchema: z.object({}),
+    outputSchema: ListArrayOutputSchema,
+    execute: async ({ executionContext }) => {
+      const leadService = getToolServices().leadService
+      if (!leadService) throw serviceUnavailable('LeadService')
+      if (!executionContext?.organizationId) throw serviceUnavailable('ExecutionContext', { reason: 'organizationId required for multi-tenant isolation' })
+
+      const results = await leadService.listLists(executionContext.organizationId)
+
+      return results.map(result => ({
+        id: result.id,
+        organizationId: result.organizationId,
+        name: result.name,
+        description: result.description,
+        createdAt: result.createdAt.toISOString()
+      }))
+    }
+  }
+}

package/src/execution/engine/tools/platform/acquisition/types.ts

@@ -0,0 +1,260 @@
+import { z } from 'zod'
+
+// ============================================
+// LIST SCHEMAS
+// ============================================
+
+export const CreateListInputSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional()
+})
+
+export const UpdateListInputSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).optional(),
+  description: z.string().optional()
+})
+
+export const DeleteListInputSchema = z.object({
+  id: z.string().uuid()
+})
+
+export const ListOutputSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  name: z.string(),
+  description: z.string().nullable(),
+  createdAt: z.string() // ISO date string
+})
+
+export const ListArrayOutputSchema = z.array(ListOutputSchema)
+
+// ============================================
+// COMPANY SCHEMAS
+// ============================================
+
+export const CreateCompanyInputSchema = z.object({
+  name: z.string().min(1),
+  domain: z.string().optional(),
+  linkedinUrl: z.string().url().optional(),
+  website: z.string().url().optional(),
+  numEmployees: z.number().int().positive().optional(),
+  foundedYear: z.number().int().min(1800).max(2100).optional(),
+  locationCity: z.string().optional(),
+  locationState: z.string().optional(),
+  source: z.string().optional(),
+  batchId: z.string().optional()
+})
+
+export const UpdateCompanyInputSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).optional(),
+  domain: z.string().optional(),
+  linkedinUrl: z.string().url().optional(),
+  website: z.string().url().optional(),
+  numEmployees: z.number().int().positive().optional(),
+  foundedYear: z.number().int().min(1800).max(2100).optional(),
+  locationCity: z.string().optional(),
+  locationState: z.string().optional(),
+  category: z.string().optional(),
+  segment: z.string().optional(),
+  pipelineStatus: z.record(z.string(), z.unknown()).optional(),
+  enrichmentData: z.record(z.string(), z.unknown()).optional(),
+  source: z.string().optional(),
+  batchId: z.string().optional()
+})
+
+export const UpsertCompanyInputSchema = CreateCompanyInputSchema.extend({
+  domain: z.string().min(1) // Domain required for upsert (unique key)
+})
+
+export const GetCompanyInputSchema = z.object({
+  id: z.string().uuid()
+})
+
+export const ListCompaniesInputSchema = z.object({
+  segment: z.string().optional(),
+  category: z.string().optional(),
+  domain: z.string().optional().describe('Exact domain match filter'),
+  website: z.string().optional().describe('Exact website match filter'),
+  pipelineStatus: z.record(z.string(), z.unknown()).optional().describe('JSONB containment filter for pipeline_status'),
+  batchId: z.string().optional(),
+  status: z
+    .enum(['active', 'invalid'])
+    .optional()
+    .describe('Filter by company status. Defaults to active if not set and includeAll is false'),
+  includeAll: z
+    .boolean()
+    .optional()
+    .describe('Bypass default active-only filter to return all companies regardless of status'),
+  excludeColumns: z
+    .array(z.enum(['enrichmentData', 'pipelineStatus']))
+    .optional()
+    .describe('Exclude large JSONB columns from the response to reduce query size')
+})
+
+export const DeleteCompanyInputSchema = z.object({
+  id: z.string().uuid()
+})
+
+export const CompanyOutputSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  name: z.string(),
+  domain: z.string().nullable(),
+  linkedinUrl: z.string().nullable(),
+  website: z.string().nullable(),
+  numEmployees: z.number().nullable(),
+  foundedYear: z.number().nullable(),
+  locationCity: z.string().nullable(),
+  locationState: z.string().nullable(),
+  category: z.string().nullable(),
+  segment: z.string().nullable(),
+  pipelineStatus: z.record(z.string(), z.unknown()).nullable(),
+  enrichmentData: z.record(z.string(), z.unknown()).nullable(),
+  source: z.string().nullable(),
+  batchId: z.string().nullable().optional(),
+  status: z.enum(['active', 'invalid']),
+  createdAt: z.string(),
+  updatedAt: z.string()
+})
+
+export const CompanyArrayOutputSchema = z.array(CompanyOutputSchema)
+
+// ============================================
+// CONTACT SCHEMAS
+// ============================================
+
+export const CreateContactInputSchema = z.object({
+  email: z.string().email(),
+  companyId: z.string().uuid().optional(),
+  firstName: z.string().optional(),
+  lastName: z.string().optional(),
+  linkedinUrl: z.string().url().optional(),
+  title: z.string().optional(),
+  source: z.string().optional(),
+  sourceId: z.string().optional(),
+  batchId: z.string().optional()
+})
+
+export const UpdateContactInputSchema = z.object({
+  id: z.string().uuid(),
+  companyId: z.string().uuid().optional(),
+  emailValid: z.enum(['VALID', 'INVALID', 'RISKY', 'UNKNOWN']).optional(),
+  firstName: z.string().optional(),
+  lastName: z.string().optional(),
+  linkedinUrl: z.string().url().optional(),
+  title: z.string().optional(),
+  headline: z.string().optional(),
+  filterReason: z.string().optional(),
+  openingLine: z.string().optional(),
+  pipelineStatus: z.record(z.string(), z.unknown()).optional(),
+  enrichmentData: z.record(z.string(), z.unknown()).optional(),
+  status: z.enum(['active', 'invalid']).optional()
+})
+
+export const UpsertContactInputSchema = CreateContactInputSchema
+
+export const GetContactInputSchema = z.object({
+  id: z.string().uuid()
+})
+
+export const ListContactsInputSchema = z.object({
+  openingLineIsNull: z.boolean().optional(), // Filter to contacts without personalization
+  batchId: z.string().optional(),
+  contactStatus: z.enum(['active', 'invalid']).optional().describe('Filter by contact status (soft-delete flag)'),
+  limit: z.number().int().min(1).max(1000).default(100),
+  offset: z.number().int().min(0).default(0)
+})
+
+export const DeleteContactInputSchema = z.object({
+  id: z.string().uuid()
+})
+
+export const DeactivateContactsByCompanyInputSchema = z.object({
+  companyId: z.string().uuid()
+})
+
+export const DeactivateContactsByCompanyResultSchema = z.object({
+  deactivated: z.number()
+})
+
+export const BulkImportInputSchema = z.object({
+  contacts: z.array(CreateContactInputSchema)
+})
+
+export const ContactOutputSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  companyId: z.string().uuid().nullable(),
+  email: z.string(),
+  emailValid: z.enum(['VALID', 'INVALID', 'RISKY', 'UNKNOWN']).nullable(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
+  linkedinUrl: z.string().nullable(),
+  title: z.string().nullable(),
+  headline: z.string().nullable(),
+  filterReason: z.string().nullable(),
+  openingLine: z.string().nullable(),
+  source: z.string().nullable(),
+  sourceId: z.string().nullable(),
+  pipelineStatus: z.record(z.string(), z.unknown()).nullable(),
+  enrichmentData: z.record(z.string(), z.unknown()).nullable(),
+  batchId: z.string().nullable().optional(),
+  status: z.enum(['active', 'invalid']),
+  createdAt: z.string(),
+  updatedAt: z.string()
+})
+
+export const PaginatedContactsOutputSchema = z.object({
+  data: z.array(ContactOutputSchema),
+  total: z.number(),
+  limit: z.number(),
+  offset: z.number()
+})
+
+export const BulkImportResultSchema = z.object({
+  created: z.number(),
+  updated: z.number(),
+  errors: z.array(
+    z.object({
+      email: z.string(),
+      error: z.string()
+    })
+  )
+})
+
+export const DeleteResultSchema = z.object({
+  success: z.boolean()
+})
+
+// ============================================
+// INFERRED TYPES
+// ============================================
+
+export type CreateListInput = z.infer<typeof CreateListInputSchema>
+export type UpdateListInput = z.infer<typeof UpdateListInputSchema>
+export type DeleteListInput = z.infer<typeof DeleteListInputSchema>
+export type ListOutput = z.infer<typeof ListOutputSchema>
+
+export type CreateCompanyInput = z.infer<typeof CreateCompanyInputSchema>
+export type UpdateCompanyInput = z.infer<typeof UpdateCompanyInputSchema>
+export type UpsertCompanyInput = z.infer<typeof UpsertCompanyInputSchema>
+export type GetCompanyInput = z.infer<typeof GetCompanyInputSchema>
+export type ListCompaniesInput = z.infer<typeof ListCompaniesInputSchema>
+export type DeleteCompanyInput = z.infer<typeof DeleteCompanyInputSchema>
+export type CompanyOutput = z.infer<typeof CompanyOutputSchema>
+
+export type CreateContactInput = z.infer<typeof CreateContactInputSchema>
+export type UpdateContactInput = z.infer<typeof UpdateContactInputSchema>
+export type UpsertContactInput = z.infer<typeof UpsertContactInputSchema>
+export type GetContactInput = z.infer<typeof GetContactInputSchema>
+export type ListContactsInput = z.infer<typeof ListContactsInputSchema>
+export type DeleteContactInput = z.infer<typeof DeleteContactInputSchema>
+export type BulkImportInput = z.infer<typeof BulkImportInputSchema>
+export type ContactOutput = z.infer<typeof ContactOutputSchema>
+export type PaginatedContactsOutput = z.infer<typeof PaginatedContactsOutputSchema>
+export type BulkImportResult = z.infer<typeof BulkImportResultSchema>
+export type DeleteResult = z.infer<typeof DeleteResultSchema>
+export type DeactivateContactsByCompanyInput = z.infer<typeof DeactivateContactsByCompanyInputSchema>
+export type DeactivateContactsByCompanyResult = z.infer<typeof DeactivateContactsByCompanyResultSchema>

package/src/execution/engine/tools/platform/approval/cancel-by-metadata.ts

@@ -0,0 +1,65 @@
+/**
+ * HITL Cancel by Metadata Tool
+ *
+ * Batch delete pending HITL (command queue) tasks matching metadata filters.
+ * Used for cleanup when a contact unsubscribes or a deal is closed.
+ */
+
+import { z } from 'zod'
+import { getToolServices } from '../../registry'
+import type { Tool } from '../../types'
+import { serviceUnavailable } from '../../types'
+
+// ============================================
+// Schemas
+// ============================================
+
+export const HitlCancelByMetadataInputSchema = z.object({
+  /** JSONB containment filter for metadata (e.g., { contactEmail: 'user@example.com' }) */
+  metadata: z.record(z.string(), z.unknown()),
+  /** Only delete tasks with this status (default: 'pending') */
+  status: z.string().default('pending')
+})
+
+export const HitlCancelByMetadataOutputSchema = z.object({
+  deleted: z.number()
+})
+
+export type HitlCancelByMetadataInput = z.infer<typeof HitlCancelByMetadataInputSchema>
+export type HitlCancelByMetadataOutput = z.infer<typeof HitlCancelByMetadataOutputSchema>
+
+// ============================================
+// Tool Factory
+// ============================================
+
+export function createHitlCancelByMetadataTool(): Tool {
+  return {
+    name: 'hitl_cancel_by_metadata',
+    description:
+      'Delete pending HITL (human-in-the-loop) tasks matching metadata filters. Used for batch cleanup of command queue entries when a contact unsubscribes or a deal is closed.',
+    inputSchema: HitlCancelByMetadataInputSchema,
+    outputSchema: HitlCancelByMetadataOutputSchema,
+    async execute({ input, executionContext }) {
+      if (!executionContext?.organizationId) {
+        throw serviceUnavailable('ExecutionContext', { tool: 'hitl_cancel_by_metadata', reason: 'organizationId required for multi-tenant isolation' })
+      }
+
+      const { commandQueueService } = getToolServices()
+      if (!commandQueueService) {
+        throw serviceUnavailable('CommandQueueService', {
+          message:
+            'Ensure toolServicesRegistry.initialize() was called in apps/api/src/main.ts',
+          tool: 'hitl_cancel_by_metadata'
+        })
+      }
+
+      const { metadata, status } = input as HitlCancelByMetadataInput
+
+      return commandQueueService.deleteByMetadata(
+        executionContext.organizationId,
+        metadata,
+        status
+      )
+    }
+  }
+}

package/src/execution/engine/tools/platform/approval/index.ts

@@ -0,0 +1,4 @@
+export { createApprovalTool } from './tool'
+export { createHitlCancelByMetadataTool } from './cancel-by-metadata'
+export type { HitlCancelByMetadataInput, HitlCancelByMetadataOutput } from './cancel-by-metadata'
+export { HitlCancelByMetadataInputSchema, HitlCancelByMetadataOutputSchema } from './cancel-by-metadata'

package/src/execution/engine/tools/platform/approval/tool.ts

@@ -0,0 +1,99 @@
+import type { Tool, ToolExecutionOptions } from '../../types'
+import { serviceUnavailable } from '../../types'
+import type { CreateTaskParams, ActionConfig } from '../../../../../commands/queue/types'
+import { getToolServices } from '../../registry'
+import type { ApprovalToolConfig } from '../types'
+
+/**
+ * Create an approval tool that sends tasks to the command queue for human approval
+ *
+ * Approval tools enable human-in-the-loop workflows by creating tasks that require
+ * human approval before proceeding. The task contains the input payload and routes
+ * to specified agents based on approval/rejection.
+ *
+ * @param config - Configuration for the approval tool
+ * @returns Tool that creates approval tasks in the command queue
+ *
+ * @example
+ * const approvalTool = createApprovalTool({
+ *   name: 'request_payment_approval',
+ *   description: 'Request approval for high-value payment',
+ *   inputSchema: z.object({ amount: z.number(), recipient: z.string() }),
+ *   outputSchema: z.object({ taskId: z.string() }),
+ *   approveTargetResourceId: 'payment-processor-agent',
+ *   rejectTargetResourceId: 'payment-rejection-handler',
+ *   priority: 8
+ * })
+ */
+export function createApprovalTool(config: ApprovalToolConfig): Tool {
+  return {
+    name: config.name,
+    description: config.description,
+    inputSchema: config.inputSchema,
+    outputSchema: config.outputSchema,
+
+    async execute(options: ToolExecutionOptions): Promise<unknown> {
+      // ExecutionContext is required for platform tools
+      if (!options.executionContext) {
+        throw serviceUnavailable('ExecutionContext', { tool: config.name, reason: 'organizationId required for multi-tenant isolation' })
+      }
+
+      // Get command queue service from global registry
+      const { commandQueueService: commandQueue } = getToolServices()
+      if (!commandQueue) {
+        throw serviceUnavailable('CommandQueueService', {
+          message: 'Ensure toolServicesRegistry.initialize() was called in apps/api/src/main.ts',
+          tool: config.name
+        })
+      }
+
+      // Build task parameters using execution context
+      // Convert old approve/reject pattern to new action-based schema
+      const actions: ActionConfig[] = [
+        {
+          id: 'approve',
+          label: 'Approve',
+          type: 'primary',
+          icon: 'IconCheck',
+          color: 'green',
+          target: {
+            resourceType: 'agent',
+            resourceId: config.approveTargetResourceId
+          }
+        }
+      ]
+
+      // Add reject action if configured
+      if (config.rejectTargetResourceId) {
+        actions.push({
+          id: 'reject',
+          label: 'Reject',
+          type: 'danger',
+          icon: 'IconX',
+          color: 'red',
+          target: {
+            resourceType: 'agent',
+            resourceId: config.rejectTargetResourceId
+          }
+        })
+      }
+
+      const params: CreateTaskParams = {
+        organizationId: options.executionContext.organizationId,
+        originExecutionId: options.executionContext.executionId,
+        originResourceType: 'agent',
+        originResourceId: options.executionContext.resourceId,
+        actions,
+        context: options.input,
+        priority: config.priority ?? 5,
+        expiresAt: config.expiresAt
+      }
+
+      // Create task in command queue
+      const task = await commandQueue.createTask(params)
+
+      // Return task ID for tracking
+      return { taskId: task.id }
+    }
+  }
+}

package/src/execution/engine/tools/platform/email/index.ts

@@ -0,0 +1,122 @@
+/**
+ * Platform Email Tool
+ *
+ * Factory function for creating a platform email tool that sends
+ * transactional emails from notifications@elevasis.io using platform Resend credentials.
+ *
+ * Usage:
+ * ```typescript
+ * const emailTool = createPlatformEmailTool({
+ *   name: 'send_platform_email',
+ *   description: 'Send platform notification emails to users'
+ * })
+ * ```
+ */
+
+import type { Tool, ToolExecutionOptions } from '../../types'
+import { serviceUnavailable } from '../../types'
+import { getToolServices } from '../../registry'
+import type { SendPlatformEmailParams } from '../../registry'
+import {
+  SendPlatformEmailInputSchema,
+  SendPlatformEmailOutputSchema,
+  type SendPlatformEmailInput,
+  type SendPlatformEmailOutput,
+  type PlatformEmailToolConfig
+} from './types'
+
+/**
+ * Create a platform email tool that sends emails to targeted users
+ *
+ * Platform email tools enable agents and workflows to send transactional emails
+ * from the platform email address (notifications@elevasis.io). Emails can target
+ * specific users, users with a role, or all organization members.
+ *
+ * @param config - Configuration for the email tool
+ * @returns Tool that sends platform emails
+ *
+ * @example
+ * const emailTool = createPlatformEmailTool({
+ *   name: 'notify_admins',
+ *   description: 'Send email notification to all admin users'
+ * })
+ *
+ * // Execute with explicit user targeting
+ * await emailTool.execute({
+ *   input: {
+ *     userIds: ['user-id-1', 'user-id-2'],
+ *     subject: 'Workflow completed',
+ *     html: '<p>Your workflow has completed successfully.</p>'
+ *   },
+ *   executionContext: context
+ * })
+ *
+ * // Execute with role-based targeting
+ * await emailTool.execute({
+ *   input: {
+ *     targetRole: 'admin',
+ *     subject: 'System alert',
+ *     text: 'A critical error occurred.'
+ *   },
+ *   executionContext: context
+ * })
+ */
+export function createPlatformEmailTool(config: PlatformEmailToolConfig): Tool {
+  return {
+    name: config.name,
+    description: config.description,
+    inputSchema: SendPlatformEmailInputSchema,
+    outputSchema: SendPlatformEmailOutputSchema,
+
+    async execute(options: ToolExecutionOptions): Promise<SendPlatformEmailOutput> {
+      // ExecutionContext is required for platform tools
+      if (!options.executionContext) {
+        throw serviceUnavailable('ExecutionContext', { tool: config.name, reason: 'organizationId required for multi-tenant isolation' })
+      }
+
+      // Get email service from global registry
+      const { emailService } = getToolServices()
+      if (!emailService) {
+        throw serviceUnavailable('EmailService', {
+          message: 'Ensure toolServicesRegistry.initialize() was called in apps/api/src/main.ts',
+          tool: config.name
+        })
+      }
+
+      // Build email parameters from input + context
+      const inputData = options.input as SendPlatformEmailInput
+
+      const params: SendPlatformEmailParams = {
+        organizationId: options.executionContext.organizationId,
+
+        // Targeting (exactly one will be set, validated by schema)
+        userIds: inputData.userIds,
+        targetRole: inputData.targetRole,
+        targetAll: inputData.targetAll,
+
+        // Content
+        subject: inputData.subject,
+        html: inputData.html,
+        text: inputData.text,
+
+        // Optional
+        replyTo: inputData.replyTo,
+        tags: inputData.tags
+      }
+
+      // Send email via service
+      const result = await emailService.send(params)
+
+      return result
+    }
+  }
+}
+
+// Re-export types for consumers
+export {
+  SendPlatformEmailInputSchema,
+  SendPlatformEmailOutputSchema,
+  type SendPlatformEmailInput,
+  type SendPlatformEmailOutput,
+  type PlatformEmailToolConfig
+} from './types'