find_implementation_requirements

Instructions

Implementation Reference

• src/tools/find-implementation-requirements.ts:62-117 (handler)

  Main handler: executes the tool by querying the API manager for requirements and formatting the response in agent_ready, summary, or detailed format.

  async execute(args: FindImplementationRequirementsArgs) {
    try {
      const context = {
        domain: args.domain,
        complexity_level: args.complexity_level || 'intermediate'
      };
  
      const requirements = await this.apiManager.findImplementationRequirements(args.feature, context);
  
      const format = args.format || 'agent_ready';
  
      switch (format) {
        case 'agent_ready':
          return {
            content: [
              {
                type: 'text',
                text: JSON.stringify(this.formatForAgent(requirements, args), null, 2)
              }
            ]
          };
  
        case 'summary':
          return {
            content: [
              {
                type: 'text',
                text: this.formatSummary(requirements, args)
              }
            ]
          };
  
        case 'detailed':
        default:
          return {
            content: [
              {
                type: 'text',
                text: this.formatDetailed(requirements, args)
              }
            ]
          };
      }
  
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error finding implementation requirements: ${error instanceof Error ? error.message : 'Unknown error'}`
          }
        ],
        isError: true
      };
    }
  }

• src/tools/find-implementation-requirements.ts:19-60 (schema)

  Tool definition including input schema for validation and tool metadata.

  getDefinition() {
    return {
      name: 'find_implementation_requirements',
      description: 'Extract detailed implementation requirements for specific 3GPP features, including mandatory/optional requirements, dependencies, and implementation guidance.',
      inputSchema: {
        type: 'object',
        properties: {
          feature: {
            type: 'string',
            description: 'The feature or functionality to analyze (e.g., "CHF implementation", "5G handover", "SUCI privacy protection")'
          },
          domain: {
            type: 'string',
            description: 'Specific domain context (e.g., "charging", "security", "mobility", "radio")'
          },
          complexity_level: {
            type: 'string',
            enum: ['basic', 'intermediate', 'advanced'],
            description: 'Implementation complexity level (default: intermediate)',
            default: 'intermediate'
          },
          include_dependencies: {
            type: 'boolean',
            description: 'Include dependency analysis and prerequisite requirements (default: true)',
            default: true
          },
          include_testing_guidance: {
            type: 'boolean',
            description: 'Include testing and validation guidance (default: true)',
            default: true
          },
          format: {
            type: 'string',
            enum: ['detailed', 'summary', 'agent_ready'],
            description: 'Response format - agent_ready provides structured JSON for AI agents',
            default: 'agent_ready'
          }
        },
        required: ['feature']
      }
    };
  }

• src/index.ts:85-93 (registration)

  Registration in listTools handler: includes requirementsTool.getDefinition().

  this.server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: [
        this.searchTool.getDefinition(),
        this.detailsTool.getDefinition(),
        this.compareTool.getDefinition(),
        this.requirementsTool.getDefinition()
      ]
    };

• src/index.ts:110-112 (registration)

  Dispatch registration in callTool handler: routes to requirementsTool.execute.

  case 'find_implementation_requirements':
    return await this.requirementsTool.execute(args as unknown as FindImplementationRequirementsArgs);

• src/api/api-manager.ts:163-202 (helper)

  Backend helper method in APIManager that performs the core search and extraction of implementation requirements using TSpec-LLM and 3GPP API.

  async findImplementationRequirements(feature: string, context?: {
    domain?: string;
    complexity_level?: 'basic' | 'intermediate' | 'advanced';
  }): Promise<{
    requirements: any[];
    related_specifications: SpecificationMetadata[];
    implementation_guidance: string[];
  }> {
    try {
      const searchQuery = `${feature} implementation requirements ${context?.domain || ''}`;
  
      // Search TSpec-LLM for implementation details
      const tspecResults = await this.tspecClient.searchSpecifications({
        query: searchQuery,
        max_results: 10
      });
  
      // Extract requirements from content
      const requirements = this.extractRequirements(tspecResults);
  
      // Find related specifications
      const relatedSpecs = await this.tgppClient.searchSpecifications(feature);
  
      // Generate implementation guidance
      const implementationGuidance = this.generateImplementationGuidance(
        feature,
        tspecResults,
        context
      );
  
      return {
        requirements,
        related_specifications: relatedSpecs,
        implementation_guidance: implementationGuidance
      };
  
    } catch (error) {
      throw new Error(`Failed to find implementation requirements: ${error instanceof Error ? error.message : 'Unknown error'}`);
    }
  }