@elevasis/core 0.1.0

package/src/execution/engine/tools/platform/resource-invocation/resource-invocation-service.ts

@@ -0,0 +1,147 @@
+import type { ExecutionContext } from '../../../base/types'
+import type { ResourceRegistry } from '../../../../../platform/registry/resource-registry'
+import type { ResourceExecutionRequest, ResourceInvocationResult } from './types'
+
+/**
+ * ResourceInvocationService
+ * Handles execution of resources (agents and workflows) from agent context
+ *
+ * Responsibilities:
+ * - Validate resource exists and is accessible
+ * - Validate input against resource contract
+ * - Execute resource with parent execution context
+ * - Return typed invocation result
+ *
+ * Multi-tenancy: All resource lookups scoped by organizationName (passed as parameter)
+ */
+export class ResourceInvocationService {
+  constructor(
+    private registry: ResourceRegistry,
+    private executeResource: (
+      request: ResourceExecutionRequest,
+      parentContext: ExecutionContext
+    ) => Promise<ResourceInvocationResult>
+  ) {}
+
+  /**
+   * Execute resource synchronously (waits for completion)
+   *
+   * @param resourceId - ID of resource to execute (agent or workflow)
+   * @param input - Input payload for resource
+   * @param organizationName - Organization name for resource lookup (from execution request)
+   * @param parentContext - Parent execution context (provides organization ID and tracking)
+   * @returns Invocation result with success, output, executionId, and resourceType
+   *
+   * @example
+   * const result = await service.executeSync(
+   *   'lead-validation-workflow',
+   *   { email: 'test@test.com', name: 'John Doe' },
+   *   'acme-corp',
+   *   executionContext
+   * )
+   *
+   * if (result.success) {
+   *   console.log('Validation result:', result.output)
+   * } else {
+   *   console.error('Validation failed:', result.error)
+   * }
+   */
+  async executeSync(
+    resourceId: string,
+    input: unknown,
+    organizationName: string,
+    parentContext: ExecutionContext
+  ): Promise<ResourceInvocationResult> {
+    // 1. Validate resource exists (scoped to organization)
+    const definition = this.registry.getResourceDefinition(
+      organizationName,
+      resourceId
+    )
+
+    if (!definition) {
+      return {
+        success: false,
+        output: null,
+        executionId: '',
+        resourceType: 'workflow',
+        error: `Resource not found: ${resourceId}`
+      }
+    }
+
+    // Determine resource type from definition
+    const resourceType = definition.config.type as 'agent' | 'workflow'
+
+    // 2. Enforce relationship declaration
+    const relationships = this.registry.getRelationships(organizationName)
+    if (relationships) {
+      const callerRel = relationships[parentContext.resourceId]
+      const declaredTargets = [
+        ...(callerRel?.triggers?.agents ?? []),
+        ...(callerRel?.triggers?.workflows ?? [])
+      ]
+      if (!declaredTargets.includes(resourceId)) {
+        throw new Error(
+          `Undeclared resource invocation: "${parentContext.resourceId}" -> "${resourceId}". ` +
+          `Add to relationships: { '${parentContext.resourceId}': { triggers: { ${resourceType}s: ['${resourceId}'] } } }`
+        )
+      }
+    }
+
+    // 3. Validate input against resource contract
+    const validationResult = definition.contract.inputSchema.safeParse(input)
+    if (!validationResult.success) {
+      return {
+        success: false,
+        output: null,
+        executionId: '',
+        resourceType,
+        error: `Input validation failed: ${validationResult.error.message}`
+      }
+    }
+
+    // 4. Execute resource with parent context
+    const result = await this.executeResource(
+      {
+        resourceId,
+        input: validationResult.data,
+        organizationId: parentContext.organizationId,
+        organizationName
+      },
+      parentContext
+    )
+
+    return {
+      ...result,
+      resourceType
+    }
+  }
+}
+
+/**
+ * Factory function for creating ResourceInvocationService
+ * Validates dependencies at construction time (fail-fast)
+ *
+ * @param registry - ResourceRegistry for resource lookup
+ * @param executeResource - Callback to execute resource (delegates to coordinator)
+ * @returns ResourceInvocationService instance
+ * @throws Error if dependencies are missing
+ *
+ * @example
+ * const service = createResourceInvocationService(
+ *   resourceRegistry,
+ *   async (request, parentContext) => {
+ *     return coordinator.executeNested(request, parentContext)
+ *   }
+ * )
+ */
+export function createResourceInvocationService(
+  registry: ResourceRegistry,
+  executeResource: (
+    request: ResourceExecutionRequest,
+    parentContext: ExecutionContext
+  ) => Promise<ResourceInvocationResult>
+): ResourceInvocationService {
+  if (!registry) throw new Error('ResourceRegistry required')
+  if (!executeResource) throw new Error('executeResource callback required')
+  return new ResourceInvocationService(registry, executeResource)
+}

