!(function (e, t, n) {
    function a() {
        var e = t.getElementsByTagName('script')[0],
            n = t.createElement('script')
        ;(n.type = 'text/javascript'),
            (n.async = !0),
            (n.src = 'https://beacon-v2.helpscout.net'),
            e.parentNode.insertBefore(n, e)
    }
    if (
        ((e.Beacon = n =
            function (t, n, a) {
                e.Beacon.readyQueue.push({ method: t, options: n, data: a })
            }),
        (n.readyQueue = []),
        'complete' === t.readyState)
    )
        return a()
    e.attachEvent ? e.attachEvent('onload', a) : e.addEventListener('load', a, !1)
})(window, document, window.Beacon || function () {})
window.Beacon('init', '4f355e62-a67a-4f94-a807-d66284f35ea5')


const script = document.createElement('script')
script.type = 'text/javascript'
script.id = 'hs-script-loader'
script.async = true
script.defer = true
script.src = '//js.hs-scripts.com/7230102.js'

document.head.appendChild(script)


const { parse, stringify } = require('yaml')
const fs = require('fs')
const path = require('path')

const usage = `
Usage: node scripts/add-security-to-schema.js <schema-to-modify>

This script adds the security schema from the base schema to the schema to modify, and enables it for every endpoint.
Base schema and schema to modify can be in either JSON or YAML format.
`

function loadJSONorYAML(file) {
    const fileContent = fs.readFileSync(file, 'utf8')
    const isJson = file.endsWith('.json')
    return {
        data: isJson ? JSON.parse(fileContent) : parse(fileContent),
        isJson,
    }
}

/**
 * Load the base schema
 */
const apiSpecDir = 'api-specs'
const baseSchema = 'salad-cloud'
const schema = fs.readdirSync(apiSpecDir).find((file) => path.basename(file, path.extname(file)) === baseSchema)
const schemaPath = path.join(apiSpecDir, schema)
const { data: schemaObj } = loadJSONorYAML(schemaPath)

/**
 * Load the schema to modify
 */
const schemaToModify = process.argv[2]
if (!schemaToModify) {
    console.error(usage)
    process.exit(1)
}
const { data: schemaToModifyObj, isJson: outputIsJson } = loadJSONorYAML(schemaToModify)

/**
 * Add the security schema from the base schema to the schema to modify, and enable it for every endpoint
 */
schemaToModifyObj.components.securitySchemes = schemaObj.components.securitySchemes
const nameOfScheme = Object.keys(schemaObj.components.securitySchemes)[0]
schemaToModifyObj.security = [{}, { [nameOfScheme]: [] }]

/**
 * Write the modified schema back to the file
 */
const output = outputIsJson ? JSON.stringify(schemaToModifyObj, null, 2) : stringify(schemaToModifyObj)
fs.writeFileSync(schemaToModify, output)


const fs = require('fs')
const path = require('path')
const { parse } = require('yaml')

const usage = `
Usage: node scripts/create-api-spec-for-endpoint.js <config-file>

This script creates an OpenAPI spec for an endpoint based on the base schema and input/output schemas provided in the config file.
The config file must be JSON formatted, and should have the following structure:
{
    "baseSchema": "path/to/base/schema",
    "inputSchema": "path/to/input/schema",
    "outputSchema": "path/to/output/schema",
    "endpointId": "endpoint-id",
    "endpointName": "Endpoint Name",
    "schemaName": "SchemaName",
    "apiDocPath": "path/to/api-docs"
}

A new schema file will be created in the same directory as the base schema, with the name <endpointId>.json.
`

// Directory being run from
const dir = process.cwd()

const getImportName = (filePath) => {
    return path.resolve(dir, filePath)
}

/**
 * Mintlify supports schemas in both JSON and YAML formats. This function
 * reads a file in either format and returns the parsed content.
 * @param {string} file A path to a JSON or YAML file
 * @returns
 */
function loadJSONorYAML(file) {
    const fileContent = fs.readFileSync(file, 'utf8')
    const isJson = file.endsWith('.json')
    return isJson ? JSON.parse(fileContent) : parse(fileContent)
}

