get_specification_details

Instructions

Implementation Reference

• src/tools/get-specification-details.ts:50-100 (handler)

  The main handler function that executes the tool logic: fetches specification details via API manager and formats the response according to the specified format (agent_ready, summary, detailed).

  async execute(args: GetSpecificationDetailsArgs) {
    try {
      const details = await this.apiManager.getSpecificationDetails(args.specification_id);
  
      const format = args.format || 'agent_ready';
  
      switch (format) {
        case 'agent_ready':
          return {
            content: [
              {
                type: 'text',
                text: JSON.stringify(this.formatForAgent(details, args), null, 2)
              }
            ]
          };
  
        case 'summary':
          return {
            content: [
              {
                type: 'text',
                text: this.formatSummary(details, args)
              }
            ]
          };
  
        case 'detailed':
        default:
          return {
            content: [
              {
                type: 'text',
                text: this.formatDetailed(details, args)
              }
            ]
          };
      }
  
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error retrieving specification details: ${error instanceof Error ? error.message : 'Unknown error'}`
          }
        ],
        isError: true
      };
    }
  }

• src/tools/get-specification-details.ts:17-48 (schema)

  Tool definition including name, description, and inputSchema for validation (specification_id required, optional flags for content/dependencies/format). Also defines the TypeScript interface GetSpecificationDetailsArgs above.

  getDefinition() {
    return {
      name: 'get_specification_details',
      description: 'Get comprehensive details about a specific 3GPP specification including metadata, content, dependencies, and related information.',
      inputSchema: {
        type: 'object',
        properties: {
          specification_id: {
            type: 'string',
            description: 'The specification ID (e.g., "TS 32.290", "TS 38.331", "TS 33.501")'
          },
          include_content: {
            type: 'boolean',
            description: 'Include detailed content from TSpec-LLM dataset (default: true)',
            default: true
          },
          include_dependencies: {
            type: 'boolean',
            description: 'Include information about specification dependencies (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: ['specification_id']
      }
    };
  }

• src/index.ts:104-105 (registration)

  Registration in the MCP server's CallToolRequest handler: dispatches execution to the tool instance based on name.

  case 'get_specification_details':
    return await this.detailsTool.execute(args as unknown as GetSpecificationDetailsArgs);

• src/index.ts:79-79 (registration)

  Instantiation of the GetSpecificationDetailsTool instance with APIManager dependency.

  this.detailsTool = new GetSpecificationDetailsTool(this.apiManager);

• src/index.ts:88-89 (registration)

  Tool definition included in the ListTools response for MCP server discovery.

  this.searchTool.getDefinition(),
  this.detailsTool.getDefinition(),

• src/tools/get-specification-details.ts:102-159 (helper)

  Primary helper for formatting output in 'agent_ready' mode: structures specification metadata, working group info, release details, dependencies, content sections, and implementation guidance into JSON.

  private formatForAgent(details: any, args: GetSpecificationDetailsArgs): any {
    const result: any = {
      specification: {
        id: details.metadata.id,
        title: details.metadata.title,
        version: details.metadata.version,
        release: details.metadata.release,
        working_group: details.metadata.working_group,
        status: details.metadata.status,
        publication_date: details.metadata.publication_date,
        summary: details.metadata.summary,
        keywords: details.metadata.keywords
      },
  
      working_group: {
        name: details.working_group.name,
        full_name: details.working_group.full_name,
        focus_area: details.working_group.focus_area,
        related_specifications: details.working_group.specifications
      },
  
      release_info: {
        release: details.release.release,
        freeze_date: details.release.freeze_date,
        status: details.release.status,
        major_features: details.release.major_features
      }
    };
  
    if (args.include_dependencies !== false) {
      result.dependencies = {
        direct_dependencies: details.metadata.dependencies,
        dependency_analysis: this.analyzeDependencies(details.metadata.dependencies)
      };
    }
  
    if (args.include_content !== false && details.tspec_content) {
      result.content = {
        total_sections: details.tspec_content.results.length,
        sections: details.tspec_content.results.map((section: any) => ({
          section: section.section,
          content: section.content,
          relevance_score: section.relevance_score,
          keywords: section.metadata.keywords
        }))
      };
    }
  
    result.implementation_guidance = {
      complexity_level: this.assessComplexity(details),
      implementation_priority: this.getImplementationPriority(details),
      recommended_prerequisites: this.getPrerequisites(details),
      common_use_cases: this.getCommonUseCases(details),
      testing_considerations: this.getTestingConsiderations(details)
    };
  
    return result;
  }