package/src/execution/engine/tools/platform/resource-invocation/tool.ts

@@ -0,0 +1,115 @@
+/**
+ * Resource Invocation Tool Factory
+ *
+ * Creates tools that invoke other resources (agents or workflows) as first-class tools.
+ * Schemas are derived directly from the resource's contract, eliminating duplication.
+ *
+ * @module resource-invocation/tool
+ */
+
+import { z } from 'zod'
+import { serviceUnavailable, apiError } from '../../types'
+import type { Tool, ToolExecutionOptions } from '../../types'
+import type { AgentDefinition } from '../../../agent/core/types'
+import type { WorkflowDefinition } from '../../../workflow/types'
+import { getToolServices } from '../../registry'
+import { DEFAULT_RESOURCE_INVOCATION_TIMEOUT } from '../../../../../platform/constants/timeouts'
+
+/**
+ * Resource definition type (Agent or Workflow)
+ * Both types have config and contract fields needed for tool creation
+ */
+export type ResourceDefinition = AgentDefinition | WorkflowDefinition
+
+/**
+ * Configuration for creating a resource invocation tool
+ *
+ * The tool factory derives schemas from resource.contract automatically,
+ * ensuring type safety and eliminating manual schema duplication.
+ */
+export interface ResourceInvocationToolConfig {
+  /** Tool name for LLM selection (e.g., 'invoke_lead_validation') */
+  name: string
+
+  /** Description of what the tool does (shown to LLM) */
+  description: string
+
+  /** Target resource definition - schemas derived automatically from contract */
+  resource: ResourceDefinition
+}
+
+/**
+ * Create a tool that invokes another resource (agent or workflow)
+ *
+ * Schemas are derived directly from the resource's contract:
+ * - inputSchema: From resource.contract.inputSchema
+ * - outputSchema: From resource.contract.outputSchema (or z.null() if not defined)
+ *
+ * This ensures type safety and eliminates schema duplication.
+ *
+ * @param config - Tool configuration with name, description, and target resource
+ * @returns Tool that invokes the resource via ResourceInvocationService
+ *
+ * @example
+ * // Invoke workflow with derived schemas
+ * const leadValidationTool = createResourceInvocationTool({
+ *   name: 'invoke_lead_validation',
+ *   description: 'Validate scraped lead data for completeness and format',
+ *   resource: leadValidationWorkflow  // Schemas derived from contract
+ * })
+ *
+ * @example
+ * // Invoke agent with derived schemas
+ * const companyResearchTool = createResourceInvocationTool({
+ *   name: 'invoke_company_research',
+ *   description: 'Research company details using AI reasoning',
+ *   resource: companyResearchAgent  // Schemas derived from contract
+ * })
+ */
+export function createResourceInvocationTool(
+  config: ResourceInvocationToolConfig
+): Tool {
+  const { resource } = config
+
+  // Derive schemas from resource contract - no manual duplication
+  const inputSchema = resource.contract.inputSchema
+  const outputSchema = resource.contract.outputSchema ?? z.null()
+
+  return {
+    name: config.name,
+    description: config.description,
+    inputSchema,
+    outputSchema,
+    timeout: DEFAULT_RESOURCE_INVOCATION_TIMEOUT,
+
+    async execute(options: ToolExecutionOptions): Promise<unknown> {
+      // Get resource invocation service from global registry
+      const { resourceInvocationService } = getToolServices()
+
+      if (!resourceInvocationService) {
+        throw serviceUnavailable('ResourceInvocationService')
+      }
+
+      if (!options.executionContext) {
+        throw serviceUnavailable('ExecutionContext', { tool: config.name, reason: 'organizationId required for multi-tenant isolation' })
+      }
+
+      // Execute resource and get result
+      // organizationName is guaranteed to be present in ExecutionContext (extends ExecutionMetadata)
+      const result = await resourceInvocationService.executeSync(
+        resource.config.resourceId,
+        options.input,
+        options.executionContext.organizationName,
+        options.executionContext
+      )
+
+      // Throw error if execution failed
+      if (!result.success) {
+        throw apiError(result.error || `${result.resourceType} execution failed`)
+      }
+
+      // Return output (null for fire-and-forget resources without outputSchema)
+      return result.output
+    }
+  }
+}