/**
 * Deep clone an object using JSON serialization.
 * @param {any} obj Any JSON-serializable object
 * @returns
 */
const clone = (obj) => JSON.parse(JSON.stringify(obj))

if (process.argv.length !== 3) {
    console.error(usage)
    process.exit(1)
}
/**
 * The config file is the first argument passed to the script
 */
const configFile = getImportName(process.argv[2])

/**
 * We start with the base salad cloud schema, because our endpoint
 * is essentially a clone of the inference endpoints schemas, but with
 * the .input and .output schemas replaced with something custom.
 */
console.log(`Reading config file: ${configFile}`)
const config = require(configFile)

const schema = loadJSONorYAML(getImportName(config.baseSchema))
const inputSchema = loadJSONorYAML(getImportName(config.inputSchema))
const outputSchema = loadJSONorYAML(getImportName(config.outputSchema))

const { endpointId, endpointName, schemaName } = config
const inputSchemaName = `${schemaName}Input`
const outputSchemaName = `${schemaName}Output`
const jobSchemaName = `${schemaName}Job`

/**
 * Create a new schema object with the same structure as the base schema,
 * but with the title and description updated to reflect the new endpoint.
 */
const newSchema = clone(schema)
newSchema.info.title = endpointName
newSchema.info.description = `API for ${endpointName}`
newSchema.paths = {}

/**
 * Add the required new schemas to the components section
 */
// .input
newSchema.components.schemas[inputSchemaName] = inputSchema
newSchema.components.schemas[jobSchemaName] = clone(schema.components.schemas.InferenceEndpointJob)
newSchema.components.schemas[jobSchemaName].description = `Job input schema for ${endpointName}`
newSchema.components.schemas[jobSchemaName].properties.input = { $ref: `#/components/schemas/${inputSchemaName}` }

// .output
newSchema.components.schemas[outputSchemaName] = outputSchema
newSchema.components.schemas[jobSchemaName].properties.output = { $ref: `#/components/schemas/${outputSchemaName}` }

/**
 * Duplicate the CreateInferenceEndpointJob schema and update it with custom input and output
 */
newSchema.components.schemas[`Create${jobSchemaName}`] = clone(schema.components.schemas.CreateInferenceEndpointJob)
newSchema.components.schemas[`Create${jobSchemaName}`].description = `Create a job for ${endpointName}`
newSchema.components.schemas[`Create${jobSchemaName}`].properties.input = {
    $ref: `#/components/schemas/${inputSchemaName}`,
}

/**
 * Duplicate the InferenceEndpointJobList schema and update it with the new job schema
 */
newSchema.components.schemas[`${jobSchemaName}List`] = clone(schema.components.schemas.InferenceEndpointJobList)
newSchema.components.schemas[`${jobSchemaName}List`].description = `List of jobs for ${endpointName}`
newSchema.components.schemas[`${jobSchemaName}List`].properties.items = {
    $ref: `#/components/schemas/${jobSchemaName}`,
}

/**
 * The Request and Response body schemas are also defined in the components section.
 * As before, we duplicate the existing schemas and update them.
 */

/**
 * Request Body: Create
 */
newSchema.components.requestBodies[`Create${jobSchemaName}`] = clone(
    schema.components.requestBodies.CreateInferenceEndpointJob,
)
newSchema.components.requestBodies[`Create${jobSchemaName}`].content['application/json'].schema = {
    $ref: `#/components/schemas/Create${jobSchemaName}`,
}

/**
 * There are many irrelevant request bodies from the base schema that we can clear out.
 */
Object.keys(newSchema.components.requestBodies).forEach((key) => {
    if (key !== `Create${jobSchemaName}`) {
        delete newSchema.components.requestBodies[key]
    }
})

/**
 * Response Bodies
 */
// List
newSchema.components.responses[`List${jobSchemaName}`] = clone(schema.components.responses.ListInferenceEndpointJobs)
newSchema.components.responses[`List${jobSchemaName}`].content['application/json'].schema = {
    $ref: `#/components/schemas/${jobSchemaName}List`,
}

