gaudio_create_job

Instructions

Implementation Reference

• src/tools/create-job.ts:1-54 (handler)

  The handler function that registers and implements the 'gaudio_create_job' tool. It defines a Zod schema with uploadId, model, and optional type parameters; validates the model exists and type is provided when required; calls client.createJob(model, params) to create the job; and returns the jobId, model, and status.

  import { z } from "zod";
  import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
  import type { GaudioClient } from "../api/client.js";
  import { getModel } from "../models/registry.js";
  
  export function registerCreateJob(server: McpServer, client: GaudioClient) {
    server.tool(
      "gaudio_create_job",
      "Create a processing job with an uploaded file. For Stem Separation models (gsep_music_hq_v1, gsep_music_shq_v1, gsep_speech_hq_v1), the 'type' parameter is required (e.g. 'vocal', 'vocal,drum'). For DME models, no type is needed. For Text Sync (gts_lyrics_line_v1), use gaudio_sync_lyrics instead.",
      {
        uploadId: z.string().describe("Upload ID from gaudio_upload_file (used as audioUploadId)"),
        model: z.string().describe("Model name (e.g. gsep_music_hq_v1, gsep_dme_dtrack_v1)"),
        type: z
          .string()
          .optional()
          .describe("Stem type(s), comma-separated. Required for Stem Separation models. e.g. 'vocal', 'vocal,drum,bass'"),
      },
      async ({ uploadId, model, type }) => {
        const modelInfo = getModel(model);
        if (!modelInfo) {
          return {
            content: [{ type: "text" as const, text: `Unknown model: ${model}. Use gaudio_list_models to see available models.` }],
            isError: true,
          };
        }
  
        if (modelInfo.typeRequired && !type) {
          return {
            content: [
              {
                type: "text" as const,
                text: `Model ${model} requires a 'type' parameter. Options: ${modelInfo.typeOptions?.join(", ")}`,
              },
            ],
            isError: true,
          };
        }
  
        const params: Record<string, unknown> = { audioUploadId: uploadId };
        if (type) params.type = type;
  
        const { jobId } = await client.createJob(model, params);
  
        return {
          content: [
            {
              type: "text" as const,
              text: JSON.stringify({ jobId, model, status: "created" }, null, 2),
            },
          ],
        };
      },
    );
  }

• src/index.ts:29-37 (registration)

  Registration of the gaudio_create_job tool by calling registerCreateJob(server, client) in the main entry point.

  registerCreateJob(server, client);
  registerGetJob(server, client);
  registerSeparateAudio(server, client);
  registerSyncLyrics(server, client);
  registerGetKeyInfo(server, client);
  
  const transport = new StdioServerTransport();
  await server.connect(transport);

• src/tools/create-job.ts:10-17 (schema)

  Zod schema for gaudio_create_job: uploadId (string), model (string), type (optional string for stem separation).

  {
    uploadId: z.string().describe("Upload ID from gaudio_upload_file (used as audioUploadId)"),
    model: z.string().describe("Model name (e.g. gsep_music_hq_v1, gsep_dme_dtrack_v1)"),
    type: z
      .string()
      .optional()
      .describe("Stem type(s), comma-separated. Required for Stem Separation models. e.g. 'vocal', 'vocal,drum,bass'"),
  },

• src/api/client.ts:163-169 (helper)

  The client.createJob method called by the handler. It POSTs to /{model}/jobs with the provided params (including audioUploadId and optional type) and returns the jobId from the response.

  async createJob(
    model: string,
    params: Record<string, unknown>,
  ): Promise<{ jobId: string }> {
    const res = await this.request("POST", `/${model}/jobs`, params);
    return { jobId: res.resultData?.jobId as string };
  }

• src/models/registry.ts:120-122 (helper)

  The getModel helper used by the handler to validate the model name exists in the registry.

  export function getModel(name: string): ModelInfo | undefined {
    return MODEL_REGISTRY.find((m) => m.name === name);
  }