@sync.so/mcp-server 0.1.3 → 0.2.0

package/dist/tools/audio-trim.js

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { schemaProperty } from '../openapi/parser.js';
+export function supportsAudioTrimming(operations) {
+    const create = operations.find((op) => op.method === 'post' && op.path === '/v2/audio-trims');
+    return (!!create?.parameters.some((p) => p.in === 'header' && p.name.toLowerCase() === 'idempotency-key' && p.required) &&
+        schemaProperty(create.requestBody?.schema ?? {}, 'assetId')?.format === 'uuid' &&
+        !!operations.some((op) => op.method === 'get' && op.path === '/v2/audio-trims/{id}'));
+}
+const result = z.object({
+    id: z.uuid(),
+    status: z.enum(['queued', 'processing', 'completed', 'failed']),
+    assetId: z.uuid().nullable(),
+    durationSeconds: z.number().positive().nullable(),
+    errorCode: z.string().nullable(),
+    retryAfterMs: z.number().int().nonnegative(),
+});
+export function createAudioTrimTools(operations, http) {
+    if (!supportsAudioTrimming(operations))
+        return [];
+    // assetId is the API's name for the source; audioAssetId is the older MCP name.
+    const create = z
+        .object({
+        assetId: z.uuid().optional().describe('Saved AUDIO asset to shorten.'),
+        projectId: z.uuid().optional(),
+        durationSeconds: z.number().min(0.01).max(3600),
+        idempotencyKey: z.uuid(),
+        audioAssetId: z
+            .uuid()
+            .optional()
+            .describe('Deprecated alias of assetId.')
+            .meta({ deprecated: true }),
+    })
+        .strict();
+    const read = z.object({ id: z.uuid() }).strict();
+    return [
+        {
+            name: 'audio-trims_create',
+            title: 'Prepare shorter audio',
+            description: 'Save the first durationSeconds of an authorized Sync audio asset, passed as assetId, as a new reusable asset. Explain and confirm the partial duration first. Persist one idempotencyKey and reuse it with identical inputs after an uncertain response. This prepares audio only: it never generates video, spends generation credits, or consumes a free generation. Poll audio-trims_get until completed, then use its assetId and actual duration for a fresh quote. Partial video lipsync must use cut_off; keep the original draft unchanged. Failed operations require an explicit new attempt.',
+            inputSchema: create.shape,
+            outputSchema: result.shape,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+            handler: async (args, context) => {
+                const { assetId, audioAssetId, idempotencyKey, ...rest } = create.parse(args);
+                const source = assetId ?? audioAssetId;
+                if (source === undefined)
+                    throw new Error('Pass assetId.');
+                if (assetId !== undefined && audioAssetId !== undefined && assetId !== audioAssetId)
+                    throw new Error('assetId and audioAssetId name different assets; pass assetId only.');
+                return result.parse(await http.request('post', '/v2/audio-trims', {
+                    body: { ...rest, assetId: source },
+                    headers: { 'Idempotency-Key': idempotencyKey },
+                    signal: context?.signal,
+                }));
+            },
+        },
+        {
+            name: 'audio-trims_get',
+            title: 'Read audio preparation',
+            description: 'Read the same authorized audio preparation. Pending status is resumable; do not create another trim. This never starts video generation.',
+            inputSchema: read.shape,
+            outputSchema: result.shape,
+            annotations: {
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+            handler: async (args, context) => result.parse(await http.request('get', `/v2/audio-trims/${read.parse(args).id}`, {
+                signal: context?.signal,
+            })),
+        },
+    ];
+}

package/dist/tools/batch-results.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+/**
+ * A finished batch's results. The API writes one JSONL line per item (request_id, status,
+ * error and the /v2/generate response) and serves the file publicly behind the API origin;
+ * batches_get turns it into rows the agent can use without downloading anything.
+ */
+export declare const BATCH_DONE: Set<string>;
+export declare const resultRow: z.ZodObject<{
+    requestId: z.ZodString;
+    status: z.ZodString;
+    generationId: z.ZodOptional<z.ZodString>;
+    outputMediaUrl: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare function withResults(batch: Record<string, unknown>, which: 'all' | 'failed' | 'none', apiBaseUrl: string, signal: AbortSignal | undefined): Promise<Record<string, unknown>>;
+//# sourceMappingURL=batch-results.d.ts.map

package/dist/tools/batch-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-results.d.ts","sourceRoot":"","sources":["../../src/tools/batch-results.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;GAIG;AAEH,eAAO,MAAM,UAAU,aAAmC,CAAC;AAQ3D,eAAO,MAAM,SAAS;;;;;;iBAMpB,CAAC;AAsEH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,EAChC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAiBlC"}

package/dist/tools/batch-results.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { boundedBy, TIMED_OUT } from './job-wait.js';
+/**
+ * A finished batch's results. The API writes one JSONL line per item (request_id, status,
+ * error and the /v2/generate response) and serves the file publicly behind the API origin;
+ * batches_get turns it into rows the agent can use without downloading anything.
+ */
+export const BATCH_DONE = new Set(['COMPLETED', 'FAILED']);
+const RESULTS_TIMEOUT_MS = 30_000;
+const MAX_RESULTS_BYTES = 20 * 1024 * 1024;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export const resultRow = z.object({
+    requestId: z.string(),
+    status: z.string().describe('The generation status: COMPLETED, FAILED or REJECTED.'),
+    generationId: z.string().optional().describe('Read it with generations_get.'),
+    outputMediaUrl: z.string().optional().describe('The finished video; return it verbatim.'),
+    error: z.unknown().optional(),
+});
+function rowOf(line) {
+    if (!isRecord(line) || typeof line.request_id !== 'string')
+        return undefined;
+    const response = isRecord(line.response) ? line.response : {};
+    const output = response.outputMediaUrl ?? response.outputUrl;
+    return {
+        requestId: line.request_id,
+        status: typeof line.status === 'string' ? line.status : 'UNKNOWN',
+        ...(typeof response.id === 'string' ? { generationId: response.id } : {}),
+        ...(typeof output === 'string' && output ? { outputMediaUrl: output } : {}),
+        ...(line.error === null || line.error === undefined ? {} : { error: line.error }),
+    };
+}
+const TOO_LARGE = 'the result file is too large to read here';
+/**
+ * The body as text, counting decoded bytes as they arrive, so a chunked or compressed
+ * file cannot grow past the cap in memory: the download is canceled once it would.
+ */
+async function readCapped(res) {
+    if (!res.body)
+        return '';
+    const reader = res.body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        bytes += value.byteLength;
+        if (bytes > MAX_RESULTS_BYTES) {
+            await reader.cancel().catch(() => { });
+            throw new Error(TOO_LARGE);
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/**
+ * The result file is public behind the API origin, which redirects to a signed copy; it
+ * is fetched without credentials, and only from the API origin.
+ */
+async function readResults(outputUrl, apiBaseUrl, signal) {
+    const url = new URL(outputUrl);
+    if (url.origin !== new URL(apiBaseUrl).origin)
+        throw new Error(`the result file is not on the Sync API (${url.origin})`);
+    const response = await boundedBy(RESULTS_TIMEOUT_MS, signal, (bounded) => fetch(url, { signal: bounded, redirect: 'follow' }).then(async (res) => {
+        if (!res.ok)
+            throw new Error(`the result file answered ${res.status}`);
+        if (Number(res.headers.get('content-length') ?? 0) > MAX_RESULTS_BYTES)
+            throw new Error(TOO_LARGE);
+        return readCapped(res);
+    }));
+    if (response === TIMED_OUT)
+        throw new Error('reading the result file timed out');
+    return response
+        .split('\n')
+        .filter((line) => line.trim() !== '')
+        .map((line) => rowOf(JSON.parse(line)))
+        .filter((row) => row !== undefined);
+}
+const FAILED_ROW = new Set(['FAILED', 'REJECTED']);
+export async function withResults(batch, which, apiBaseUrl, signal) {
+    if (which === 'none' || !BATCH_DONE.has(String(batch.status)))
+        return batch;
+    if (typeof batch.outputUrl !== 'string' || batch.outputUrl === '')
+        return batch;
+    try {
+        const rows = await readResults(batch.outputUrl, apiBaseUrl, signal);
+        return {
+            ...batch,
+            results: which === 'failed' ? rows.filter((row) => FAILED_ROW.has(row.status)) : rows,
+        };
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        const reason = error instanceof Error ? error.message : String(error);
+        return {
+            ...batch,
+            resultsError: `${reason}. Download outputUrl (JSONL, one line per item with request_id, status, error and response) or find the generations with generations_list.`,
+        };
+    }
+}

package/dist/tools/batches.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { type HttpClient } from '../http-client.js';
+import type { ParsedOperation } from '../openapi/types.js';
+import type { McpToolDefinition } from './generator.js';
+/**
+ * batches_create, batches_get and batches_list: many independent /v2/generate generations
+ * as one Sync batch. batches_create builds the API's JSON `rows` form and checks locally
+ * what the API would refuse anyway, naming the item. batches_get adds each row's result
+ * from batch-results.ts once the batch finishes.
+ */
+export declare const BATCH_TOOLS: readonly ['batches_create', 'batches_get', 'batches_list'];
+export declare function isBatchOperation(operation: ParsedOperation): boolean;
+declare const item: z.ZodObject<{
+    requestId: z.ZodOptional<z.ZodString>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+type BatchRow = {
+    request_id: string;
+    endpoint: '/v2/generate';
+    payload: Record<string, unknown>;
+};
+/** The API's rows, or an error naming every item it would refuse (up to a few). */
+export declare function buildBatchRows(items: z.infer<typeof item>[]): BatchRow[];
+/** Running share of the batch, for progress notifications. */
+export declare function batchProgress(batch: Record<string, unknown>): number | undefined;
+export declare function createBatchTools(operations: ParsedOperation[], http: HttpClient, apiBaseUrl: string): McpToolDefinition[];
+export {};
+//# sourceMappingURL=batches.d.ts.map

package/dist/tools/batches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batches.d.ts","sourceRoot":"","sources":["../../src/tools/batches.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,gBAAgB,CAAC;AAI5E;;;;;GAKG;AAEH,eAAO,MAAM,WAAW,YAAI,gBAAgB,EAAE,aAAa,EAAE,cAAc,CAAU,CAAC;AAUtF,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,eAAe,GAAG,OAAO,CAEpE;AAYD,QAAA,MAAM,IAAI;;;kBAgBC,CAAC;AAqIZ,KAAK,QAAQ,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC;AAEnG,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,EAAE,GAAG,QAAQ,EAAE,CA8BxE;AA6BD,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS,CAKhF;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,eAAe,EAAE,EAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,MAAM,GACjB,iBAAiB,EAAE,CAkGrB"}

package/dist/tools/batches.js

@@ -0,0 +1,293 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { ApiRequestError } from '../http-client.js';
+import { BATCH_DONE, resultRow, withResults } from './batch-results.js';
+import { pollUntil, waitInput } from './job-wait.js';
+import { projectIntentError, projectUseAllowed } from './project-intent.js';
+/**
+ * batches_create, batches_get and batches_list: many independent /v2/generate generations
+ * as one Sync batch. batches_create builds the API's JSON `rows` form and checks locally
+ * what the API would refuse anyway, naming the item. batches_get adds each row's result
+ * from batch-results.ts once the batch finishes.
+ */
+export const BATCH_TOOLS = ['batches_create', 'batches_get', 'batches_list'];
+const MIN_ITEMS = 20;
+// The API measures the rows as JSONL, one compact JSON object per line.
+const MAX_JSONL_BYTES = 5 * 1024 * 1024;
+const LIST_STATUSES = ['PENDING', 'JOBS_CREATED', 'PROCESSING', 'COMPLETED', 'FAILED'];
+const MAX_REPORTED_PROBLEMS = 10;
+const BATCH_ROUTES = ['post /v2/batch', 'get /v2/batch', 'get /v2/batch/{id}'];
+export function isBatchOperation(operation) {
+    return BATCH_ROUTES.includes(`${operation.method} ${operation.path}`);
+}
+function supportsBatches(operations) {
+    return BATCH_ROUTES.every((route) => operations.some((operation) => `${operation.method} ${operation.path}` === route));
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+const item = z
+    .object({
+    requestId: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe('Your id for this item, unique in the batch. Omit it to get item-<n> (n counts from 1). Each result row carries it.'),
+    payload: z
+        .record(z.string(), z.unknown())
+        .describe('One POST /v2/generate body, the same as a single generation: {model, input: [{type: "video", url}, {type: "audio", url}], options?}. Input items take a public URL or a Sync assetId; a text input takes {type: "text", provider: {...}} with a voice from voices_list.'),
+})
+    .strict();
+const createInput = z
+    .object({
+    items: z
+        .array(item)
+        .min(MIN_ITEMS, `A batch needs at least ${MIN_ITEMS} items; create fewer generations one at a time.`)
+        .describe(`The generations, in order; at least ${MIN_ITEMS}. Plans allow up to 500 per batch by default, and the whole batch must fit in 5 MB as JSONL.`),
+    dryRun: z
+        .boolean()
+        .optional()
+        .describe('Validate every item with the API without creating the batch or spending anything; answers status VALIDATED.'),
+    webhookUrl: z
+        .url()
+        .optional()
+        .describe('URL Sync POSTs the batch to when it finishes, signed with the organization webhook secret.'),
+    projectIntent: z
+        .literal('explicit')
+        .optional()
+        .describe('Required when any payload sets projectId. Set only when the user explicitly chose that project, or it is the project just created for this request; never infer it from a matching name or an open editor.'),
+})
+    .strict();
+/** Items writing into an existing project need the same explicit intent as every write tool. */
+function assertProjectIntent(items, projectIntent) {
+    const refused = items.flatMap(({ payload }, index) => projectUseAllowed(payload.projectId, projectIntent) ? [] : [`items[${index}]`]);
+    if (refused.length === 0)
+        return;
+    const named = refused.slice(0, MAX_REPORTED_PROBLEMS).join(', ');
+    const more = refused.length > MAX_REPORTED_PROBLEMS
+        ? ` and ${refused.length - MAX_REPORTED_PROBLEMS} more`
+        : '';
+    throw projectIntentError(`The batch was not sent: ${named}${more} set payload.projectId without projectIntent=explicit. `);
+}
+const metrics = z
+    .looseObject({
+    total_generations: z.number().optional(),
+    success_count: z.number().optional(),
+    failed_count: z.number().optional(),
+    pending_count: z.number().optional(),
+})
+    .describe('Generation counts: total, succeeded, failed and still pending.');
+const batchFields = {
+    id: z.string().describe('The batch id; pass it to batches_get.'),
+    status: z
+        .string()
+        .describe('PENDING, JOBS_CREATED or PROCESSING while running (internal states also mean running); COMPLETED or FAILED when done.'),
+    created_at: z.string().optional(),
+    metrics: metrics.optional(),
+    webhookUrl: z.string().nullable().optional(),
+    outputUrl: z
+        .string()
+        .nullable()
+        .optional()
+        .describe('The JSONL result file once the batch finishes; empty while it runs.'),
+};
+const createOutput = {
+    ...batchFields,
+    id: batchFields.id.optional(),
+    requestIds: z
+        .array(z.string())
+        .describe('Each item’s requestId, in item order, including generated ones.'),
+};
+const getInput = z
+    .object({
+    id: z.string().trim().min(1).describe('The batch id batches_create or batches_list returned.'),
+    wait: waitInput,
+    results: z
+        .enum(['all', 'failed', 'none'])
+        .optional()
+        .describe('Once the batch finishes, which result rows to return: all (default), failed (FAILED or REJECTED only) or none.'),
+})
+    .strict();
+const getOutput = {
+    ...batchFields,
+    results: z
+        .array(resultRow)
+        .optional()
+        .describe('One row per item from the result file, once the batch finishes.'),
+    resultsError: z
+        .string()
+        .optional()
+        .describe('Why the result file could not be read; the batch fields are still current.'),
+};
+const listInput = z
+    .object({
+    status: z.enum(LIST_STATUSES).optional(),
+    createdAfter: z.string().optional().describe('ISO 8601 date-time.'),
+    createdBefore: z.string().optional().describe('ISO 8601 date-time.'),
+})
+    .strict();
+function payloadProblem(payload) {
+    // The API expands Edit Dialogue rows itself, with their own checks.
+    if (payload.dialogueEdit !== undefined)
+        return undefined;
+    if (typeof payload.model !== 'string' || payload.model.trim() === '')
+        return 'payload.model must name a model, such as sync-3 (see models_list)';
+    if (!Array.isArray(payload.input) || payload.input.length === 0)
+        return 'payload.input must list the inputs, such as {type: "video", url} and {type: "audio", url}';
+    const bad = payload.input.findIndex((entry) => !isRecord(entry) || typeof entry.type !== 'string');
+    return bad === -1 ? undefined : `payload.input[${bad}] needs a type: video, image, audio or text`;
+}
+/** The API's rows, or an error naming every item it would refuse (up to a few). */
+export function buildBatchRows(items) {
+    const problems = [];
+    const firstUse = new Map();
+    items.forEach(({ requestId, payload }, index) => {
+        if (requestId !== undefined) {
+            const first = firstUse.get(requestId);
+            if (first === undefined)
+                firstUse.set(requestId, index);
+            else
+                problems.push(`items[${index}].requestId "${requestId}" repeats items[${first}]`);
+        }
+        const problem = payloadProblem(payload);
+        if (problem)
+            problems.push(`items[${index}]: ${problem}`);
+    });
+    if (problems.length > 0) {
+        const more = problems.length - MAX_REPORTED_PROBLEMS;
+        throw new Error(`The batch was not sent. ${problems.slice(0, MAX_REPORTED_PROBLEMS).join('; ')}${more > 0 ? `; and ${more} more` : ''}. Every requestId must be unique in the batch.`);
+    }
+    const rows = items.map(({ requestId, payload }, index) => {
+        let id = requestId ?? `item-${index + 1}`;
+        if (requestId === undefined && firstUse.has(id))
+            id = `${id}-${randomUUID().slice(0, 8)}`;
+        firstUse.set(id, index);
+        return { request_id: id, endpoint: '/v2/generate', payload };
+    });
+    const bytes = Buffer.byteLength(rows.map((row) => JSON.stringify(row)).join('\n'));
+    if (bytes > MAX_JSONL_BYTES)
+        throw new Error(`The batch was not sent: it is ${(bytes / 1024 / 1024).toFixed(1)} MB as JSONL and the API takes at most 5 MB. Split the items into smaller batches.`);
+    return rows;
+}
+const BATCH_LIMIT_STEP = 'This account already runs as many batches as its plan allows (activeBatches of concurrencyLimit). Wait for one to finish, with batches_list status PROCESSING or batches_get wait: true, then create this batch once. Creating it again before then fails the same way.';
+function planStep(requiredPlan) {
+    const plan = requiredPlan === 'enterprise'
+        ? ' No self-serve plan includes it; the user can contact sync.'
+        : requiredPlan
+            ? ` It needs the ${requiredPlan} plan or above.`
+            : '';
+    return `Batch is not on this account’s plan.${plan} Tell the user, with billingUrl when present, where a person can change the plan. Meanwhile, create the generations one at a time with lipsync_create or dubbing_create. Creating the batch again fails the same way until the plan changes.`;
+}
+/** Tell the agent what changes the outcome; API lines are 1-based item positions. */
+function explainCreateError(error) {
+    if (!(error instanceof ApiRequestError))
+        throw error;
+    if (error.status === 402 && error.code === 'plan_feature_unavailable')
+        error.nextStep = planStep(error.details?.requiredPlan);
+    else if (error.status === 429 && error.code === 'concurrency_limit_reached')
+        error.nextStep = BATCH_LIMIT_STEP;
+    else if (error.status === 400 || error.status === 422) {
+        const line = error.details?.lineNumber;
+        error.nextStep = `${line ? `Line ${line} is items[${line - 1}]. ` : 'An API message citing line N means items[N-1]. '}Fix the items, check with dryRun: true, then create the batch once.`;
+    }
+    throw error;
+}
+/** Running share of the batch, for progress notifications. */
+export function batchProgress(batch) {
+    const counts = isRecord(batch.metrics) ? batch.metrics : {};
+    const total = Number(counts.total_generations);
+    const done = Number(counts.success_count ?? 0) + Number(counts.failed_count ?? 0);
+    return total > 0 && Number.isFinite(done) ? Math.min((done / total) * 100, 100) : undefined;
+}
+export function createBatchTools(operations, http, apiBaseUrl) {
+    if (!supportsBatches(operations))
+        return [];
+    const readBatch = async (id, signal) => {
+        const batch = await http.request('get', `/v2/batch/${encodeURIComponent(id)}`, { signal });
+        return isRecord(batch) ? batch : { id, status: 'UNKNOWN' };
+    };
+    const get = async (args, context) => {
+        const input = getInput.parse(args);
+        const batch = input.wait
+            ? await pollUntil((signal) => readBatch(input.id, signal), (b) => BATCH_DONE.has(String(b.status)), context, {
+                describe: (b) => {
+                    const progress = batchProgress(b);
+                    return `batch ${String(b.status).toLowerCase()}${progress === undefined ? '' : ` ${Math.round(progress)}%`}`;
+                },
+            })
+            : await readBatch(input.id, context?.signal);
+        return withResults(batch, input.results ?? 'all', apiBaseUrl, context?.signal);
+    };
+    return [
+        {
+            name: 'batches_create',
+            title: 'Create a batch of generations',
+            description: `Submit many independent lipsync generations at once as one Sync batch, such as localizing one campaign video into many languages or syncing many videos to their own audio. Each item is one /v2/generate body; Sync queues them, so they skip the per-generation concurrency limit, and results can take up to a day. Use it for ${MIN_ITEMS} or more generations that do not depend on each other; for fewer, or when one result feeds the next, use lipsync_create or dubbing_create per video. Call with dryRun: true first to have the API check every item without creating anything. This is a paid action: every item is billed as its own generation. Before creating, estimate a representative item with generations_estimate-cost, tell the user the item count and the estimated total, and wait for their confirmation. Not idempotent: each call creates a new batch, so after an uncertain response check batches_list before creating again. Leave payload.projectId out for new work; a payload with projectId needs projectIntent=explicit, which only an explicit user selection or a project just created for this request allows. Batch may not be on every plan: a 402 names requiredPlan and billingUrl. Returns the batch id and each item's requestId; then call batches_get with wait: true.`,
+            inputSchema: createInput.shape,
+            outputSchema: createOutput,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+            handler: async (args, context) => {
+                const { items, dryRun, webhookUrl, projectIntent } = createInput.parse(args);
+                assertProjectIntent(items, projectIntent);
+                const rows = buildBatchRows(items);
+                const response = await http
+                    .request('post', '/v2/batch', {
+                    body: {
+                        rows,
+                        ...(dryRun ? { dry_run: true } : {}),
+                        ...(webhookUrl ? { webhook_url: webhookUrl } : {}),
+                    },
+                    signal: context?.signal,
+                })
+                    .catch(explainCreateError);
+                return {
+                    ...(isRecord(response) ? response : {}),
+                    requestIds: rows.map((row) => row.request_id),
+                };
+            },
+        },
+        {
+            name: 'batches_get',
+            title: 'Read a batch',
+            description: 'Read a Sync batch: status, metrics (total, succeeded, failed, pending) and outputUrl. Once it is COMPLETED or FAILED, results lists each item by requestId with its generation status, generationId, outputMediaUrl or error. With wait: true it waits on the server for up to about 50 seconds and sends progress notifications; batches can take hours, so call again while it runs and never create the batch again.',
+            inputSchema: getInput.shape,
+            outputSchema: getOutput,
+            annotations: {
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+            handler: get,
+        },
+        {
+            name: 'batches_list',
+            title: 'List batches',
+            description: 'List this account’s Sync batches with their status and metrics, optionally by status or creation time. Use it to find a batch id, to check for a batch just created after an uncertain batches_create response, or to see which batches are still running.',
+            inputSchema: listInput.shape,
+            outputSchema: { batches: z.array(z.looseObject(batchFields)) },
+            annotations: {
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+            handler: async (args, context) => {
+                const { status, createdAfter, createdBefore } = listInput.parse(args);
+                const query = Object.fromEntries(Object.entries({
+                    status,
+                    created_after: createdAfter,
+                    created_before: createdBefore,
+                }).filter((entry) => entry[1] !== undefined));
+                const batches = await http.request('get', '/v2/batch', { query, signal: context?.signal });
+                return { batches: Array.isArray(batches) ? batches : [] };
+            },
+        },
+    ];
+}

package/dist/tools/dialogue.d.ts

@@ -0,0 +1,6 @@
+import { type HttpClient } from '../http-client.js';
+import type { ParsedOperation } from '../openapi/types.js';
+import { type McpToolDefinition } from './generator.js';
+export declare function dialogueOperations(operations: ParsedOperation[]): ParsedOperation[];
+export declare function createDialogueTools(operations: ParsedOperation[], httpClient: HttpClient): McpToolDefinition[];
+//# sourceMappingURL=dialogue.d.ts.map

package/dist/tools/dialogue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialogue.d.ts","sourceRoot":"","sources":["../../src/tools/dialogue.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAWvE,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,eAAe,EAAE,qBAE/D;AA2CD,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,eAAe,EAAE,EAC7B,UAAU,EAAE,UAAU,GACrB,iBAAiB,EAAE,CAmUrB"}