// Get
newSchema.components.responses[`Get${jobSchemaName}`] = clone(schema.components.responses.GetInferenceEndpointJob)
newSchema.components.responses[`Get${jobSchemaName}`].content['application/json'].schema = {
    $ref: `#/components/schemas/${jobSchemaName}`,
}

// Create
newSchema.components.responses[`Create${jobSchemaName}`] = clone(schema.components.responses.CreateInferenceEndpointJob)
newSchema.components.responses[`Create${jobSchemaName}`].content['application/json'].schema = {
    $ref: `#/components/schemas/${jobSchemaName}`,
}

/**
 * There are many irrelevant response bodies from the base schema that we can clear out.
 * We only need the errors, and the job-related responses.
 */
function isNumber(str) {
    return !isNaN(str) && !isNaN(parseFloat(str))
}
Object.keys(newSchema.components.responses).forEach((key) => {
    if (
        ![`List${jobSchemaName}`, `Get${jobSchemaName}`, `Create${jobSchemaName}`, 'UnknownError'].includes(key) &&
        !isNumber(key) &&
        !key.includes('InferenceEndpoint')
    ) {
        delete newSchema.components.responses[key]
    }
})

// Path Parameters
newSchema.components.parameters.job_id = clone(schema.components.parameters.inference_endpoint_job_id)
newSchema.components.parameters.job_id.description = `The ID of the job for ${endpointName}`
newSchema.components.parameters.job_id.name = 'job_id'

/**
 * Now we add the new endpoint to the paths section of the schema.
 */
// Resource: /organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}
const endpointPath = `/organizations/{organization_name}/inference-endpoints/${endpointId}`
newSchema.paths[endpointPath] = clone(
    schema.paths['/organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}'],
)

// Remove the no-longer-needed variable reference
let inferenceEndpointNameParamIndex = newSchema.paths[endpointPath].parameters.findIndex(
    (param) => param.$ref === '#/components/parameters/inference_endpoint_name',
)
if (inferenceEndpointNameParamIndex !== -1) {
    newSchema.paths[endpointPath].parameters.splice(inferenceEndpointNameParamIndex, 1)
}
// Resource: /organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}/jobs
newSchema.paths[`${endpointPath}/jobs`] = clone(
    schema.paths['/organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}/jobs'],
)
newSchema.paths[`${endpointPath}/jobs`].summary = `Jobs for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].description = `Operations for ${endpointName} jobs`

// Remove the no-longer-needed variable reference
const jobsInferenceEndpointNameParamIndex = newSchema.paths[`${endpointPath}/jobs`].parameters.findIndex(
    (param) => param.$ref === '#/components/parameters/inference_endpoint_name',
)
if (jobsInferenceEndpointNameParamIndex !== -1) {
    newSchema.paths[`${endpointPath}/jobs`].parameters.splice(jobsInferenceEndpointNameParamIndex, 1)
}

newSchema.paths[`${endpointPath}/jobs`].get.summary = `List jobs for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].get.description = `Retrieves a list of jobs for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].get.responses['200'] = {
    $ref: `#/components/responses/List${jobSchemaName}`,
}
newSchema.paths[`${endpointPath}/jobs`].post.summary = `Create a job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].post.description = `Creates a job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].post.requestBody = {
    $ref: `#/components/requestBodies/Create${jobSchemaName}`,
}
newSchema.paths[`${endpointPath}/jobs`].post.responses['201'] = {
    $ref: `#/components/responses/Create${jobSchemaName}`,
}

// Resource: /organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}/jobs/{job_id}
newSchema.paths[`${endpointPath}/jobs/{job_id}`] = clone(
    schema.paths[
        '/organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}/jobs/{inference_endpoint_job_id}'
    ],
)
newSchema.paths[`${endpointPath}/jobs/{job_id}`].summary = `Job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs/{job_id}`].description = `Operations for a ${endpointName} job`
newSchema.paths[`${endpointPath}/jobs/{job_id}`].parameters.push({ $ref: '#/components/parameters/job_id' })

