mcp-execution-codegen 0.7.1

TypeScript code generation with progressive loading for MCP tools
Documentation

mcp-execution-codegen

Crates.io docs.rs codecov MSRV License

Progressive loading TypeScript code generation for MCP tools. Achieves 98% token savings by generating one file per tool.

Installation

[dependencies]
mcp-execution-codegen = "0.7"

Or with cargo-add:

cargo add mcp-execution-codegen

[!IMPORTANT] Requires Rust 1.91 or later.

Usage

Progressive Loading Generation

use mcp_execution_codegen::progressive::ProgressiveGenerator;
use mcp_execution_introspector::Introspector;
use mcp_execution_core::{ServerId, ServerConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Introspect MCP server
    let mut introspector = Introspector::new();
    let server_id = ServerId::new("github");
    let config = ServerConfig::builder()
        .command("github-mcp-execution-server".to_string())
        .build();
    let info = introspector.discover_server(server_id, &config).await?;

    // 2. Generate progressive loading files
    let generator = ProgressiveGenerator::new()?;
    let code = generator.generate(&info)?;

    println!("Generated {} files", code.file_count());
    Ok(())
}

[!TIP] Generated files include: one .ts file per tool, index.ts re-exports, and _runtime/mcp-bridge.ts helper.

Token Savings

Approach Tokens Savings
Traditional (all tools) ~30,000 -
Progressive (1 tool) ~500-1,500 98%

Generated TypeScript Structure

Each tool file includes full TypeScript interfaces:

/**
 * Creates a new issue in a GitHub repository
 * @param params - Tool parameters
 * @returns Tool execution result
 */
export async function createIssue(
  params: CreateIssueParams
): Promise<CreateIssueResult> {
  return await callMCPTool('github', 'create_issue', params);
}

export interface CreateIssueParams {
  /** Repository in format "owner/repo" */
  repo: string;
  /** Issue title */
  title: string;
  /** Issue body (optional) */
  body?: string;
}

Features

  • One File Per Tool: Separate TypeScript file for each MCP tool
  • Type-Safe Interfaces: Full TypeScript parameter and result types
  • JSDoc Documentation: Complete documentation from MCP schemas
  • 98% Token Savings: Load only the tools you need
  • Handlebars Templates: Customizable code generation

Type Conversion

JSON Schema types are converted to TypeScript:

JSON Schema TypeScript
string string
number number
boolean boolean
array T[]
object { [key: string]: T }

[!NOTE] Optional parameters use ? suffix in TypeScript interfaces.

Performance

Metric Target Achieved
10 tools <100ms 0.19ms (526x faster)
50 tools <20ms 0.97ms (20.6x faster)
VFS export <10ms 1.2ms (8.3x faster)

Security

[!IMPORTANT] All server-controlled strings are sanitized before interpolation into generated TypeScript.

The code generator applies JSDoc sanitization to every field that originates from an MCP server:

  • Tool name and description (truncated to 256 chars, */ escaped, CR/LF stripped)
  • Server name and version (same rules, version truncated to 64 chars)
  • Every description field inside input_schema JSON recursively
  • Categorization fields: category (128 chars), keywords, short_description (256 chars each)
  • Non-string description values in schemas are replaced with null

This prevents malicious MCP servers from injecting arbitrary TypeScript by embedding */ in their metadata.

Related Crates

This crate is part of the mcp-execution workspace:

MSRV Policy

Minimum Supported Rust Version: 1.91

MSRV increases are considered minor version bumps.

License

Licensed under either of Apache License 2.0 or MIT license at your option.