openpets 1.0.11 → 1.0.12

package/dist/src/core/mcp-generator.js

@@ -0,0 +1,1438 @@
+/**
+ * MCP Tool Generator
+ *
+ * Generates OpenPets-compatible tool definitions from a remote MCP server.
+ * Similar to how hey-api generates TypeScript clients from OpenAPI specs.
+ *
+ * Usage:
+ *   pets generate-mcp           # Run from inside a pet directory with mcpServer in package.json
+ *   pets generate-mcp --output mcp-tools.ts  # Custom output file
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve, basename } from "path";
+import { config as loadDotenv } from "dotenv";
+import { createLogger } from "./logger";
+const logger = createLogger("mcp-generator");
+function loadMCPConfigFromPackageJson(dir) {
+    const packageJsonPath = resolve(dir, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (!packageJson.mcpServer) {
+            return null;
+        }
+        // Extract pet name from package name or directory
+        const petName = packageJson.name?.replace(/^@openpets\//, "") || basename(dir);
+        // Load .env files
+        loadDotenv({ path: resolve(dir, ".env") });
+        loadDotenv({ path: resolve(dir, "../.env") });
+        loadDotenv({ path: resolve(dir, "../../.env") });
+        // Get auth token from environment
+        const envVarName = `${petName.toUpperCase().replace(/-/g, "_")}_ACCESS_TOKEN`;
+        const authToken = process.env[envVarName];
+        // Check for custom auth env var name, otherwise derive from pet name
+        const customAuthEnvVar = packageJson.mcpServer.authEnvVar;
+        const authEnvVarName = customAuthEnvVar || envVarName;
+        const resolvedAuthToken = process.env[authEnvVarName] || authToken;
+        return {
+            config: {
+                url: packageJson.mcpServer.url,
+                name: packageJson.mcpServer.name || petName,
+                version: packageJson.mcpServer.version,
+                npmPackage: packageJson.mcpServer.npmPackage,
+                stdioCommand: packageJson.mcpServer.stdioCommand,
+                stdioArgs: packageJson.mcpServer.stdioArgs,
+                transport: packageJson.mcpServer.transport,
+                dockerImage: packageJson.mcpServer.dockerImage,
+                dockerEnvVar: packageJson.mcpServer.dockerEnvVar,
+                authHeader: packageJson.mcpServer.authHeader,
+                authEnvVar: authEnvVarName,
+                stdioEnvVar: packageJson.mcpServer.stdioEnvVar,
+            },
+            petName,
+            authToken: resolvedAuthToken,
+        };
+    }
+    catch (error) {
+        logger.error(`Error reading package.json: ${error.message}`);
+        return null;
+    }
+}
+async function connectToMCPServer(config, authToken) {
+    const client = new Client({
+        name: "openpets-generator",
+        version: "1.0.0",
+    });
+    let transport;
+    switch (config.transport) {
+        case "sse-remote": {
+            // Use mcp-remote for OAuth-based remote MCP servers (like Asana)
+            // This will open a browser for OAuth authentication
+            logger.debug(`Connecting via mcp-remote to: ${config.url}`);
+            console.log(`\n🔐 OAuth authentication required. A browser window will open...`);
+            transport = new StdioClientTransport({
+                command: "bunx",
+                args: ["mcp-remote", config.url],
+            });
+            break;
+        }
+        case "docker": {
+            // Use Docker container with environment variable authentication
+            // Example: GitHub MCP server at ghcr.io/github/github-mcp-server
+            const dockerImage = config.dockerImage || `ghcr.io/${config.name}/${config.name}-mcp-server`;
+            // dockerEnvVar is what the container expects, authEnvVar is what we read from .env
+            const containerEnvVar = config.dockerEnvVar || config.authEnvVar || `${config.name?.toUpperCase().replace(/-/g, "_")}_PERSONAL_ACCESS_TOKEN`;
+            const sourceEnvVar = config.authEnvVar || containerEnvVar;
+            if (!authToken) {
+                throw new Error(`Missing ${sourceEnvVar} environment variable for Docker transport`);
+            }
+            logger.debug(`Connecting via Docker: ${dockerImage}`);
+            console.log(`\n🐳 Connecting to Docker MCP server: ${dockerImage}`);
+            transport = new StdioClientTransport({
+                command: "docker",
+                args: [
+                    "run", "-i", "--rm",
+                    "-e", containerEnvVar,
+                    dockerImage,
+                ],
+                env: {
+                    ...process.env,
+                    [containerEnvVar]: authToken,
+                },
+            });
+            break;
+        }
+        case "http": {
+            // Use HTTP/SSE transport with Bearer token authentication
+            // Example: GitHub Copilot MCP at https://api.githubcopilot.com/mcp/
+            if (!config.url) {
+                throw new Error("URL is required for HTTP transport");
+            }
+            const headers = {};
+            if (authToken) {
+                const headerName = config.authHeader || "Authorization";
+                headers[headerName] = `Bearer ${authToken}`;
+            }
+            logger.debug(`Connecting via HTTP to: ${config.url}`);
+            console.log(`\n🌐 Connecting to HTTP MCP server: ${config.url}`);
+            // Try StreamableHTTP first, fall back to SSE
+            try {
+                transport = new StreamableHTTPClientTransport(new URL(config.url), {
+                    requestInit: { headers },
+                });
+                await client.connect(transport);
+                logger.debug("Connected via Streamable HTTP transport");
+            }
+            catch (httpError) {
+                logger.debug(`Streamable HTTP failed: ${httpError.message}, trying SSE...`);
+                transport = new SSEClientTransport(new URL(config.url), {
+                    requestInit: { headers },
+                });
+                await client.connect(transport);
+                logger.debug("Connected via SSE transport");
+            }
+            const toolsResponse = await client.listTools();
+            return { client, tools: toolsResponse.tools };
+        }
+        default: {
+            // Default: stdio transport with npm package and access token
+            const npmPackage = config.npmPackage || `@${config.name}/mcp-server`;
+            const args = config.stdioArgs ? [...config.stdioArgs] : [npmPackage];
+            // Build environment for the subprocess
+            const env = { ...process.env };
+            // Pass auth token either via command line arg or environment variable
+            if (authToken) {
+                if (config.stdioEnvVar) {
+                    // Pass token via environment variable (e.g., NOTION_TOKEN for Notion MCP server)
+                    env[config.stdioEnvVar] = authToken;
+                    logger.debug(`Passing token via env var: ${config.stdioEnvVar}`);
+                }
+                else if (!args.some(arg => arg.includes('access-token'))) {
+                    // Default: pass token via command line argument
+                    args.push(`--access-token=${authToken}`);
+                }
+            }
+            const command = config.stdioCommand || "bunx";
+            logger.debug(`Connecting via stdio: ${command} ${args.join(" ")}`);
+            transport = new StdioClientTransport({
+                command,
+                args,
+                env,
+            });
+            break;
+        }
+    }
+    await client.connect(transport);
+    const toolsResponse = await client.listTools();
+    return { client, tools: toolsResponse.tools };
+}
+/**
+ * Generate a verbose description for a nested object schema.
+ * This extracts property names, types, descriptions, and required fields
+ * to provide helpful context for JSON object parameters.
+ */
+function generateNestedObjectDescription(prop, maxDepth = 2) {
+    if (!prop || prop.type !== "object" || !prop.properties) {
+        return prop?.description || prop?.title || "JSON object";
+    }
+    const parts = [];
+    // Add base description if present
+    if (prop.description) {
+        parts.push(prop.description);
+    }
+    else if (prop.title) {
+        parts.push(prop.title);
+    }
+    const required = prop.required || [];
+    const propDescriptions = [];
+    for (const [name, schema] of Object.entries(prop.properties)) {
+        const isRequired = required.includes(name);
+        const requiredMarker = isRequired ? " (required)" : "";
+        let typeDesc = schema.type || "any";
+        // Handle enums
+        if (schema.enum && schema.enum.length > 0) {
+            const enumVals = schema.enum.slice(0, 5).map((v) => JSON.stringify(v)).join(", ");
+            const more = schema.enum.length > 5 ? `, ... (${schema.enum.length} total)` : "";
+            typeDesc = `enum: [${enumVals}${more}]`;
+        }
+        // Handle anyOf (nullable/union types)
+        if (schema.anyOf) {
+            const types = schema.anyOf
+                .map((s) => s.type || (s.enum ? "enum" : "any"))
+                .filter((t) => t !== "null");
+            typeDesc = types.join(" | ") || "any";
+        }
+        // Handle arrays
+        if (schema.type === "array" && schema.items) {
+            typeDesc = `array of ${schema.items.type || "objects"}`;
+        }
+        // Handle nested objects (but limit depth)
+        if (schema.type === "object" && schema.properties && maxDepth > 0) {
+            const nestedProps = Object.keys(schema.properties).slice(0, 5);
+            const more = Object.keys(schema.properties).length > 5 ? ", ..." : "";
+            typeDesc = `object with: {${nestedProps.join(", ")}${more}}`;
+        }
+        // Build property description
+        let propDesc = `${name}${requiredMarker}: ${typeDesc}`;
+        if (schema.description) {
+            propDesc += ` - ${schema.description.substring(0, 80)}${schema.description.length > 80 ? "..." : ""}`;
+        }
+        if (schema.default !== undefined) {
+            propDesc += ` (default: ${JSON.stringify(schema.default)})`;
+        }
+        propDescriptions.push(propDesc);
+    }
+    if (propDescriptions.length > 0) {
+        parts.push("Properties: " + propDescriptions.join("; "));
+    }
+    return parts.join(". ") || "JSON object";
+}
+function jsonSchemaToZod(prop) {
+    if (!prop)
+        return "z.any()";
+    const desc = prop.description
+        ? `.describe(${JSON.stringify(prop.description)})`
+        : "";
+    // Handle anyOf (nullable/union types) - common in MCP schemas
+    if (prop.anyOf && Array.isArray(prop.anyOf)) {
+        // Filter out null type to find the actual type
+        const nonNullTypes = prop.anyOf.filter((s) => s.type !== "null");
+        if (nonNullTypes.length === 1) {
+            // Simple nullable type - use the non-null type
+            const actualType = nonNullTypes[0];
+            // Check for enum in the actual type
+            if (actualType.enum && actualType.enum.length > 0) {
+                // Limit enum values for readability
+                const enumVals = actualType.enum.slice(0, 10);
+                const enumValues = enumVals.map((v) => JSON.stringify(v)).join(", ");
+                const more = actualType.enum.length > 10 ? ` /* +${actualType.enum.length - 10} more */` : "";
+                return `z.enum([${enumValues}${more}])${desc}`;
+            }
+            // Recursively get the zod type for the actual type
+            return jsonSchemaToZod({ ...actualType, description: prop.description });
+        }
+        if (nonNullTypes.length > 1) {
+            // Multiple types - try to pick the most useful one
+            const stringType = nonNullTypes.find((t) => t.type === "string");
+            const arrayType = nonNullTypes.find((t) => t.type === "array");
+            if (stringType && arrayType) {
+                // Common pattern: string | string[] - use array of strings
+                if (arrayType.items?.type === "string") {
+                    return `z.array(z.string())${desc}`;
+                }
+            }
+            // Fall back to any with description
+            return `z.any()${desc}`;
+        }
+    }
+    switch (prop.type) {
+        case "string":
+            if (prop.enum && prop.enum.length > 0) {
+                // Limit enum values for readability
+                const enumVals = prop.enum.slice(0, 10);
+                const enumValues = enumVals.map((v) => JSON.stringify(v)).join(", ");
+                const more = prop.enum.length > 10 ? ` /* +${prop.enum.length - 10} more */` : "";
+                return `z.enum([${enumValues}${more}])${desc}`;
+            }
+            return `z.string()${desc}`;
+        case "number":
+        case "integer":
+            return `z.number()${desc}`;
+        case "boolean":
+            return `z.boolean()${desc}`;
+        case "array":
+            if (prop.items?.type === "string") {
+                return `z.array(z.string())${desc}`;
+            }
+            else if (prop.items?.type === "number" || prop.items?.type === "integer") {
+                return `z.array(z.number())${desc}`;
+            }
+            // Check for enum items
+            if (prop.items?.enum && prop.items.enum.length > 0) {
+                const enumVals = prop.items.enum.slice(0, 10);
+                const enumValues = enumVals.map((v) => JSON.stringify(v)).join(", ");
+                const more = prop.items.enum.length > 10 ? ` /* +${prop.items.enum.length - 10} more */` : "";
+                return `z.array(z.enum([${enumValues}${more}]))${desc}`;
+            }
+            // For complex array items, use JSON string (OpenCode limitation)
+            const arrayDesc = prop.description
+                ? `.describe(${JSON.stringify("JSON array: " + prop.description)})`
+                : '.describe("JSON array")';
+            return `z.string()${arrayDesc}`;
+        case "object":
+            // For nested objects, generate a verbose description that includes
+            // property names, types, and descriptions for better AI context
+            const verboseDesc = generateNestedObjectDescription(prop);
+            return `z.string().describe(${JSON.stringify("JSON object: " + verboseDesc)})`;
+        default:
+            return `z.any()${desc}`;
+    }
+}
+/**
+ * Flatten nested object properties to top-level with prefixed names.
+ * This allows OpenCode to see and validate each parameter directly.
+ *
+ * Example: { queryParameters: { page: number, limit: number } }
+ * Becomes: { query_page: number, query_limit: number }
+ */
+function flattenProperties(properties, required, prefix = "") {
+    const flattened = [];
+    for (const [propName, propDef] of Object.entries(properties)) {
+        const isRequired = required.includes(propName);
+        const path = prefix ? [prefix, propName] : [propName];
+        // Check if this is a nested object that should be flattened
+        if (propDef.type === "object" && propDef.properties && Object.keys(propDef.properties).length > 0) {
+            // Determine prefix for flattened names
+            let flatPrefix;
+            if (propName === "queryParameters") {
+                flatPrefix = "query";
+            }
+            else if (propName === "pathParameters") {
+                flatPrefix = "path";
+            }
+            else if (propName === "body") {
+                flatPrefix = "body";
+            }
+            else {
+                flatPrefix = propName;
+            }
+            // Recursively flatten nested properties
+            const nestedRequired = propDef.required || [];
+            const nestedFlattened = flattenNestedProperties(propDef.properties, nestedRequired, flatPrefix, path, isRequired);
+            flattened.push(...nestedFlattened);
+        }
+        else {
+            // Non-object property, add directly
+            const flatName = prefix ? `${prefix}_${propName}` : propName;
+            flattened.push({
+                flatName,
+                originalPath: path,
+                zodType: jsonSchemaToZod(propDef),
+                isRequired
+            });
+        }
+    }
+    return flattened;
+}
+/**
+ * Flatten nested properties with proper path tracking
+ */
+function flattenNestedProperties(properties, required, prefix, parentPath, parentRequired) {
+    const flattened = [];
+    for (const [propName, propDef] of Object.entries(properties)) {
+        const isRequired = parentRequired && required.includes(propName);
+        const flatName = `${prefix}_${propName}`;
+        const path = [...parentPath, propName];
+        // For deeply nested objects, still flatten but use JSON string
+        // OpenCode has limitations on deeply nested schemas
+        if (propDef.type === "object" && propDef.properties && Object.keys(propDef.properties).length > 0) {
+            // For 2+ levels deep, use JSON string with verbose description
+            const verboseDesc = generateNestedObjectDescription(propDef);
+            flattened.push({
+                flatName,
+                originalPath: path,
+                zodType: `z.string().describe(${JSON.stringify("JSON object: " + verboseDesc)})`,
+                isRequired
+            });
+        }
+        else {
+            flattened.push({
+                flatName,
+                originalPath: path,
+                zodType: jsonSchemaToZod(propDef),
+                isRequired
+            });
+        }
+    }
+    return flattened;
+}
+/**
+ * Generate code to reconstruct nested structure from flattened args.
+ * Returns null if no reconstruction is needed.
+ */
+function generateReconstructionCode(flattenedProps) {
+    // Check if any reconstruction is needed
+    const needsReconstruction = flattenedProps.some(p => p.originalPath.length > 1);
+    if (!needsReconstruction) {
+        return null;
+    }
+    // Group by top-level property
+    const groups = {};
+    for (const prop of flattenedProps) {
+        const topLevel = prop.originalPath[0];
+        if (!groups[topLevel]) {
+            groups[topLevel] = [];
+        }
+        groups[topLevel].push(prop);
+    }
+    // Generate reconstruction code
+    const lines = ["      const mcpArgs: Record<string, any> = {}"];
+    for (const [topLevel, props] of Object.entries(groups)) {
+        if (props.every(p => p.originalPath.length === 1)) {
+            // Simple top-level property (shouldn't happen in flattened case)
+            const prop = props[0];
+            lines.push(`      if (args.${prop.flatName} !== undefined) mcpArgs.${topLevel} = args.${prop.flatName}`);
+        }
+        else {
+            // Nested properties need reconstruction
+            lines.push(`      const ${topLevel}Obj: Record<string, any> = {}`);
+            for (const prop of props) {
+                if (prop.originalPath.length > 1) {
+                    const nestedKey = prop.originalPath[prop.originalPath.length - 1];
+                    lines.push(`      if (args.${prop.flatName} !== undefined) ${topLevel}Obj.${nestedKey} = args.${prop.flatName}`);
+                }
+            }
+            lines.push(`      if (Object.keys(${topLevel}Obj).length > 0) mcpArgs.${topLevel} = ${topLevel}Obj`);
+        }
+    }
+    return lines.join("\n");
+}
+function generateToolDefinition(tool, petName) {
+    // Remove pet prefix from tool name if it already has one (e.g., asana_get_task -> get-task)
+    const toolNameWithoutPrefix = tool.name.replace(new RegExp(`^${petName}_`, 'i'), '');
+    const toolNameKebab = `${petName}-${toolNameWithoutPrefix.replace(/_/g, "-")}`;
+    const description = (tool.description || tool.title || `${tool.name} tool`)
+        .replace(/\\/g, "\\\\")
+        .replace(/`/g, "\\`")
+        .replace(/\$/g, "\\$");
+    // Get original properties
+    const properties = tool.inputSchema?.properties || {};
+    const required = tool.inputSchema?.required || [];
+    // Flatten nested properties for better OpenCode integration
+    const flattenedProps = flattenProperties(properties, required);
+    // Generate schema fields from flattened properties
+    const schemaFields = [];
+    for (const prop of flattenedProps) {
+        let zodType = prop.zodType;
+        if (!prop.isRequired && !zodType.includes(".optional()")) {
+            zodType = zodType + ".optional()";
+        }
+        schemaFields.push(`      ${prop.flatName}: ${zodType}`);
+    }
+    const schemaBody = schemaFields.length > 0
+        ? `z.object({\n${schemaFields.join(",\n")}\n    })`
+        : "z.object({})";
+    // Generate args reconstruction code if needed
+    const reconstructionCode = generateReconstructionCode(flattenedProps);
+    if (reconstructionCode) {
+        return `  {
+    name: "${toolNameKebab}",
+    description: \`${description}\`,
+    schema: ${schemaBody},
+    async execute(args) {
+      // Reconstruct nested structure from flattened args
+${reconstructionCode}
+      return callMCPTool("${tool.name}", mcpArgs)
+    }
+  }`;
+    }
+    return `  {
+    name: "${toolNameKebab}",
+    description: \`${description}\`,
+    schema: ${schemaBody},
+    async execute(args) {
+      return callMCPTool("${tool.name}", args)
+    }
+  }`;
+}
+function generateMCPToolsFile(options) {
+    const { tools, petName, serverIdentifier, transport, envVarName, dockerImage, authHeader } = options;
+    const toolDefinitions = tools.map(tool => generateToolDefinition(tool, petName)).join(",\n\n");
+    switch (transport) {
+        case "sse-remote":
+            return generateOAuthMCPFile(toolDefinitions, petName, serverIdentifier, tools.length);
+        case "docker":
+            return generateDockerMCPFile(toolDefinitions, petName, dockerImage || serverIdentifier, envVarName, tools.length);
+        case "http":
+            return generateHttpMCPFile(toolDefinitions, petName, serverIdentifier, envVarName, authHeader || "Authorization", tools.length);
+        default:
+            return generateStdioMCPFile(toolDefinitions, petName, serverIdentifier, envVarName, tools.length);
+    }
+}
+function generateOAuthMCPFile(toolDefinitions, petName, serverUrl, toolCount) {
+    return `/**
+ * Auto-generated MCP tools from ${serverUrl}
+ * Generated by: pets generate-mcp
+ * Transport: SSE Remote (OAuth via mcp-remote)
+ * 
+ * DO NOT EDIT MANUALLY - Regenerate with: pets generate-mcp
+ */
+
+import { z, type ToolDefinition } from "openpets-sdk"
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
+
+// MCP client state
+let mcpClient: Client | null = null
+let lastConnectionTime: number = 0
+let connectionPromise: Promise<Client> | null = null
+
+// Configuration
+const CONNECTION_TIMEOUT_MS = 60000  // 60 seconds (OAuth may take longer)
+const CONNECTION_MAX_AGE_MS = 10 * 60 * 1000  // 10 minutes
+const MAX_RETRIES = 2
+const RETRY_DELAY_MS = 1000
+
+/**
+ * Sleep helper for retry delays
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * Check if current connection is stale
+ */
+function isConnectionStale(): boolean {
+  return Date.now() - lastConnectionTime > CONNECTION_MAX_AGE_MS
+}
+
+/**
+ * Reset the client connection
+ */
+async function resetConnection(): Promise<void> {
+  if (mcpClient) {
+    try {
+      await mcpClient.close()
+    } catch {
+      // Ignore close errors
+    }
+    mcpClient = null
+  }
+  connectionPromise = null
+  lastConnectionTime = 0
+}
+
+/**
+ * Get or initialize the MCP client connection via mcp-remote (OAuth)
+ * Note: First connection will open a browser for OAuth authentication
+ */
+async function getMCPClient(): Promise<Client> {
+  // If we have a valid, non-stale connection, reuse it
+  if (mcpClient && !isConnectionStale()) {
+    return mcpClient
+  }
+  
+  // If connection is stale, reset it
+  if (mcpClient && isConnectionStale()) {
+    await resetConnection()
+  }
+  
+  // If a connection is already in progress, wait for it
+  if (connectionPromise) {
+    return connectionPromise
+  }
+  
+  // Create new connection
+  connectionPromise = (async () => {
+    const client = new Client({
+      name: "openpets-${petName}",
+      version: "1.0.0",
+    })
+    
+    const transport = new StdioClientTransport({
+      command: "bunx",
+      args: ["mcp-remote", "${serverUrl}"],
+    })
+    
+    // Connect with timeout
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => reject(new Error("OAuth connection timeout")), CONNECTION_TIMEOUT_MS)
+    })
+    
+    await Promise.race([client.connect(transport), timeoutPromise])
+    
+    mcpClient = client
+    lastConnectionTime = Date.now()
+    return client
+  })()
+  
+  try {
+    return await connectionPromise
+  } catch (error) {
+    connectionPromise = null
+    throw error
+  }
+}
+
+/**
+ * Call an MCP tool with retry logic and better error handling
+ */
+async function callMCPTool(toolName: string, args: Record<string, any>): Promise<string> {
+  let lastError: Error | null = null
+  
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const client = await getMCPClient()
+      
+      // Call with timeout
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => reject(new Error("Tool call timeout")), CONNECTION_TIMEOUT_MS)
+      })
+      
+      const result = await Promise.race([
+        client.callTool({ name: toolName, arguments: args }),
+        timeoutPromise
+      ])
+      
+      return JSON.stringify(result, null, 2)
+    } catch (error: any) {
+      lastError = error
+      
+      // On connection-related errors, reset and retry
+      if (error.message?.includes("timeout") || 
+          error.message?.includes("connection") ||
+          error.message?.includes("closed")) {
+        await resetConnection()
+        if (attempt < MAX_RETRIES) {
+          await sleep(RETRY_DELAY_MS * (attempt + 1))
+          continue
+        }
+      }
+      
+      // For other errors, don't retry
+      break
+    }
+  }
+  
+  return JSON.stringify({
+    success: false,
+    error: lastError?.message || "Unknown error",
+    tool: toolName
+  }, null, 2)
+}
+
+/**
+ * Close the MCP client connection
+ */
+export async function closeMCPClient(): Promise<void> {
+  await resetConnection()
+}
+
+/**
+ * Check if MCP client is connected and healthy
+ */
+export function isMCPClientConnected(): boolean {
+  return mcpClient !== null && !isConnectionStale()
+}
+
+/**
+ * Auto-generated MCP tools
+ * Total: ${toolCount} tools
+ */
+export const mcpTools: ToolDefinition[] = [
+${toolDefinitions}
+]
+
+export default mcpTools
+`;
+}
+function generateDockerMCPFile(toolDefinitions, petName, dockerImage, envVarName, toolCount) {
+    return `/**
+ * Auto-generated MCP tools from ${dockerImage}
+ * Generated by: pets generate-mcp
+ * Transport: Docker (container with env var authentication)
+ * 
+ * DO NOT EDIT MANUALLY - Regenerate with: pets generate-mcp
+ */
+
+import { z, type ToolDefinition } from "openpets-sdk"
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
+
+// MCP client state
+let mcpClient: Client | null = null
+let lastConnectionTime: number = 0
+let connectionPromise: Promise<Client> | null = null
+
+// Configuration
+const CONNECTION_TIMEOUT_MS = 60000  // 60 seconds (Docker startup may take time)
+const CONNECTION_MAX_AGE_MS = 10 * 60 * 1000  // 10 minutes
+const MAX_RETRIES = 2
+const RETRY_DELAY_MS = 2000  // Longer delay for Docker restarts
+
+/**
+ * Sleep helper for retry delays
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * Check if current connection is stale
+ */
+function isConnectionStale(): boolean {
+  return Date.now() - lastConnectionTime > CONNECTION_MAX_AGE_MS
+}
+
+/**
+ * Reset the client connection
+ */
+async function resetConnection(): Promise<void> {
+  if (mcpClient) {
+    try {
+      await mcpClient.close()
+    } catch {
+      // Ignore close errors
+    }
+    mcpClient = null
+  }
+  connectionPromise = null
+  lastConnectionTime = 0
+}
+
+/**
+ * Create a new Docker MCP client connection with timeout
+ */
+async function createConnection(accessToken: string): Promise<Client> {
+  const client = new Client({
+    name: "openpets-${petName}",
+    version: "1.0.0",
+  })
+  
+  const transport = new StdioClientTransport({
+    command: "docker",
+    args: [
+      "run", "-i", "--rm",
+      "-e", "${envVarName}",
+      "${dockerImage}",
+    ],
+    env: {
+      ...process.env,
+      ${envVarName}: accessToken,
+    },
+  })
+  
+  // Connect with timeout
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    setTimeout(() => reject(new Error("Docker connection timeout")), CONNECTION_TIMEOUT_MS)
+  })
+  
+  await Promise.race([client.connect(transport), timeoutPromise])
+  return client
+}
+
+/**
+ * Get or initialize the MCP client connection via Docker
+ * Requires Docker to be installed and running
+ * Uses connection pooling and retry logic for resilience
+ */
+async function getMCPClient(accessToken: string): Promise<Client> {
+  // If we have a valid, non-stale connection, reuse it
+  if (mcpClient && !isConnectionStale()) {
+    return mcpClient
+  }
+  
+  // If connection is stale, reset it
+  if (mcpClient && isConnectionStale()) {
+    await resetConnection()
+  }
+  
+  // If a connection is already in progress, wait for it
+  if (connectionPromise) {
+    return connectionPromise
+  }
+  
+  // Create new connection with retry logic
+  connectionPromise = (async () => {
+    let lastError: Error | null = null
+    
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        if (attempt > 0) {
+          await sleep(RETRY_DELAY_MS * attempt)
+        }
+        
+        const client = await createConnection(accessToken)
+        mcpClient = client
+        lastConnectionTime = Date.now()
+        return client
+      } catch (error: any) {
+        lastError = error
+        if (attempt < MAX_RETRIES) {
+          console.warn(\`Docker MCP connection attempt \${attempt + 1} failed: \${error.message}. Retrying...\`)
+        }
+      }
+    }
+    
+    connectionPromise = null
+    throw lastError || new Error("Failed to connect to Docker MCP server")
+  })()
+  
+  return connectionPromise
+}
+
+/**
+ * Call an MCP tool with retry logic and better error handling
+ */
+async function callMCPTool(toolName: string, args: Record<string, any>): Promise<string> {
+  const accessToken = process.env.${envVarName}
+  if (!accessToken) {
+    return JSON.stringify({
+      success: false,
+      error: "Missing ${envVarName} environment variable",
+      tool: toolName
+    }, null, 2)
+  }
+  
+  let lastError: Error | null = null
+  
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const client = await getMCPClient(accessToken)
+      
+      // Call with timeout
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => reject(new Error("Tool call timeout")), CONNECTION_TIMEOUT_MS)
+      })
+      
+      const result = await Promise.race([
+        client.callTool({ name: toolName, arguments: args }),
+        timeoutPromise
+      ])
+      
+      return JSON.stringify(result, null, 2)
+    } catch (error: any) {
+      lastError = error
+      
+      // On connection-related errors, reset and retry
+      if (error.message?.includes("timeout") || 
+          error.message?.includes("connection") ||
+          error.message?.includes("Docker") ||
+          error.message?.includes("closed") ||
+          error.message?.includes("ENOENT")) {
+        await resetConnection()
+        if (attempt < MAX_RETRIES) {
+          await sleep(RETRY_DELAY_MS * (attempt + 1))
+          continue
+        }
+      }
+      
+      // For other errors, don't retry
+      break
+    }
+  }
+  
+  return JSON.stringify({
+    success: false,
+    error: lastError?.message || "Unknown error",
+    tool: toolName
+  }, null, 2)
+}
+
+/**
+ * Close the MCP client connection
+ */
+export async function closeMCPClient(): Promise<void> {
+  await resetConnection()
+}
+
+/**
+ * Check if MCP client is connected and healthy
+ */
+export function isMCPClientConnected(): boolean {
+  return mcpClient !== null && !isConnectionStale()
+}
+
+/**
+ * Auto-generated MCP tools
+ * Total: ${toolCount} tools
+ */
+export const mcpTools: ToolDefinition[] = [
+${toolDefinitions}
+]
+
+export default mcpTools
+`;
+}
+function generateHttpMCPFile(toolDefinitions, petName, serverUrl, envVarName, authHeader, toolCount) {
+    return `/**
+ * Auto-generated MCP tools from ${serverUrl}
+ * Generated by: pets generate-mcp
+ * Transport: HTTP (with Bearer token authentication)
+ * 
+ * DO NOT EDIT MANUALLY - Regenerate with: pets generate-mcp
+ */
+
+import { z, type ToolDefinition } from "openpets-sdk"
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
+
+// MCP client state
+let mcpClient: Client | null = null
+let lastConnectionTime: number = 0
+let connectionPromise: Promise<Client> | null = null
+
+// Configuration
+const CONNECTION_TIMEOUT_MS = 30000  // 30 seconds
+const CONNECTION_MAX_AGE_MS = 5 * 60 * 1000  // 5 minutes - reconnect after this
+const MAX_RETRIES = 2
+const RETRY_DELAY_MS = 1000
+
+/**
+ * Sleep helper for retry delays
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * Check if current connection is stale
+ */
+function isConnectionStale(): boolean {
+  return Date.now() - lastConnectionTime > CONNECTION_MAX_AGE_MS
+}
+
+/**
+ * Reset the client connection
+ */
+async function resetConnection(): Promise<void> {
+  if (mcpClient) {
+    try {
+      await mcpClient.close()
+    } catch {
+      // Ignore close errors
+    }
+    mcpClient = null
+  }
+  connectionPromise = null
+  lastConnectionTime = 0
+}
+
+/**
+ * Create a new MCP client connection with timeout
+ */
+async function createConnection(accessToken: string): Promise<Client> {
+  const client = new Client({
+    name: "openpets-${petName}",
+    version: "1.0.0",
+  })
+  
+  const headers = {
+    "${authHeader}": \`Bearer \${accessToken}\`,
+  }
+  
+  // Create connection with timeout
+  const connectWithTimeout = async (transport: any) => {
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => reject(new Error("Connection timeout")), CONNECTION_TIMEOUT_MS)
+    })
+    await Promise.race([client.connect(transport), timeoutPromise])
+  }
+  
+  // Try StreamableHTTP first, fall back to SSE
+  try {
+    const transport = new StreamableHTTPClientTransport(new URL("${serverUrl}"), {
+      requestInit: { headers },
+    })
+    await connectWithTimeout(transport)
+  } catch (httpError: any) {
+    const sseTransport = new SSEClientTransport(new URL("${serverUrl}"), {
+      requestInit: { headers },
+    })
+    await connectWithTimeout(sseTransport)
+  }
+  
+  return client
+}
+
+/**
+ * Get or initialize the MCP client connection via HTTP
+ * Uses Bearer token authentication with connection pooling and retry logic
+ */
+async function getMCPClient(accessToken: string): Promise<Client> {
+  // If we have a valid, non-stale connection, reuse it
+  if (mcpClient && !isConnectionStale()) {
+    return mcpClient
+  }
+  
+  // If connection is stale, reset it
+  if (mcpClient && isConnectionStale()) {
+    await resetConnection()
+  }
+  
+  // If a connection is already in progress, wait for it
+  if (connectionPromise) {
+    return connectionPromise
+  }
+  
+  // Create new connection with retry logic
+  connectionPromise = (async () => {
+    let lastError: Error | null = null
+    
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        if (attempt > 0) {
+          await sleep(RETRY_DELAY_MS * attempt)
+        }
+        
+        const client = await createConnection(accessToken)
+        mcpClient = client
+        lastConnectionTime = Date.now()
+        return client
+      } catch (error: any) {
+        lastError = error
+        if (attempt < MAX_RETRIES) {
+          console.warn(\`MCP connection attempt \${attempt + 1} failed: \${error.message}. Retrying...\`)
+        }
+      }
+    }
+    
+    connectionPromise = null
+    throw lastError || new Error("Failed to connect to MCP server")
+  })()
+  
+  return connectionPromise
+}
+
+/**
+ * Call an MCP tool with retry logic and better error handling
+ */
+async function callMCPTool(toolName: string, args: Record<string, any>): Promise<string> {
+  const accessToken = process.env.${envVarName}
+  if (!accessToken) {
+    return JSON.stringify({
+      success: false,
+      error: "Missing ${envVarName} environment variable",
+      tool: toolName
+    }, null, 2)
+  }
+  
+  let lastError: Error | null = null
+  
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const client = await getMCPClient(accessToken)
+      
+      // Call with timeout
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => reject(new Error("Tool call timeout")), CONNECTION_TIMEOUT_MS)
+      })
+      
+      const result = await Promise.race([
+        client.callTool({ name: toolName, arguments: args }),
+        timeoutPromise
+      ])
+      
+      return JSON.stringify(result, null, 2)
+    } catch (error: any) {
+      lastError = error
+      
+      // On connection-related errors, reset and retry
+      if (error.message?.includes("timeout") || 
+          error.message?.includes("connection") ||
+          error.message?.includes("ECONNREFUSED") ||
+          error.message?.includes("socket")) {
+        await resetConnection()
+        if (attempt < MAX_RETRIES) {
+          await sleep(RETRY_DELAY_MS * (attempt + 1))
+          continue
+        }
+      }
+      
+      // For other errors, don't retry
+      break
+    }
+  }
+  
+  return JSON.stringify({
+    success: false,
+    error: lastError?.message || "Unknown error",
+    tool: toolName
+  }, null, 2)
+}
+
+/**
+ * Close the MCP client connection
+ */
+export async function closeMCPClient(): Promise<void> {
+  await resetConnection()
+}
+
+/**
+ * Check if MCP client is connected and healthy
+ */
+export function isMCPClientConnected(): boolean {
+  return mcpClient !== null && !isConnectionStale()
+}
+
+/**
+ * Auto-generated MCP tools
+ * Total: ${toolCount} tools
+ */
+export const mcpTools: ToolDefinition[] = [
+${toolDefinitions}
+]
+
+export default mcpTools
+`;
+}
+function generateStdioMCPFile(toolDefinitions, petName, npmPackage, envVarName, toolCount) {
+    return `/**
+ * Auto-generated MCP tools from ${npmPackage}
+ * Generated by: pets generate-mcp
+ * Transport: Stdio (direct npm package)
+ * 
+ * DO NOT EDIT MANUALLY - Regenerate with: pets generate-mcp
+ */
+
+import { z, type ToolDefinition } from "openpets-sdk"
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
+
+// MCP client state
+let mcpClient: Client | null = null
+let lastConnectionTime: number = 0
+let connectionPromise: Promise<Client> | null = null
+
+// Configuration
+const CONNECTION_TIMEOUT_MS = 30000  // 30 seconds
+const CONNECTION_MAX_AGE_MS = 10 * 60 * 1000  // 10 minutes
+const MAX_RETRIES = 2
+const RETRY_DELAY_MS = 1000
+
+/**
+ * Sleep helper for retry delays
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * Check if current connection is stale
+ */
+function isConnectionStale(): boolean {
+  return Date.now() - lastConnectionTime > CONNECTION_MAX_AGE_MS
+}
+
+/**
+ * Reset the client connection
+ */
+async function resetConnection(): Promise<void> {
+  if (mcpClient) {
+    try {
+      await mcpClient.close()
+    } catch {
+      // Ignore close errors
+    }
+    mcpClient = null
+  }
+  connectionPromise = null
+  lastConnectionTime = 0
+}
+
+/**
+ * Create a new stdio MCP client connection with timeout
+ */
+async function createConnection(accessToken: string): Promise<Client> {
+  const client = new Client({
+    name: "openpets-${petName}",
+    version: "1.0.0",
+  })
+  
+  const transport = new StdioClientTransport({
+    command: "bunx",
+    args: ["${npmPackage}", \`--access-token=\${accessToken}\`],
+  })
+  
+  // Connect with timeout
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    setTimeout(() => reject(new Error("Connection timeout")), CONNECTION_TIMEOUT_MS)
+  })
+  
+  await Promise.race([client.connect(transport), timeoutPromise])
+  return client
+}
+
+/**
+ * Get or initialize the MCP client connection
+ * Uses connection pooling and retry logic for resilience
+ */
+async function getMCPClient(accessToken: string): Promise<Client> {
+  // If we have a valid, non-stale connection, reuse it
+  if (mcpClient && !isConnectionStale()) {
+    return mcpClient
+  }
+  
+  // If connection is stale, reset it
+  if (mcpClient && isConnectionStale()) {
+    await resetConnection()
+  }
+  
+  // If a connection is already in progress, wait for it
+  if (connectionPromise) {
+    return connectionPromise
+  }
+  
+  // Create new connection with retry logic
+  connectionPromise = (async () => {
+    let lastError: Error | null = null
+    
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        if (attempt > 0) {
+          await sleep(RETRY_DELAY_MS * attempt)
+        }
+        
+        const client = await createConnection(accessToken)
+        mcpClient = client
+        lastConnectionTime = Date.now()
+        return client
+      } catch (error: any) {
+        lastError = error
+        if (attempt < MAX_RETRIES) {
+          console.warn(\`MCP connection attempt \${attempt + 1} failed: \${error.message}. Retrying...\`)
+        }
+      }
+    }
+    
+    connectionPromise = null
+    throw lastError || new Error("Failed to connect to MCP server")
+  })()
+  
+  return connectionPromise
+}
+
+/**
+ * Call an MCP tool with retry logic and better error handling
+ */
+async function callMCPTool(toolName: string, args: Record<string, any>): Promise<string> {
+  const accessToken = process.env.${envVarName}
+  if (!accessToken) {
+    return JSON.stringify({
+      success: false,
+      error: "Missing ${envVarName} environment variable",
+      tool: toolName
+    }, null, 2)
+  }
+  
+  let lastError: Error | null = null
+  
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const client = await getMCPClient(accessToken)
+      
+      // Call with timeout
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => reject(new Error("Tool call timeout")), CONNECTION_TIMEOUT_MS)
+      })
+      
+      const result = await Promise.race([
+        client.callTool({ name: toolName, arguments: args }),
+        timeoutPromise
+      ])
+      
+      return JSON.stringify(result, null, 2)
+    } catch (error: any) {
+      lastError = error
+      
+      // On connection-related errors, reset and retry
+      if (error.message?.includes("timeout") || 
+          error.message?.includes("connection") ||
+          error.message?.includes("closed") ||
+          error.message?.includes("ENOENT")) {
+        await resetConnection()
+        if (attempt < MAX_RETRIES) {
+          await sleep(RETRY_DELAY_MS * (attempt + 1))
+          continue
+        }
+      }
+      
+      // For other errors, don't retry
+      break
+    }
+  }
+  
+  return JSON.stringify({
+    success: false,
+    error: lastError?.message || "Unknown error",
+    tool: toolName
+  }, null, 2)
+}
+
+/**
+ * Close the MCP client connection
+ */
+export async function closeMCPClient(): Promise<void> {
+  await resetConnection()
+}
+
+/**
+ * Check if MCP client is connected and healthy
+ */
+export function isMCPClientConnected(): boolean {
+  return mcpClient !== null && !isConnectionStale()
+}
+
+/**
+ * Auto-generated MCP tools
+ * Total: ${toolCount} tools
+ */
+export const mcpTools: ToolDefinition[] = [
+${toolDefinitions}
+]
+
+export default mcpTools
+`;
+}
+export async function generateMCPTools(options = {}) {
+    const cwd = process.cwd();
+    const outputFile = options.outputFile || "mcp.ts";
+    // Load MCP config from package.json
+    const mcpInfo = loadMCPConfigFromPackageJson(cwd);
+    if (!mcpInfo) {
+        return {
+            success: false,
+            message: "No mcpServer configuration found in package.json. Add mcpServer.npmPackage to your package.json."
+        };
+    }
+    const { config, petName, authToken } = mcpInfo;
+    const npmPackage = config.npmPackage || `@${petName}/mcp-server`;
+    const transport = config.transport || "stdio";
+    const isRemoteOAuth = transport === "sse-remote";
+    const envVarName = config.authEnvVar || `${petName.toUpperCase().replace(/-/g, "_")}_ACCESS_TOKEN`;
+    // For non-OAuth servers, require auth token
+    if (!isRemoteOAuth && !authToken) {
+        return {
+            success: false,
+            message: `Missing ${envVarName} environment variable. Set it in .env to connect to the MCP server.`
+        };
+    }
+    if (options.verbose) {
+        console.log(`Transport: ${transport}`);
+        if (isRemoteOAuth) {
+            console.log(`Connecting to remote MCP server via OAuth: ${config.url}`);
+        }
+        else if (transport === "docker") {
+            console.log(`Connecting to Docker MCP server: ${config.dockerImage}`);
+        }
+        else if (transport === "http") {
+            console.log(`Connecting to HTTP MCP server: ${config.url}`);
+        }
+        else {
+            console.log(`Connecting to MCP server: ${npmPackage}`);
+        }
+    }
+    try {
+        // Connect to MCP server
+        const { client, tools } = await connectToMCPServer(config, authToken);
+        if (options.verbose) {
+            console.log(`Found ${tools.length} tools`);
+        }
+        // Dump raw schemas if requested
+        if (options.dumpSchemas) {
+            const schemasFile = resolve(cwd, "mcp-schemas.json");
+            const schemasData = {
+                generatedAt: new Date().toISOString(),
+                serverUrl: config.url || npmPackage,
+                transport,
+                toolCount: tools.length,
+                tools: tools.map(t => ({
+                    name: t.name,
+                    description: t.description,
+                    inputSchema: t.inputSchema,
+                    outputSchema: t.outputSchema
+                }))
+            };
+            writeFileSync(schemasFile, JSON.stringify(schemasData, null, 2));
+            console.log(`Dumped raw schemas to: ${schemasFile}`);
+        }
+        // Determine server identifier based on transport
+        let serverIdentifier;
+        switch (transport) {
+            case "sse-remote":
+            case "http":
+                serverIdentifier = config.url;
+                break;
+            case "docker":
+                serverIdentifier = config.dockerImage || `ghcr.io/${petName}/${petName}-mcp-server`;
+                break;
+            default:
+                serverIdentifier = npmPackage;
+        }
+        // Generate the mcp.ts file content
+        const content = generateMCPToolsFile({
+            tools,
+            petName,
+            serverIdentifier,
+            transport,
+            envVarName,
+            dockerImage: config.dockerImage,
+            authHeader: config.authHeader,
+        });
+        if (options.dryRun) {
+            console.log("\n--- Generated mcp.ts ---");
+            console.log(content);
+            console.log("--- End ---\n");
+        }
+        else {
+            const outputPath = resolve(cwd, outputFile);
+            writeFileSync(outputPath, content);
+        }
+        // Close client
+        await client.close();
+        return {
+            success: true,
+            message: options.dryRun
+                ? `Would generate ${tools.length} tools to ${outputFile}`
+                : `Generated ${tools.length} tools to ${outputFile}`,
+            toolCount: tools.length,
+            outputPath: resolve(cwd, outputFile),
+            tools,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to connect to MCP server: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=mcp-generator.js.map