// Remove the no-longer-needed variable reference
const jobInferenceEndpointNameParamIndex = newSchema.paths[`${endpointPath}/jobs/{job_id}`].parameters.findIndex(
    (param) => param.$ref === '#/components/parameters/inference_endpoint_name',
)
if (jobInferenceEndpointNameParamIndex !== -1) {
    newSchema.paths[`${endpointPath}/jobs/{job_id}`].parameters.splice(jobInferenceEndpointNameParamIndex, 1)
}
inferenceEndpointNameParamIndex = newSchema.paths[`${endpointPath}/jobs/{job_id}`].parameters.findIndex(
    (param) => param.$ref === '#/components/parameters/inference_endpoint_job_id',
)
if (inferenceEndpointNameParamIndex !== -1) {
    newSchema.paths[`${endpointPath}/jobs/{job_id}`].parameters.splice(inferenceEndpointNameParamIndex, 1)
}

newSchema.paths[`${endpointPath}/jobs/{job_id}`].get.summary = `Get job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs/{job_id}`].get.description = `Retrieves a job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs/{job_id}`].get.responses['200'] = {
    $ref: `#/components/responses/Get${jobSchemaName}`,
}

newSchema.paths[`${endpointPath}/jobs/{job_id}`].delete.summary = `Delete job for ${endpointName}`

/**
 * Write the new schema to a file
 */
const newSchemaPath = path.join(path.dirname(config.baseSchema), `${endpointId}.json`)
fs.writeFileSync(newSchemaPath, JSON.stringify(newSchema, null, 2))

console.log(`New schema created: ${newSchemaPath}`)


const fs = require('fs')
const path = require('path')

const usage = `
Usage: move-page.js <source> <destination>

Moves a page from one location to another, updating all links, and adding a redirect to mint.json
`

let src = process.argv[2]
let dest = process.argv[3]

if (!src || !dest) {
    console.error(usage)
    process.exit(1)
}

if (!src.endsWith('.mdx')) {
    src += '.mdx'
}

if (!dest.endsWith('.mdx')) {
    dest += '.mdx'
}

if (!fs.existsSync(src)) {
    console.error(`Source file does not exist: ${src}`)
    process.exit(1)
}

if (fs.existsSync(dest)) {
    console.error(`Destination file already exists: ${dest}`)
    process.exit(1)
}

fs.mkdirSync(path.dirname(dest), { recursive: true })

/**
 * name is the relative path from the root of the project to the source file, without the leading slash,
 * and with the file extension removed.
 *  */
const srcName = path.relative(process.cwd(), src).slice(0, -path.extname(src).length)
const srcPath = `/${srcName}`
const destName = path.relative(process.cwd(), dest).slice(0, -path.extname(dest).length)
const destPath = `/${destName}`

const mint = require('../mint.json')

// Move the page
fs.renameSync(src, dest)
console.log(`Moved ${src} to ${dest}`)

// Add the redirect
mint.redirects.push({
    source: srcPath,
    destination: destPath,
})

/*
 * Update the navigation array in mint.json, which is a recursive structure of { group, pages }, where pages is an array
 * of either strings or objects with group and pages.
 * */
function updateNavigation(navigation, updated = []) {
    for (const item of navigation) {
        if (typeof item === 'string') {
            if (item === srcName) {
                updated.push(destName)
            } else {
                updated.push(item)
            }
        } else {
            const group = { ...item }
            group.pages = updateNavigation(group.pages)
            updated.push(group)
        }
    }
    return updated
}
mint.navigation = updateNavigation(mint.navigation)

fs.writeFileSync('mint.json', JSON.stringify(mint, null, 2))
console.log(`Updated mint.json`)

console.log('updating all links in .mdx files')
// Update all links in .mdx files, recursively
function updateLinks(directory) {
    for (const file of fs.readdirSync(directory, { withFileTypes: true })) {
        const filePath = path.join(directory, file.name)
        if (file.isDirectory()) {
            updateLinks(filePath)
        } else if (file.name.endsWith('.mdx')) {
            const content = fs.readFileSync(filePath, 'utf8')
            if (!content.includes(srcPath)) {
                continue
            }
            console.log(`Updating links in ${filePath}`)
            const updated = content.replace(new RegExp(srcPath, 'g'), destPath)
            fs.writeFileSync(filePath, updated)
            console.log(`Updated links in ${filePath}`)
        }
    }
}
updateLinks('.')