package/src/execution/engine/tools/platform/resource-invocation/types.ts

@@ -0,0 +1,31 @@
+/**
+ * Resource execution request parameters
+ * Contains resource identification and input payload for execution
+ */
+export interface ResourceExecutionRequest {
+  /** Resource ID to execute (agent or workflow) */
+  resourceId: string
+  /** Input payload for the resource (validated against resource contract) */
+  input: unknown
+  /** Organization ID for multi-tenancy isolation */
+  organizationId: string
+  /** Organization name for resource lookup */
+  organizationName: string
+}
+
+/**
+ * Resource invocation result
+ * Returned from executeSync() after resource execution completes
+ */
+export interface ResourceInvocationResult {
+  /** Whether execution succeeded */
+  success: boolean
+  /** Output from resource (TOutput from contract, or null if no outputSchema) */
+  output: unknown
+  /** Execution ID for tracking and observability */
+  executionId: string
+  /** Type of resource executed (agent or workflow) */
+  resourceType: 'agent' | 'workflow'
+  /** Error message if execution failed */
+  error?: string
+}

package/src/execution/engine/tools/platform/scheduler.ts

@@ -0,0 +1,87 @@
+import type { Tool, ToolExecutionOptions } from '../types'
+import { serviceUnavailable } from '../types'
+import type { CreateScheduleInput, AbsoluteScheduleConfig } from '../../../scheduler/types'
+import { getToolServices } from '../registry'
+import type { SchedulerToolConfig } from './types'
+
+/**
+ * Create a scheduler tool that schedules future execution of agents/workflows
+ *
+ * Scheduler tools enable time-based automation by creating scheduled tasks that
+ * execute at a specific time. The task contains the input payload and routes to
+ * the specified resource.
+ *
+ * @param config - Configuration for the scheduler tool
+ * @returns Tool that creates scheduled tasks
+ *
+ * @example
+ * const schedulerTool = createSchedulerTool({
+ *   name: 'schedule_followup',
+ *   description: 'Schedule a follow-up task for later',
+ *   inputSchema: z.object({ message: z.string(), recipientId: z.string() }),
+ *   outputSchema: z.object({ taskId: z.string() }),
+ *   targetResourceId: 'followup-agent',
+ *   targetResourceType: 'agent',
+ *   runAt: new Date(Date.now() + 86400000), // 24 hours from now
+ *   maxRetries: 3
+ * })
+ */
+export function createSchedulerTool(config: SchedulerToolConfig): 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 task scheduler service from global registry
+      const { taskSchedulerService: taskScheduler } = getToolServices()
+      if (!taskScheduler) {
+        throw serviceUnavailable('TaskSchedulerService', {
+          message: 'Ensure toolServicesRegistry.initialize() was called in apps/api/src/main.ts',
+          tool: config.name
+        })
+      }
+
+      // Convert simple runAt to AbsoluteScheduleConfig (single-item schedule)
+      const scheduleConfig: AbsoluteScheduleConfig = {
+        type: 'absolute',
+        items: [{
+          runAt: config.runAt.toISOString(),
+          payload: options.input as Record<string, unknown>,
+          label: config.taskDescription
+        }]
+      }
+
+      // Build schedule input using execution context
+      const scheduleInput: CreateScheduleInput = {
+        organizationId: options.executionContext.organizationId,
+        name: config.taskDescription ?? `Scheduled: ${config.name}`,
+        description: `Created by ${config.name} tool`,
+        target: {
+          resourceType: config.targetResourceType,
+          resourceId: config.targetResourceId
+        },
+        scheduleConfig,
+        maxRetries: config.maxRetries ?? 3,
+        idempotencyKey: config.idempotencyKey,
+
+        // Origin tracking
+        originExecutionId: options.executionContext.executionId,
+        originResourceType: 'agent',
+        originResourceId: options.executionContext.resourceId
+      }
+
+      // Create schedule (returns TaskSchedule)
+      const schedule = await taskScheduler.createSchedule(scheduleInput)
+
+      // Return schedule ID for tracking (unchanged return shape)
+      return { taskId: schedule.id }
+    }
+  }
+}

