@nodetool-ai/deploy 0.7.0-rc.23 → 0.8.2

package/dist/runpod-api.js

@@ -1,703 +0,0 @@
-/**
- * RunPod API Module
- *
- * Provides a clean interface to RunPod's REST and GraphQL APIs for managing
- * templates and endpoints. Handles authentication, request/response processing,
- * and error handling for all RunPod operations.
- *
- * Key Features:
- * - Template management (create, update, delete, get)
- * - Endpoint management (create, update, delete)
- * - Network volume management
- * - GraphQL query support
- * - Proper error handling and logging
- */
-const RUNPOD_REST_BASE_URL = "https://rest.runpod.io/v1";
-/** Escape a string for safe interpolation inside a GraphQL quoted string. */
-function gqlEscape(s) {
-    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-const HTTP_STATUS_UNAUTHORIZED = 401;
-const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
-// ---------------------------------------------------------------------------
-// Enums
-// ---------------------------------------------------------------------------
-/** GPU types available in RunPod using their official GPU ID codes. */
-export var GPUType;
-(function (GPUType) {
-    // Ada Lovelace Architecture
-    GPUType["ADA_24"] = "ADA_24";
-    GPUType["ADA_32_PRO"] = "ADA_32_PRO";
-    GPUType["ADA_48_PRO"] = "ADA_48_PRO";
-    GPUType["ADA_80_PRO"] = "ADA_80_PRO";
-    // Ampere Architecture
-    GPUType["AMPERE_16"] = "AMPERE_16";
-    GPUType["AMPERE_24"] = "AMPERE_24";
-    GPUType["AMPERE_48"] = "AMPERE_48";
-    GPUType["AMPERE_80"] = "AMPERE_80";
-    // Hopper Architecture
-    GPUType["HOPPER_141"] = "HOPPER_141";
-})(GPUType || (GPUType = {}));
-/** Compute types for RunPod endpoints. */
-export var ComputeType;
-(function (ComputeType) {
-    ComputeType["CPU"] = "CPU";
-    ComputeType["GPU"] = "GPU";
-})(ComputeType || (ComputeType = {}));
-/** CPU flavor IDs for RunPod endpoints. */
-export var CPUFlavor;
-(function (CPUFlavor) {
-    CPUFlavor["CPU_3C"] = "cpu3c";
-    CPUFlavor["CPU_3G"] = "cpu3g";
-    CPUFlavor["CPU_5C"] = "cpu5c";
-    CPUFlavor["CPU_5G"] = "cpu5g";
-})(CPUFlavor || (CPUFlavor = {}));
-/** Data center locations for RunPod endpoints. */
-export var DataCenter;
-(function (DataCenter) {
-    // United States
-    DataCenter["US_CALIFORNIA_2"] = "US-CA-2";
-    DataCenter["US_DELAWARE_1"] = "US-DE-1";
-    DataCenter["US_GEORGIA_1"] = "US-GA-1";
-    DataCenter["US_GEORGIA_2"] = "US-GA-2";
-    DataCenter["US_ILLINOIS_1"] = "US-IL-1";
-    DataCenter["US_KANSAS_2"] = "US-KS-2";
-    DataCenter["US_KANSAS_3"] = "US-KS-3";
-    DataCenter["US_NORTH_CAROLINA_1"] = "US-NC-1";
-    DataCenter["US_TEXAS_1"] = "US-TX-1";
-    DataCenter["US_TEXAS_3"] = "US-TX-3";
-    DataCenter["US_TEXAS_4"] = "US-TX-4";
-    DataCenter["US_WASHINGTON_1"] = "US-WA-1";
-    // Canada
-    DataCenter["CA_MONTREAL_1"] = "CA-MTL-1";
-    DataCenter["CA_MONTREAL_2"] = "CA-MTL-2";
-    DataCenter["CA_MONTREAL_3"] = "CA-MTL-3";
-    // Europe
-    DataCenter["EU_CZECH_REPUBLIC_1"] = "EU-CZ-1";
-    DataCenter["EU_FRANCE_1"] = "EU-FR-1";
-    DataCenter["EU_NETHERLANDS_1"] = "EU-NL-1";
-    DataCenter["EU_ROMANIA_1"] = "EU-RO-1";
-    DataCenter["EU_SWEDEN_1"] = "EU-SE-1";
-    // Europe Extended
-    DataCenter["EUR_ICELAND_1"] = "EUR-IS-1";
-    DataCenter["EUR_ICELAND_2"] = "EUR-IS-2";
-    DataCenter["EUR_ICELAND_3"] = "EUR-IS-3";
-    DataCenter["EUR_NORWAY_1"] = "EUR-NO-1";
-    // Asia-Pacific
-    DataCenter["AP_JAPAN_1"] = "AP-JP-1";
-    // Oceania
-    DataCenter["OC_AUSTRALIA_1"] = "OC-AU-1";
-})(DataCenter || (DataCenter = {}));
-/** CUDA versions available in RunPod. */
-export var CUDAVersion;
-(function (CUDAVersion) {
-    CUDAVersion["CUDA_11_8"] = "11.8";
-    CUDAVersion["CUDA_12_0"] = "12.0";
-    CUDAVersion["CUDA_12_1"] = "12.1";
-    CUDAVersion["CUDA_12_2"] = "12.2";
-    CUDAVersion["CUDA_12_3"] = "12.3";
-    CUDAVersion["CUDA_12_4"] = "12.4";
-    CUDAVersion["CUDA_12_5"] = "12.5";
-    CUDAVersion["CUDA_12_6"] = "12.6";
-    CUDAVersion["CUDA_12_7"] = "12.7";
-    CUDAVersion["CUDA_12_8"] = "12.8";
-})(CUDAVersion || (CUDAVersion = {}));
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Return all values of a string enum. */
-export function enumValues(e) {
-    return Object.values(e);
-}
-/** Print available options for an enum. */
-export function printEnumOptions(enumObj, title) {
-    console.log(`\n${title}:`);
-    for (const value of Object.values(enumObj)) {
-        console.log(`  ${value}`);
-    }
-}
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-function getApiKey() {
-    const key = process.env.RUNPOD_API_KEY;
-    if (!key) {
-        throw new Error("RUNPOD_API_KEY environment variable is not set");
-    }
-    return key;
-}
-/**
- * Run a GraphQL query against the RunPod API.
- */
-export async function runGraphqlQuery(query) {
-    const apiUrlBase = process.env.RUNPOD_API_BASE_URL ?? "https://api.runpod.io";
-    const url = `${apiUrlBase}/graphql`;
-    const apiKey = getApiKey();
-    const response = await fetch(url, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "User-Agent": USER_AGENT,
-            Authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify({ query }),
-        signal: AbortSignal.timeout(30_000)
-    });
-    if (response.status === HTTP_STATUS_UNAUTHORIZED) {
-        throw new Error("Unauthorized request, please check your API key.");
-    }
-    const json = (await response.json());
-    if (json.errors && json.errors.length > 0) {
-        throw new Error(json.errors[0].message);
-    }
-    return json;
-}
-/**
- * Make a REST API call to RunPod.
- *
- * @param endpoint - The API endpoint (e.g., "endpoints", "templates")
- * @param method   - HTTP method
- * @param data     - Request body for POST/PUT/PATCH
- * @returns API response data, or empty object for DELETE 204 responses
- */
-export async function makeRunpodApiCall(endpoint, method = "GET", data) {
-    const url = `${RUNPOD_REST_BASE_URL}/${endpoint}`;
-    const apiKey = getApiKey();
-    const headers = {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json",
-        "User-Agent": USER_AGENT,
-        Accept: "*/*",
-        "Accept-Language": "en-US,en;q=0.9"
-    };
-    const init = {
-        method,
-        headers,
-        signal: AbortSignal.timeout(60_000)
-    };
-    if (data && (method === "POST" || method === "PUT" || method === "PATCH")) {
-        init.body = JSON.stringify(data);
-    }
-    let response;
-    try {
-        response = await fetch(url, init);
-    }
-    catch (err) {
-        console.error("RunPod API call failed:", err);
-        throw err;
-    }
-    if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        console.error(`RunPod API call failed: ${response.status}`);
-        if (body) {
-            console.error("Response body:", body);
-        }
-        throw new Error(`RunPod API ${method} ${endpoint} failed with status ${response.status}: ${body}`);
-    }
-    // DELETE 204 may have no body
-    if (method === "DELETE" && response.status === 204) {
-        return {};
-    }
-    const text = await response.text();
-    if (!text) {
-        return {};
-    }
-    return JSON.parse(text);
-}
-// ---------------------------------------------------------------------------
-// Network Volume Management
-// ---------------------------------------------------------------------------
-/**
- * Create a new network volume.
- */
-export async function createNetworkVolume(name, size, dataCenterId) {
-    return makeRunpodApiCall("networkvolumes", "POST", {
-        dataCenterId,
-        name,
-        size
-    });
-}
-/**
- * List all network volumes.
- */
-export async function listNetworkVolumes() {
-    return makeRunpodApiCall("networkvolumes", "GET");
-}
-/**
- * Get details of a specific network volume.
- */
-export async function getNetworkVolume(volumeId) {
-    return makeRunpodApiCall(`networkvolumes/${volumeId}`, "GET");
-}
-/**
- * Update a network volume.
- */
-export async function updateNetworkVolume(volumeId, name, size) {
-    const data = {};
-    if (name != null)
-        data.name = name;
-    if (size != null)
-        data.size = size;
-    return makeRunpodApiCall(`networkvolumes/${volumeId}`, "PATCH", data);
-}
-// ---------------------------------------------------------------------------
-// Template Management
-// ---------------------------------------------------------------------------
-/**
- * Get a RunPod template by name.
- */
-export async function getRunpodTemplateByName(templateName) {
-    try {
-        const result = await makeRunpodApiCall("templates", "GET");
-        const templates = Array.isArray(result)
-            ? result
-            : (result.templates ?? []);
-        for (const tpl of templates) {
-            if (tpl.name === templateName) {
-                return tpl;
-            }
-        }
-        return null;
-    }
-    catch (err) {
-        console.error(`Error fetching template '${templateName}':`, err);
-        return null;
-    }
-}
-/**
- * Delete a RunPod template by name.
- */
-export async function deleteRunpodTemplateByName(templateName) {
-    try {
-        const template = await getRunpodTemplateByName(templateName);
-        if (!template) {
-            console.log(`Template '${templateName}' not found (may not exist)`);
-            return true;
-        }
-        const templateId = template.id;
-        await makeRunpodApiCall(`templates/${templateId}`, "DELETE");
-        console.log(`Template '${templateName}' (ID: ${templateId}) deleted successfully`);
-        return true;
-    }
-    catch (err) {
-        console.error(`Error deleting template '${templateName}':`, err);
-        return false;
-    }
-}
-/**
- * Update an existing RunPod template with a new Docker image.
- */
-export async function updateRunpodTemplate(templateData, imageName, tag) {
-    try {
-        const templateId = templateData.id;
-        const env = templateData.env ?? {};
-        env.PORT = "8000";
-        env.PORT_HEALTH = "8000";
-        const updateData = {
-            containerDiskInGb: templateData.containerDiskInGb ?? 20,
-            imageName: `${imageName}:${tag}`,
-            name: templateData.name,
-            ports: templateData.ports ?? ["8000/http"],
-            volumeInGb: templateData.volumeInGb ?? 0,
-            volumeMountPath: templateData.volumeMountPath ?? "/workspace",
-            isPublic: templateData.isPublic ?? false,
-            env
-        };
-        if (templateData.dockerEntrypoint) {
-            updateData.dockerEntrypoint = templateData.dockerEntrypoint;
-        }
-        if (templateData.dockerStartCmd) {
-            updateData.dockerStartCmd = templateData.dockerStartCmd;
-        }
-        if (templateData.readme) {
-            updateData.readme = templateData.readme;
-        }
-        console.log("Updating template with data:");
-        console.log(JSON.stringify(updateData, null, 2));
-        await makeRunpodApiCall(`templates/${templateId}`, "PATCH", updateData);
-        console.log(`Template '${templateData.name}' updated with image: ${imageName}:${tag}`);
-        return true;
-    }
-    catch (err) {
-        console.error("Error updating template:", err);
-        return false;
-    }
-}
-/**
- * Create or update a RunPod template with the latest Docker image.
- *
- * Checks if a template with the given name exists:
- * - If it exists, updates it with the new Docker image
- * - If it doesn't exist, creates a new template
- *
- * @returns The template ID
- */
-export async function createOrUpdateRunpodTemplate(templateName, imageName, tag, env) {
-    const envVars = env ?? {};
-    console.log(`Checking for existing template: ${templateName}`);
-    const existing = await getRunpodTemplateByName(templateName);
-    if (existing) {
-        const templateId = existing.id;
-        console.log(`Found existing template (ID: ${templateId})`);
-        console.log(`Current image: ${existing.imageName ?? "unknown"}`);
-        console.log(`Updating with new image: ${imageName}:${tag}`);
-        if (await updateRunpodTemplate(existing, imageName, tag)) {
-            console.log(`Template '${templateName}' updated successfully`);
-            return templateId;
-        }
-        throw new Error(`Failed to update template '${templateName}'`);
-    }
-    // Create new template
-    console.log(`Template not found, creating new template: ${templateName}`);
-    const templateData = {
-        containerDiskInGb: 20,
-        imageName: `${imageName}:${tag}`,
-        name: templateName,
-        ports: ["8000/http", "22/ssh"],
-        volumeInGb: 0,
-        volumeMountPath: "/workspace",
-        isPublic: false,
-        env: envVars
-    };
-    console.log("Creating template with data:");
-    console.log(JSON.stringify(templateData, null, 2));
-    const result = await makeRunpodApiCall("templates", "POST", templateData);
-    const templateId = result.id;
-    if (!templateId) {
-        console.error("Error: No template ID returned");
-        console.error(`Response data: ${JSON.stringify(result, null, 2)}`);
-        throw new Error("No template ID returned from RunPod API");
-    }
-    console.log(`Template created successfully: ${templateId}`);
-    return templateId;
-}
-// ---------------------------------------------------------------------------
-// Endpoint Management
-// ---------------------------------------------------------------------------
-/**
- * Get a RunPod endpoint by name.
- */
-export async function getRunpodEndpointByName(endpointName, quiet = false) {
-    const endpointsResponse = await makeRunpodApiCall("endpoints", "GET");
-    const endpoints = Array.isArray(endpointsResponse)
-        ? endpointsResponse
-        : (endpointsResponse.endpoints ?? []);
-    if (!quiet) {
-        console.log(`Looking for endpoint: '${endpointName}'`);
-        console.log(`Found ${endpoints.length} total endpoints`);
-    }
-    if (endpoints.length > 0 && !quiet) {
-        console.log("Available endpoints:");
-        endpoints.forEach((ep, i) => {
-            const name = ep.name ?? "<no name>";
-            const id = ep.id ?? "<no id>";
-            console.log(`  [${i + 1}] Name: '${name}' (ID: ${id})`);
-        });
-    }
-    // Exact match first
-    const exact = endpoints.find((ep) => ep.name === endpointName);
-    if (exact) {
-        if (!quiet) {
-            console.log(`Found exact match for endpoint: '${endpointName}'`);
-        }
-        return exact;
-    }
-    // Prefix match fallback
-    for (const ep of endpoints) {
-        const name = ep.name ?? "";
-        if (name.startsWith(endpointName)) {
-            if (!quiet) {
-                console.log(`Found prefix match for endpoint: '${endpointName}' -> '${name}'`);
-            }
-            return ep;
-        }
-    }
-    if (!quiet) {
-        console.log(`No endpoint found with name: '${endpointName}'`);
-    }
-    return null;
-}
-/**
- * Update an existing RunPod endpoint with a new template.
- */
-export async function updateRunpodEndpoint(endpointId, templateId, extra) {
-    try {
-        const updateData = {
-            templateId,
-            ...extra
-        };
-        // Remove undefined values
-        for (const key of Object.keys(updateData)) {
-            if (updateData[key] === undefined) {
-                delete updateData[key];
-            }
-        }
-        console.log(`Updating endpoint ${endpointId} with template ${templateId}`);
-        await makeRunpodApiCall(`endpoints/${endpointId}`, "PATCH", updateData);
-        console.log(`Endpoint '${endpointId}' updated successfully with template: ${templateId}`);
-        return true;
-    }
-    catch (err) {
-        console.error(`Error updating endpoint '${endpointId}':`, err);
-        return false;
-    }
-}
-/**
- * Delete a RunPod endpoint by name.
- */
-export async function deleteRunpodEndpointByName(endpointName) {
-    try {
-        const result = await makeRunpodApiCall("endpoints", "GET");
-        const endpoints = result.endpoints ?? [];
-        let endpointId;
-        console.log(`Looking for endpoint to delete: '${endpointName}'`);
-        console.log(`Found ${endpoints.length} total endpoints`);
-        // Exact match
-        for (const ep of endpoints) {
-            if (ep.name === endpointName) {
-                endpointId = ep.id;
-                console.log(`Found exact match for deletion: '${endpointName}' (ID: ${endpointId})`);
-                break;
-            }
-        }
-        // Case-insensitive fallback
-        if (!endpointId) {
-            for (const ep of endpoints) {
-                const name = (ep.name ?? "").toLowerCase();
-                if (name === endpointName.toLowerCase()) {
-                    endpointId = ep.id;
-                    console.log(`Found case-insensitive match for deletion: '${endpointName}' -> '${ep.name}' (ID: ${endpointId})`);
-                    break;
-                }
-            }
-        }
-        if (!endpointId) {
-            console.log(`Endpoint '${endpointName}' not found (may not exist)`);
-            return true;
-        }
-        await makeRunpodApiCall(`endpoints/${endpointId}`, "DELETE");
-        console.log(`Endpoint '${endpointName}' (ID: ${endpointId}) deleted successfully`);
-        return true;
-    }
-    catch (err) {
-        console.error(`Error deleting endpoint '${endpointName}':`, err);
-        return false;
-    }
-}
-/**
- * Create or update a RunPod serverless endpoint using the REST API.
- *
- * If an endpoint with the same name already exists, it will be updated
- * with the new template. Otherwise a new endpoint is created.
- *
- * @returns The endpoint ID
- */
-export async function createOrUpdateRunpodEndpoint(opts) {
-    const { templateId, name, computeType = ComputeType.GPU, gpuCount, cpuFlavorIds, vcpuCount, workersMin = 0, workersMax = 3, idleTimeout = 5, executionTimeoutMs, flashboot = false, networkVolumeId, allowedCudaVersions } = opts;
-    let gpuTypeIds = opts.gpuTypeIds;
-    let dataCenterIds = opts.dataCenterIds ?? undefined;
-    // Handle network volume and data center coordination
-    if (networkVolumeId) {
-        console.log(`Network volume specified: ${networkVolumeId}`);
-        const volumeInfo = await getNetworkVolume(networkVolumeId);
-        const volumeDataCenter = volumeInfo.dataCenterId;
-        if (volumeDataCenter) {
-            console.log(`Network volume is in data center: ${volumeDataCenter}`);
-            dataCenterIds = [volumeDataCenter];
-            console.log(`Endpoint will be deployed to same region: ${volumeDataCenter}`);
-        }
-    }
-    if (gpuTypeIds == null && computeType === ComputeType.GPU) {
-        gpuTypeIds = ["NVIDIA GeForce RTX 4090"];
-    }
-    if (dataCenterIds == null) {
-        dataCenterIds = [];
-    }
-    // Check if endpoint already exists
-    console.log(`Checking for existing endpoint: ${name}`);
-    const existingEndpoint = await getRunpodEndpointByName(name);
-    if (existingEndpoint) {
-        const endpointId = existingEndpoint.id;
-        console.log(`Found existing endpoint (ID: ${endpointId})`);
-        console.log(`Current template: ${existingEndpoint.templateId ?? "unknown"}`);
-        console.log(`Updating with new template: ${templateId}`);
-        if (await updateRunpodEndpoint(endpointId, templateId)) {
-            console.log(`Endpoint '${name}' updated successfully`);
-            return endpointId;
-        }
-        console.log(`Failed to update endpoint '${name}', creating new one...`);
-        await deleteRunpodEndpointByName(name);
-    }
-    console.log(`Creating new endpoint: ${name}`);
-    console.log(`  Compute type: ${computeType}`);
-    if (computeType === ComputeType.GPU) {
-        console.log(`  GPU types: ${JSON.stringify(gpuTypeIds)}`);
-        if (gpuCount)
-            console.log(`  GPU count: ${gpuCount}`);
-    }
-    else {
-        console.log(`  CPU flavors: ${JSON.stringify(cpuFlavorIds)}`);
-        if (vcpuCount)
-            console.log(`  vCPU count: ${vcpuCount}`);
-    }
-    console.log(`  Data centers: ${dataCenterIds.length > 0 ? JSON.stringify(dataCenterIds) : "Auto-selected"}`);
-    console.log(`  Workers: ${workersMin}-${workersMax}`);
-    const endpointData = {
-        computeType,
-        templateId,
-        name,
-        workersMin,
-        workersMax,
-        scalerType: "REQUEST_COUNT",
-        scalerValue: 4,
-        idleTimeout,
-        flashboot
-    };
-    if (computeType === ComputeType.GPU) {
-        endpointData.gpuTypeIds = gpuTypeIds ?? ["NVIDIA GeForce RTX 4090"];
-        endpointData.gpuCount = gpuCount ?? 1;
-    }
-    else {
-        endpointData.cpuFlavorIds = cpuFlavorIds ?? ["cpu3c"];
-        if (vcpuCount)
-            endpointData.vcpuCount = vcpuCount;
-    }
-    if (allowedCudaVersions && allowedCudaVersions.length > 0) {
-        endpointData.allowedCudaVersions = allowedCudaVersions;
-    }
-    if (dataCenterIds.length > 0) {
-        endpointData.dataCenterIds = dataCenterIds;
-    }
-    if (executionTimeoutMs) {
-        endpointData.executionTimeoutMs = executionTimeoutMs;
-    }
-    if (networkVolumeId) {
-        endpointData.networkVolumeId = networkVolumeId;
-    }
-    console.log("\nCreating endpoint with data:");
-    console.log(JSON.stringify(endpointData, null, 2));
-    const result = await makeRunpodApiCall("endpoints", "POST", endpointData);
-    const endpointId = result.id;
-    if (!endpointId) {
-        console.error("Error: No endpoint ID returned");
-        console.error(`Response data: ${JSON.stringify(result, null, 2)}`);
-        throw new Error("No endpoint ID returned from RunPod API");
-    }
-    console.log("\nEndpoint created successfully!");
-    console.log(`  ID: ${endpointId}`);
-    console.log(`  Name: ${result.name ?? name}`);
-    console.log(`  GPU Configuration: ${JSON.stringify(result.gpuTypeIds)}`);
-    console.log(`  Workers: ${result.workersMin}-${result.workersMax}`);
-    return endpointId;
-}
-/**
- * Create a RunPod serverless endpoint using raw GraphQL queries.
- *
- * If an endpoint with the same name already exists, it will be deleted first.
- *
- * @returns The endpoint ID
- */
-export async function createRunpodEndpointGraphql(opts) {
-    const { templateId, name, computeType = ComputeType.GPU, gpuTypeIds, gpuCount, vcpuCount, workersMin = 0, workersMax = 3, idleTimeout = 5, executionTimeoutMs, flashboot = false, networkVolumeId } = opts;
-    const dataCenterIds = opts.dataCenterIds ?? [];
-    // Ensure API key
-    getApiKey();
-    // Delete existing endpoint if it exists
-    console.log(`Checking for existing endpoint: ${name}`);
-    if (await deleteRunpodEndpointByName(name)) {
-        console.log(`Existing endpoint '${name}' deleted successfully`);
-    }
-    else {
-        console.log(`Note: Endpoint '${name}' may not have existed`);
-    }
-    console.log(`Creating new endpoint: ${name}`);
-    console.log(`  Compute type: ${computeType}`);
-    console.log(`  GPU types: ${JSON.stringify(gpuTypeIds)}`);
-    console.log(`  GPU count: ${gpuCount}`);
-    console.log(`  Data centers: ${dataCenterIds.length > 0 ? JSON.stringify(dataCenterIds) : "Auto-selected"}`);
-    console.log(`  Workers: ${workersMin}-${workersMax}`);
-    console.log(`  Idle timeout: ${idleTimeout}s`);
-    console.log(`  Execution timeout: ${executionTimeoutMs}ms`);
-    console.log(`  Flashboot: ${flashboot}`);
-    console.log(`  Network volume: ${networkVolumeId}`);
-    const gpuIdsStr = gpuTypeIds ? gpuTypeIds.join(",") : "AMPERE_24";
-    // Build mutation parts
-    const endpointName = flashboot ? `${name}-fb` : name;
-    const mutationParts = [];
-    mutationParts.push(`name: "${gqlEscape(endpointName)}"`);
-    mutationParts.push(`templateId: "${gqlEscape(templateId)}"`);
-    mutationParts.push('type: "LB"');
-    mutationParts.push(`workersMin: ${workersMin}`);
-    mutationParts.push(`workersMax: ${workersMax}`);
-    mutationParts.push(`idleTimeout: ${idleTimeout}`);
-    mutationParts.push('scalerType: "REQUEST_COUNT"');
-    mutationParts.push("scalerValue: 4");
-    mutationParts.push(`executionTimeoutMs: ${executionTimeoutMs ?? 300000}`);
-    mutationParts.push(`gpuIds: "${gqlEscape(gpuIdsStr)}"`);
-    mutationParts.push(`gpuCount: ${gpuCount ?? 1}`);
-    if (vcpuCount) {
-        mutationParts.push(`vcpuCount: ${vcpuCount}`);
-    }
-    if (dataCenterIds.length > 0) {
-        mutationParts.push(`locations: ${JSON.stringify(dataCenterIds.map(gqlEscape))}`);
-    }
-    else {
-        mutationParts.push("locations: null");
-    }
-    if (networkVolumeId) {
-        mutationParts.push(`networkVolumeId: "${gqlEscape(networkVolumeId)}"`);
-    }
-    else {
-        mutationParts.push("networkVolumeId: null");
-    }
-    const mutation = `
-    mutation {
-        saveEndpoint(input: {
-            ${mutationParts.join(", ")}
-        }) {
-            id
-            name
-            gpuIds
-            idleTimeout
-            locations
-            type
-            networkVolumeId
-            executionTimeoutMs
-            scalerType
-            scalerValue
-            templateId
-            userId
-            workersMax
-            workersMin
-            gpuCount
-            __typename
-        }
-    }
-  `;
-    console.log("\nExecuting GraphQL mutation:");
-    console.log(mutation);
-    const result = await runGraphqlQuery(mutation);
-    if (result.errors) {
-        const errors = result.errors;
-        const msg = errors[0]?.message ?? "Unknown error";
-        console.error(`Error creating endpoint: ${msg}`);
-        console.error(`Full error response: ${JSON.stringify(result, null, 2)}`);
-        throw new Error(`Failed to create RunPod endpoint: ${msg}`);
-    }
-    const data = result.data ?? {};
-    const endpointData = data.saveEndpoint ?? {};
-    const endpointId = endpointData.id;
-    if (!endpointId) {
-        console.error("Error: No endpoint ID returned");
-        console.error(`Response data: ${JSON.stringify(result, null, 2)}`);
-        throw new Error("No endpoint ID returned from RunPod GraphQL API");
-    }
-    console.log("\nEndpoint created successfully!");
-    console.log(`  ID: ${endpointId}`);
-    console.log(`  Name: ${endpointData.name}`);
-    console.log(`  GPU Configuration: ${endpointData.gpuIds}`);
-    console.log(`  Workers: ${endpointData.workersMin}-${endpointData.workersMax}`);
-    console.log(`  Scaler: ${endpointData.scalerType}`);
-    return endpointId;
-}
-//# sourceMappingURL=runpod-api.js.map