SaladCloud

Products

Tutorials

How-to Guides

Reference

Portal

Blog

Community

Support

Need support for your SaladCloud account? Start here.

SaladCloud Support

Information, Tutorials, How-To Guides and API Reference for SaladCloud Products

Introduction

SaladCloud Documentation

Start using the powerful network of SaladCloud GPUs in under 5 minutes

Create An Account

Salad Container Engine (SCE)

Get your first container up and running on SaladCloud in minutes!

Quickstart

Quickstart - API

The world’s largest distributed GPU cloud at the most competitive prices!

SCE Architectural Overview

Container Groups

The Deployment Lifecycle

Managing Deployments

Using Environment Variables

Specifying a command

Disk Space

Workload Logs

Container Logs

Quotas

FAQs

Networking / Container Gateway

Enabling IPv6

Authenticated Requests

Load Balancing Options

WebSockets

Error Pages

Job Queues

Creating a Job Queue

Job Queue Worker

Using Queues

Autoscaling Overview

Autoscaling Settings

Set Up Autoscaling

Salad Container Engine FAQs

Connect to SGS using HTTP CONNECT over TLS and begin using it in production

Connect to SGS using HAProxy's PROXY v2 protocol

Using PROXY v2 Protocol

How to request removal of a SaladCloud Node from your SGS server

Node Removals

SGS is designed for connecting to only specific domains

Approved Domains

Optional feature to increase success rate when connecting to specific domains

Smart Routing

Transform your audio, video, and text content into accurate transcripts, translations, summaries, and more with Salad Transcription API

Overview

Salad Transcription API Overview

Transform spoken words into accurate text with Salad Transcription API’s powerful speech-to-text capabilities.

Speech-to-Text

Break language barriers by translating your transcriptions into multiple languages using Salad Transcription API.

Translation

Generate accurate, industry-standard captions and subtitles using Salad Transcription API.

Captions

Unlock deeper understanding and actionable intelligence from your transcriptions with Salad Transcription API.

Text Insights and Intelligence

This is a simple HTTP service to allow SaladCloud customers to temporarily upload assets for use in other SaladCloud services. Examples include uploading images for stable diffusion training or inference, audio clips for transcription, etc.

Salad Simple Storage Service

Easy-to-deploy templates for deploying common workloads on Salad Container Engine.

Container Engine Recipes

Dreamshaper 8 - ComfyUI (API)

FLUX.1-Schnell (FP8) - ComfyUI (API)

Llama 3.1-8b with Ollama

Stable Diffusion 3.5 Large - ComfyUI(API)

Stable Diffusion 3.5 Medium - ComfyUI(API)

Stable Diffusion XL with Refiner - ComfyUI (API)

YOLOv8 Object Detection API

Docker Run on SaladCloud

How to deploy a Node App on SaladCloud

Create Your first "hello world"

Create a container

Save to docker hub

Deploy via portal

Deploy via API

How to Use the SaladCloud Terminal

Run a Python App

Using our preset Ubuntu image

Using our preset example image

Run NVIDIA Triton Server on SaladCloud

Run JupyterLab

Run Cog Applications on SaladCloud

Long-Running Jobs

Truss Deployment Guide to SaladCloud Portal and API

Start integrating directly with SaladCloud's robust API

Using the API

Gets the health statuses of the running container

Get Container Status

Gets the identity token of the running container

Get Container Token

Reallocates the running container to another Salad Node

Reallocate Container

Upload a file

Download a file

Delete a file

List all files

Sign a file and return a signed URL

Creates a job for Salad Transcription API

Create a job for Salad Transcription API

Retrieves a job for Salad Transcription API

Get job for Salad Transcription API

Delete job for Salad Transcription API

How to deploy an image generation service on SaladCloud

Image Generation On SaladCloud

A guide to deploying a custom stable diffusion model on SaladCloud with ComfyUI

How to Deploy Stable Diffusion (ComfyUI)

A guide to deploying a custom stable diffusion model on SaladCloud with Automatic1111

SaladCloud Support

Status Page

Contact Sales

Contact Support

Report Abuse