package/src/execution/engine/tools/platform/schedules/cancel-by-key-tool.ts

@@ -0,0 +1,48 @@
+/**
+ * Schedule Cancel by Key Tool
+ *
+ * Cancel a single schedule by its idempotency key (soft delete).
+ * Finds the schedule by key and cancels it. No-op if not found.
+ */
+
+import { getToolServices } from '../../registry'
+import type { Tool } from '../../types'
+import { serviceUnavailable } from '../../types'
+import { CancelScheduleByKeyInputSchema, CancelScheduleByKeyOutputSchema } from './types'
+import type { CancelScheduleByKeyInput } from './types'
+
+export function createScheduleCancelByKeyTool(): Tool {
+  return {
+    name: 'schedule_cancel_by_key',
+    description: 'Cancel a schedule by its idempotency key (soft delete). Sets status to cancelled. Returns whether a schedule was found and cancelled.',
+    inputSchema: CancelScheduleByKeyInputSchema,
+    outputSchema: CancelScheduleByKeyOutputSchema,
+    async execute({ input, executionContext }) {
+      if (!executionContext?.organizationId) {
+        throw serviceUnavailable('ExecutionContext', { tool: 'schedule_cancel_by_key', reason: 'organizationId required for multi-tenant isolation' })
+      }
+
+      const { taskSchedulerService } = getToolServices()
+      if (!taskSchedulerService) {
+        throw serviceUnavailable('TaskSchedulerService', {
+          message: 'Ensure toolServicesRegistry.initialize() was called in apps/api/src/main.ts',
+          tool: 'schedule_cancel_by_key'
+        })
+      }
+
+      const { idempotencyKey } = input as CancelScheduleByKeyInput
+
+      const schedule = await taskSchedulerService.findByIdempotencyKey(
+        executionContext.organizationId,
+        idempotencyKey
+      )
+
+      if (!schedule) {
+        return { cancelled: false }
+      }
+
+      await taskSchedulerService.cancelSchedule(schedule.id, executionContext.organizationId)
+      return { cancelled: true }
+    }
+  }
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Schedule Cancel by Metadata Tool
+ *
+ * Batch cancel (soft delete) task schedules matching metadata filters.
+ * Sets status to 'cancelled' and clears next_run_at.
+ */
+
+import { getToolServices } from '../../registry'
+import type { Tool } from '../../types'
+import { serviceUnavailable } from '../../types'
+import { CancelSchedulesByMetadataInputSchema, CancelSchedulesByMetadataOutputSchema } from './types'
+import type { CancelSchedulesByMetadataInput } from './types'
+
+export function createScheduleCancelByMetadataTool(): Tool {
+  return {
+    name: 'schedule_cancel_by_metadata',
+    description: 'Cancel all active schedules matching metadata filters. Performs a soft delete (sets status to cancelled). Use for batch cleanup when a contact unsubscribes or a deal is closed.',
+    inputSchema: CancelSchedulesByMetadataInputSchema,
+    outputSchema: CancelSchedulesByMetadataOutputSchema,
+    async execute({ input, executionContext }) {
+      if (!executionContext?.organizationId) {
+        throw serviceUnavailable('ExecutionContext', { tool: 'schedule_cancel_by_metadata', reason: 'organizationId required for multi-tenant isolation' })
+      }
+
+      const { taskSchedulerService } = getToolServices()
+      if (!taskSchedulerService) {
+        throw serviceUnavailable('TaskSchedulerService', {
+          message: 'Ensure toolServicesRegistry.initialize() was called in apps/api/src/main.ts',
+          tool: 'schedule_cancel_by_metadata'
+        })
+      }
+
+      const { metadata, status } = input as CancelSchedulesByMetadataInput
+
+      return taskSchedulerService.cancelSchedulesByMetadata(
+        executionContext.organizationId,
+        metadata,
+        status
+      )
+    }
+  }
+}

package/src/execution/engine/tools/platform/schedules/delete-by-key-tool.ts

@@ -0,0 +1,43 @@
+/**
+ * Schedule Delete by Key Tool
+ *
+ * Hard delete a schedule by its idempotency key.
+ * Removes the schedule from the database entirely so the key can be reused.
+ */
+
+import { getToolServices } from '../../registry'
+import type { Tool } from '../../types'
+import { serviceUnavailable } from '../../types'
+import { DeleteScheduleByKeyInputSchema, DeleteScheduleByKeyOutputSchema } from './types'
+import type { DeleteScheduleByKeyInput } from './types'
+
+export function createScheduleDeleteByKeyTool(): Tool {
+  return {
+    name: 'schedule_delete_by_key',
+    description: 'Hard delete a schedule by its idempotency key. Removes it from the database entirely so the key can be reused for a new schedule.',
+    inputSchema: DeleteScheduleByKeyInputSchema,
+    outputSchema: DeleteScheduleByKeyOutputSchema,
+    async execute({ input, executionContext }) {
+      if (!executionContext?.organizationId) {
+        throw serviceUnavailable('ExecutionContext', { tool: 'schedule_delete_by_key', reason: 'organizationId required for multi-tenant isolation' })
+      }
+
+      const { taskSchedulerService } = getToolServices()
+      if (!taskSchedulerService) {
+        throw serviceUnavailable('TaskSchedulerService', {
+          message: 'Ensure toolServicesRegistry.initialize() was called in apps/api/src/main.ts',
+          tool: 'schedule_delete_by_key'
+        })
+      }
+
+      const { idempotencyKey } = input as DeleteScheduleByKeyInput
+
+      await taskSchedulerService.deleteScheduleByIdempotencyKey(
+        idempotencyKey,
+        executionContext.organizationId
+      )
+
+      return { deleted: true }
+    }
+  }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Schedule Management Platform Tools
+ *
+ * Tools for querying, cancelling, and deleting task schedules.
+ * Enables agents to manage schedules without direct database access.
+ */
+
+export * from './types'
+
+export { createScheduleListTool } from './list-tool'
+export { createScheduleCancelByMetadataTool } from './cancel-by-metadata-tool'
+export { createScheduleCancelByKeyTool } from './cancel-by-key-tool'
+export { createScheduleDeleteByKeyTool } from './delete-by-key-tool'

package/src/execution/engine/tools/platform/schedules/list-tool.ts

@@ -0,0 +1,56 @@
+/**
+ * Schedule List Tool
+ *
+ * List task schedules with optional metadata-based filtering.
+ * Supports JSONB containment queries for metadata fields.
+ */
+
+import { getToolServices } from '../../registry'
+import type { Tool } from '../../types'
+import { serviceUnavailable } from '../../types'
+import { ListSchedulesInputSchema, ListSchedulesOutputSchema } from './types'
+import type { ListSchedulesInput } from './types'
+
+export function createScheduleListTool(): Tool {
+  return {
+    name: 'schedule_list',
+    description: 'List task schedules with optional filters. Supports metadata-based JSONB filtering for finding schedules by contact email or other metadata fields.',
+    inputSchema: ListSchedulesInputSchema,
+    outputSchema: ListSchedulesOutputSchema,
+    async execute({ input, executionContext }) {
+      if (!executionContext?.organizationId) {
+        throw serviceUnavailable('ExecutionContext', { tool: 'schedule_list', reason: 'organizationId required for multi-tenant isolation' })
+      }
+
+      const { taskSchedulerService } = getToolServices()
+      if (!taskSchedulerService) {
+        throw serviceUnavailable('TaskSchedulerService', {
+          message: 'Ensure toolServicesRegistry.initialize() was called in apps/api/src/main.ts',
+          tool: 'schedule_list'
+        })
+      }
+
+      const { targetResourceId, status, metadata, limit } = input as ListSchedulesInput
+
+      const result = await taskSchedulerService.listSchedules({
+        organizationId: executionContext.organizationId,
+        targetResourceId,
+        status,
+        metadata,
+        limit
+      })
+
+      return {
+        schedules: result.schedules.map(s => ({
+          id: s.id,
+          name: s.name,
+          status: s.status,
+          nextRunAt: s.nextRunAt instanceof Date ? s.nextRunAt.toISOString() : s.nextRunAt ?? null,
+          idempotencyKey: s.idempotencyKey ?? null,
+          createdAt: s.createdAt instanceof Date ? s.createdAt.toISOString() : s.createdAt
+        })),
+        total: result.total
+      }
+    }
+  }
+}

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

@@ -0,0 +1,88 @@
+/**
+ * Schedule Management Tool Types
+ *
+ * Zod schemas for schedule management platform tools.
+ * These tools enable agents to query, cancel, and delete task schedules.
+ */
+
+import { z } from 'zod'
+
+// ============================================
+// List Schedules
+// ============================================
+
+export const ListSchedulesInputSchema = z.object({
+  /** Filter by target resource ID */
+  targetResourceId: z.string().optional(),
+  /** Filter by schedule status */
+  status: z.string().optional(),
+  /** JSONB containment filter for metadata (e.g., { contactEmail: 'user@example.com' }) */
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  /** Maximum results to return (1-100, default: 20) */
+  limit: z.number().min(1).max(100).default(20)
+})
+
+export const ListSchedulesOutputSchema = z.object({
+  schedules: z.array(z.object({
+    id: z.string(),
+    name: z.string(),
+    status: z.string(),
+    nextRunAt: z.string().nullable(),
+    idempotencyKey: z.string().nullable(),
+    createdAt: z.string()
+  })),
+  total: z.number()
+})
+
+export type ListSchedulesInput = z.infer<typeof ListSchedulesInputSchema>
+export type ListSchedulesOutput = z.infer<typeof ListSchedulesOutputSchema>
+
+// ============================================
+// Cancel Schedules by Metadata
+// ============================================
+
+export const CancelSchedulesByMetadataInputSchema = z.object({
+  /** JSONB containment filter for metadata (required) */
+  metadata: z.record(z.string(), z.unknown()),
+  /** Only cancel schedules with this status (default: 'active') */
+  status: z.string().default('active')
+})
+
+export const CancelSchedulesByMetadataOutputSchema = z.object({
+  cancelled: z.number()
+})
+
+export type CancelSchedulesByMetadataInput = z.infer<typeof CancelSchedulesByMetadataInputSchema>
+export type CancelSchedulesByMetadataOutput = z.infer<typeof CancelSchedulesByMetadataOutputSchema>
+
+// ============================================
+// Cancel Schedule by Idempotency Key
+// ============================================
+
+export const CancelScheduleByKeyInputSchema = z.object({
+  /** Idempotency key of the schedule to cancel */
+  idempotencyKey: z.string()
+})
+
+export const CancelScheduleByKeyOutputSchema = z.object({
+  cancelled: z.boolean()
+})
+
+export type CancelScheduleByKeyInput = z.infer<typeof CancelScheduleByKeyInputSchema>
+export type CancelScheduleByKeyOutput = z.infer<typeof CancelScheduleByKeyOutputSchema>
+
+// ============================================
+// Delete Schedule by Idempotency Key
+// ============================================
+
+export const DeleteScheduleByKeyInputSchema = z.object({
+  /** Idempotency key of the schedule to hard-delete */
+  idempotencyKey: z.string()
+})
+
+export const DeleteScheduleByKeyOutputSchema = z.object({
+  deleted: z.boolean()
+})
+
+export type DeleteScheduleByKeyInput = z.infer<typeof DeleteScheduleByKeyInputSchema>
+export type DeleteScheduleByKeyOutput = z.infer<typeof DeleteScheduleByKeyOutputSchema>