@elevasis/core 0.1.0 → 0.2.1

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

@@ -1,147 +0,0 @@
-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

@@ -1,115 +0,0 @@
-/**
- * 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

@@ -1,31 +0,0 @@
-/**
- * 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
-}