@sync.so/mcp-server 0.1.4 → 0.2.0

package/dist/tools/translation-preview.js

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+import { schemaProperty } from '../openapi/parser.js';
+import { jobSettled } from './job-status.js';
+import { pollUntil, waitInput } from './job-wait.js';
+const PREVIEW_OPERATIONS = [
+    ['post', '/v2/integrations/dubbing'],
+    ['post', '/v2/integrations/dubbing/estimate'],
+    ['get', '/v2/integrations/dubbing/{id}'],
+];
+export function translationPreviewOperations(operations) {
+    return operations.filter((operation) => PREVIEW_OPERATIONS.some(([method, path]) => operation.method === method && operation.path === path));
+}
+export function translationPreviewAvailable(operations) {
+    const matching = translationPreviewOperations(operations);
+    return PREVIEW_OPERATIONS.every(([method, path]) => {
+        const operation = matching.find((candidate) => candidate.method === method && candidate.path === path);
+        if (operation?.savedAssetDubbingVersion !== 1)
+            return false;
+        if (method === 'get')
+            return operation.parameters.some((parameter) => parameter.in === 'query' &&
+                parameter.name === 'projectId' &&
+                parameter.schema.type === 'string' &&
+                parameter.schema.format === 'uuid');
+        if (operation.requestBody?.contentType !== 'application/json')
+            return false;
+        const schema = operation.requestBody.schema;
+        if (['audioAssetId', 'projectId'].some((name) => {
+            const property = schemaProperty(schema, name);
+            return property?.type !== 'string' || property.format !== 'uuid';
+        }))
+            return false;
+        return (path.endsWith('/estimate') ||
+            operation.parameters.some((parameter) => parameter.in === 'header' &&
+                parameter.name.toLowerCase() === 'idempotency-key' &&
+                parameter.schema.type === 'string'));
+    });
+}
+const jobSchema = z.object({
+    id: z.uuid(),
+    projectId: z.uuid(),
+    status: z.enum(['PENDING', 'PROCESSING', 'COMPLETING', 'COMPLETED', 'FAILED']),
+    sourceAudioUrl: z.string().optional(),
+    sourceLang: z.string(),
+    targetLang: z.string(),
+    cloningStrength: z.number().int().nullable().optional(),
+    outputMediaUrl: z.string().nullable(),
+    outputDurationSec: z.number().nonnegative().nullable(),
+    error: z.object({ code: z.string(), message: z.string() }).nullable(),
+    recoveryRequired: z.boolean(),
+    createdAt: z.string().optional(),
+    startedAt: z.string().nullable().optional(),
+    finishedAt: z.string().nullable().optional(),
+});
+const quoteSchema = z.object({
+    billing: z.enum(['sync_credits', 'sync_usd', 'included', 'external']),
+    estimatedGenerationCost: z.number().nonnegative().nullable(),
+    estimatedCredits: z.number().nonnegative().nullable(),
+    preview: z
+        .object({
+        sourceDurationSeconds: z.number().positive(),
+        quotedDurationSeconds: z.number().positive(),
+        limitSeconds: z.number().positive().nullable(),
+    })
+        .optional(),
+});
+/** The existing translation API must advertise saved-source authorization and keyed recovery. */
+export function createTranslationPreviewTools(operations, http) {
+    if (!translationPreviewAvailable(operations))
+        return [];
+    const source = z.object({ projectId: z.uuid(), audioAssetId: z.uuid() }).strict();
+    const create = source.extend({
+        targetLang: z.string().trim().min(1),
+        // Detected from the audio. Still accepted from callers holding the old tool list.
+        sourceLang: z.string().optional().describe('Optional; the source language is detected.'),
+        idempotencyKey: z.uuid(),
+    });
+    const read = z.object({ projectId: z.uuid(), id: z.uuid() }).strict();
+    const waitable = read.extend({ wait: waitInput });
+    return [
+        {
+            name: 'translation-previews_estimate',
+            title: 'Estimate translated audio preview',
+            description: 'Read the server quote for translating saved audio in an accessible project. Does not translate, create a video, modify saved audio, or incur provider charges. If preview.quotedDurationSeconds is shorter than preview.sourceDurationSeconds, explain the duration limit and offer the bounded preview. Before admission, save a new trimmed audio asset and quote that asset; this estimate never trims the original. External provider charges must be disclosed separately.',
+            inputSchema: source.shape,
+            outputSchema: quoteSchema.shape,
+            annotations: {
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+            handler: async (args, context) => quoteSchema.parse(await http.request('post', '/v2/integrations/dubbing/estimate', {
+                body: { ...source.parse(args), preview: true },
+                signal: context?.signal,
+            })),
+        },
+        {
+            name: 'translation-previews_create',
+            title: 'Translate audio for preview',
+            description: 'Create one paid translated-audio preview from a saved audio asset. Confirm language and displayed cost first. Persist one UUID idempotencyKey and reuse the same immutable request after an uncertain response. Poll the returned job; never redub because audio attachment failed. Final video generation is a separate, explicitly approved lip-sync operation using the translated audio asset.',
+            inputSchema: create.shape,
+            outputSchema: jobSchema.shape,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: true,
+                // Paid, and only the model-chosen idempotencyKey deduplicates it: a retry with a new key bills again.
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+            handler: async (args, context) => {
+                const { idempotencyKey, sourceLang, ...fields } = create.parse(args);
+                return jobSchema.parse(await http.request('post', '/v2/integrations/dubbing', {
+                    body: { ...fields, sourceLang: sourceLang ?? 'auto' },
+                    headers: { 'Idempotency-Key': idempotencyKey },
+                    signal: context?.signal,
+                }));
+            },
+        },
+        {
+            name: 'translation-previews_get',
+            title: 'Read translated audio preview',
+            description: 'Read the same project-authorized translation job; pass wait: true to wait for it on the server. A recoveryRequired result means provider acceptance is uncertain; do not create another job. Does not start or retry translation. When COMPLETED, outputMediaUrl can be registered with assets_create (type=AUDIO) or, when available, passed as a clip audioUrl to lipsync_create-timeline.',
+            inputSchema: waitable.shape,
+            outputSchema: jobSchema.shape,
+            annotations: {
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+            handler: async (args, context) => {
+                const { wait, ...fields } = waitable.parse(args);
+                const input = read.parse(fields);
+                const get = async (signal = context?.signal) => jobSchema.parse(await http.request('get', `/v2/integrations/dubbing/${input.id}`, {
+                    query: { projectId: input.projectId },
+                    signal,
+                }));
+                if (!wait)
+                    return get();
+                return pollUntil(get, jobSettled, context, {
+                    describe: (job) => `translation ${job.status.toLowerCase()}`,
+                });
+            },
+        },
+    ];
+}

package/dist/tools/translation.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 translationOperation(operations: ParsedOperation[]): ParsedOperation | undefined;
+export declare function createTranslationTools(operations: ParsedOperation[], httpClient: HttpClient): McpToolDefinition[];
+//# sourceMappingURL=translation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"translation.d.ts","sourceRoot":"","sources":["../../src/tools/translation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAUxD,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,eAAe,GAAG,SAAS,CAQ/F;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,eAAe,EAAE,EAC7B,UAAU,EAAE,UAAU,GACrB,iBAAiB,EAAE,CA0IrB"}

package/dist/tools/translation.js

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import { schemaProperty as property } from '../openapi/parser.js';
+import { generationContextHeaders, generationContextSchema } from './generation-context.js';
+import { modelOptionsSchema } from './model-options.js';
+import { generationOutputSchema } from './output-schemas.js';
+import { assertProjectDestination, createProjectId, newProjectFields, } from './project-destination.js';
+import { translationPreviewAvailable } from './translation-preview.js';
+export function translationOperation(operations) {
+    return operations.find((operation) => operation.operationId === 'GenerateController_createGeneration' &&
+        operation.method === 'post' &&
+        operation.path === '/v2/generate' &&
+        operation.requestBody?.contentType === 'application/json');
+}
+export function createTranslationTools(operations, httpClient) {
+    const dub = property(translationOperation(operations)?.requestBody?.schema, 'dubParams');
+    const languageList = z.array(z.string().min(1)).nonempty();
+    const target = languageList.safeParse(property(dub, 'targetLang')?.enum);
+    const source = languageList.safeParse(property(dub, 'sourceLang')?.enum);
+    // Older APIs must not advertise a workflow they cannot validate.
+    if (!target.success || !source.success || !source.data.includes('auto'))
+        return [];
+    const schema = z
+        .object({
+        continuation: generationContextSchema.optional(),
+        videoAssetId: z
+            .uuid()
+            .describe('Existing Sync VIDEO asset in the connected organization. For a social link, first create a NEW project unless the user explicitly chose an existing one. Import via assets_create with type=VIDEO and that projectId, wait for its saved asset id, then pass the same projectId with projectIntent=explicit.'),
+        ...newProjectFields,
+        projectName: z
+            .string()
+            .trim()
+            .min(1)
+            .optional()
+            .describe('Name for a NEW project. A matching existing name is never reused.'),
+        projectId: z
+            .uuid()
+            .optional()
+            .describe('Project ID only when explicitly selected by the user, or just created for this request. Otherwise omit it to create a new project. Keep unchanged on retries.'),
+        targetLang: z.enum(target.data).describe('Target language from the API-supported list.'),
+        sourceLang: z.enum(source.data).default('auto'),
+        model: z.string().trim().min(1).describe('Video lip-sync model returned by models_list.'),
+        options: modelOptionsSchema.optional(),
+        idempotencyKey: z
+            .string()
+            .regex(/^[A-Za-z0-9._~-]{1,128}$/)
+            .describe('Persist one unique key per approved generation. Retry an uncertain request with this exact key and unchanged inputs; never automatically create a new key.'),
+    })
+        .strict();
+    return [
+        {
+            name: 'dubbing_create',
+            title: 'Translate and dub a video',
+            description: 'Use this when the user wants to translate and dub a video into another language with matching lip movements. Not for subtitles only or translating a text document. Requires a saved video asset, model, and persistent idempotency key. By default creates a NEW project using a fresh projectCreationKey, even when projectName matches existing work. Preserve that UUID and key on retries. Supply projectId only for an explicit selection or the project just created for this request; never infer it from a workflow name or open editor. For social video URLs, import through assets_create and wait for the saved asset before estimating or calling this tool. ' +
+                'This is a paid action: confirm the requested language, configuration and estimated cost with the user before calling. Use generations_estimate-cost with workflow=translate-and-dub when that input is supported, and disclose any excluded external provider charges. Without the combined breakdown, lip-sync pricing is not the full workflow cost. ' +
+                'The API manages dubbing and final rendering under the returned generation id. Poll generations_get for that same id until COMPLETED; do not create another job to finish or recover it.',
+            inputSchema: schema.shape,
+            outputSchema: generationOutputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: true,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+            handler: async (args, context) => {
+                const input = schema.parse(args);
+                const signal = context?.signal;
+                signal?.throwIfAborted();
+                assertProjectDestination(input.projectId, input.projectName, input.projectCreationKey);
+                if (input.continuation && !input.projectId)
+                    throw new Error('A continuation requires its explicitly selected projectId.');
+                const projectId = input.projectId ??
+                    (await createProjectId(httpClient, {
+                        name: input.projectName ?? 'Translate and Dub',
+                        projectCreationKey: input.projectCreationKey,
+                        idempotencyKey: input.idempotencyKey,
+                        defaultWorkflow: 'translate_and_dub',
+                    }, signal));
+                const project = input.projectId
+                    ? await httpClient.request('get', `/v2/projects/${projectId}`, {
+                        signal,
+                    })
+                    : { id: projectId };
+                if (!project ||
+                    typeof project !== 'object' ||
+                    !('id' in project) ||
+                    project.id !== projectId) {
+                    throw new Error('Sync could not verify access to this project. Refresh and try again.');
+                }
+                signal?.throwIfAborted();
+                const options = input.options;
+                if (typeof options?.active_speaker_detection === 'boolean') {
+                    options.active_speaker_detection = { auto_detect: options.active_speaker_detection };
+                }
+                const lineage = await generationContextHeaders(httpClient, args, ['translate_and_dub'], signal);
+                return httpClient.request('post', '/v2/generate', {
+                    signal,
+                    headers: { ...lineage, 'Idempotency-Key': input.idempotencyKey },
+                    body: {
+                        model: input.model,
+                        projectId,
+                        input: [{ type: 'video', assetId: input.videoAssetId }],
+                        dubParams: { targetLang: input.targetLang, sourceLang: input.sourceLang },
+                        ...(options === undefined ? {} : { options }),
+                    },
+                });
+            },
+        },
+        {
+            name: 'dubbing_get-options',
+            title: 'Translation options',
+            description: 'Read the source and target languages supported by the current translation API. Does not create a generation or estimate pricing.',
+            inputSchema: {},
+            outputSchema: {
+                targetLanguages: languageList,
+                sourceLanguages: languageList,
+                previewAvailable: z.boolean(),
+            },
+            annotations: {
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+            handler: async () => ({
+                targetLanguages: target.data,
+                sourceLanguages: source.data,
+                previewAvailable: translationPreviewAvailable(operations),
+            }),
+        },
+    ];
+}

package/dist/tools/upload-widget.d.ts

@@ -0,0 +1,13 @@
+import type { ReadResourceCallback, ResourceMetadata } from '@modelcontextprotocol/server';
+import type { McpToolDefinition } from './generator.js';
+export declare const MCP_APP_RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
+export declare const UPLOAD_WIDGET_URI = "ui://sync/upload-widget-v8.html";
+export declare const UPLOAD_WIDGET_LEGACY_URIS: readonly ['ui://sync/upload-widget-v1.html', 'ui://sync/upload-widget-v2.html', 'ui://sync/upload-widget-v3.html', 'ui://sync/upload-widget-v4.html', 'ui://sync/upload-widget-v5.html', 'ui://sync/upload-widget-v6.html', 'ui://sync/upload-widget-v7.html'];
+type UploadWidgetResourceServer = {
+    registerResource(name: string, uri: string, metadata: ResourceMetadata, readCallback: ReadResourceCallback): unknown;
+};
+export declare const UPLOAD_WIDGET_HTML: string;
+export declare function registerUploadWidgetResource(server: UploadWidgetResourceServer): void;
+export declare function createUploadWidgetTool(): McpToolDefinition;
+export {};
+//# sourceMappingURL=upload-widget.d.ts.map

package/dist/tools/upload-widget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-widget.d.ts","sourceRoot":"","sources":["../../src/tools/upload-widget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,eAAO,MAAM,0BAA0B,8BAA8B,CAAC;AAEtE,eAAO,MAAM,iBAAiB,oCAAoC,CAAC;AACnE,eAAO,MAAM,yBAAyB,YACpC,iCAAiC,EACjC,iCAAiC,EACjC,iCAAiC,EACjC,iCAAiC,EACjC,iCAAiC,EACjC,iCAAiC,EACjC,iCAAiC,CACzB,CAAC;AAIX,KAAK,0BAA0B,GAAG;IAChC,gBAAgB,CACd,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,gBAAgB,EAC1B,YAAY,EAAE,oBAAoB,GACjC,OAAO,CAAC;CACZ,CAAC;AAiCF,eAAO,MAAM,kBAAkB,QAkrBvB,CAAC;AAET,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,0BAA0B,GAAG,IAAI,CAmBrF;AAED,wBAAgB,sBAAsB,IAAI,iBAAiB,CA4C1D"}