@sync.so/mcp-server 0.1.4 → 0.2.0

package/dist/tools/app-tools.js

@@ -0,0 +1,350 @@
+import { z } from 'zod';
+import { resolveClientProfile } from '../client-profile.js';
+import { uploadRuntime } from '../upload-runtime.js';
+import { generationContextHeaders, generationContextSchema } from './generation-context.js';
+import { ASSET_TYPE_BY_KIND, assertValidFileParam, fileInput, resolveMedia, uploadMediaAsset, } from './media-upload.js';
+import { modelOptionsSchema, parseModelOptions } from './model-options.js';
+import { generationOutputSchema, uploadMediaOutputSchema } from './output-schemas.js';
+import { assertProjectDestination, createProjectId, newProjectFields, } from './project-destination.js';
+import { createRunningSubmissions } from './running-submissions.js';
+function providedCount(...values) {
+    return values.filter(Boolean).length;
+}
+// Picks the source the way resolveMedia does. A ChatGPT file is named by its file_id;
+// its download_url changes on every call.
+function mediaIdentity(url, assetId, file) {
+    if (assetId)
+        return ['asset', assetId];
+    if (url)
+        return ['url', url];
+    if (file && typeof file === 'object' && 'file_id' in file)
+        return ['file', file.file_id];
+    return file;
+}
+/**
+ * What makes two lipsync_create calls the same request, ignoring keys and new-project
+ * names. The client is part of it because each client has its own default project.
+ */
+function lipsyncSubmission(args, model, options, client) {
+    return [
+        client,
+        mediaIdentity(args.videoUrl, args.videoAssetId, args.video),
+        mediaIdentity(args.imageUrl, args.imageAssetId, args.image),
+        mediaIdentity(args.audioUrl, args.audioAssetId, args.audio),
+        args.script,
+        args.voiceId,
+        args.provider,
+        args.stability,
+        args.similarityBoost,
+        model,
+        options,
+        args.projectId,
+        args.continuation,
+    ];
+}
+function assertSingleSource(kind, count) {
+    if (count > 1) {
+        throw new Error(`Provide only one ${kind} source — use either ${kind}Url, ${kind}AssetId, or the uploaded ${kind} file param.`);
+    }
+}
+/**
+ * Hand-written tools layered on top of the auto-generated ones.
+ *
+ * `lipsync_create` is a flat convenience wrapper over POST /v2/generate (the
+ * auto-generated generations_create takes a nested `input[]` array).
+ *
+ * Each media input can arrive three ways:
+ *  - `*Url` string — a hosted/public URL, e.g. the `url` returned by tts_create
+ *    or an asset URL. This is the only way to chain another tool's output (the
+ *    model can't synthesise a fileParam object), and it's passed straight to
+ *    the generation as `url`.
+ *  - `*AssetId` string — a durable Sync asset created earlier, typically by
+ *    assets_upload. This keeps uploaded-file handling separate from generation
+ *    creation when the host supports file params but should not pass the file
+ *    directly to the generation tool. For public URLs, use the explicit `*Url`
+ *    fields or the generated assets_create tool instead.
+ *  - `video`/`image`/`audio` file objects — declared as `openai/fileParams` so
+ *    ChatGPT can hand a user-uploaded file straight in. These carry a
+ *    short-lived `download_url`, so we re-host the bytes through the assets
+ *    pipeline and pass a durable `assetId` (see rehostUpload).
+ *
+ * The generation can be driven by either audio (`audioUrl`/`audioAssetId`/
+ * `audio`) or text (`script` + `voiceId`). Text is sent directly to POST
+ * /v2/generate as a text input, avoiding a separate tts_create call.
+ */
+export function createAppTools(httpClient, runtime = uploadRuntime, getProfile = () => resolveClientProfile()) {
+    const submissions = createRunningSubmissions(httpClient);
+    const tools = [
+        {
+            name: 'assets_upload',
+            title: 'Upload media',
+            description: 'Stage an image, video, or audio file in Sync asset storage and return a durable assetId. ' +
+                'The file must be a host-provided object with a temporary HTTP download URL. Public URL strings are not accepted. ' +
+                'This creates a media asset but does not start a lipsync generation.',
+            inputSchema: {
+                mediaType: z
+                    .enum(['video', 'image', 'audio'])
+                    .describe('Type of media being uploaded: image, video, or audio.'),
+                file: z
+                    .object(fileInput.shape)
+                    .describe('Uploaded media file from ChatGPT. Do not pass URL strings here.'),
+            },
+            outputSchema: uploadMediaOutputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: true,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+            meta: {
+                ui: { visibility: ['model', 'app'] },
+                'openai/fileParams': ['file'],
+                'openai/widgetAccessible': true,
+                'openai/toolInvocation/invoking': 'Uploading media to Sync…',
+                'openai/toolInvocation/invoked': 'Media uploaded to Sync.',
+            },
+            handler: async (args, context) => {
+                const signal = context?.signal;
+                signal?.throwIfAborted();
+                const { mediaType, file } = args;
+                if (!mediaType || !['video', 'image', 'audio'].includes(mediaType)) {
+                    throw new Error('mediaType is required and must be one of: video, image, audio.');
+                }
+                if (!file) {
+                    throw new Error('file is required — pass the uploaded ChatGPT file object.');
+                }
+                if (typeof file === 'string') {
+                    throw new Error(`Got a string in the file slot ("${file.slice(0, 80)}"). ` +
+                        'This tool only accepts uploaded ChatGPT file objects; pass public URLs to assets_create or lipsync_create.');
+                }
+                const assetId = await uploadMediaAsset(httpClient, mediaType, file, runtime, signal);
+                return {
+                    assetId,
+                    mediaType,
+                    assetType: ASSET_TYPE_BY_KIND[mediaType],
+                    input: { type: mediaType, assetId },
+                };
+            },
+        },
+        {
+            name: 'lipsync_create',
+            title: 'Create lipsync',
+            description: 'Use this when the user wants to make a photo talk, make an image or video say a script, or match a speaker’s lip movements to supplied audio. ' +
+                'Create a lipsync video with exactly one visual input (image or video) and one driver (audio or script). ' +
+                'For translating spoken video into another language, use dubbing_create when available. Do not use for subtitles only, standalone audio, or general video editing. ' +
+                'Inputs can be public URLs, Sync asset IDs, or supported host file objects. A script requires a voiceId. ' +
+                'The model defaults to sync-3. New requests create a new project, even when its name matches another project. projectName names the new project; it never selects existing work. Supply projectId only for an explicit user selection or a project just created for this request. Keyed new-project requests require a fresh projectCreationKey, preserved on retries. ' +
+                'Before confirming, estimate using the replacement script or measured audio duration, not the source video length. Script-based quotes are approximate and exclude speech synthesis. ' +
+                'This starts an asynchronous generation and returns its id and status.',
+            inputSchema: {
+                continuation: generationContextSchema.optional(),
+                videoUrl: z
+                    .string()
+                    .describe('Public or Sync-hosted video URL. Use exactly one of videoUrl/videoAssetId/video/imageUrl/imageAssetId/image.')
+                    .optional(),
+                videoAssetId: z
+                    .string()
+                    .describe('Sync asset id for a video, returned by assets_upload or assets_create. Use exactly one visual input.')
+                    .optional(),
+                imageUrl: z
+                    .string()
+                    .describe('Public or Sync-hosted still image URL. Use this for image-to-video lipsync with sync-3.')
+                    .optional(),
+                imageAssetId: z
+                    .string()
+                    .describe('Sync asset id for a still image, returned by assets_upload or assets_create. Use this for image-to-video lipsync with sync-3.')
+                    .optional(),
+                audioUrl: z
+                    .string()
+                    .describe('Public or Sync-hosted audio URL. Use this when the user supplies audio.')
+                    .optional(),
+                audioAssetId: z
+                    .string()
+                    .describe('Sync asset id for audio, returned by assets_upload or assets_create.')
+                    .optional(),
+                script: z.string().describe('Text for the image or video to say.').optional(),
+                voiceId: z
+                    .string()
+                    .describe('Voice id from voices_list. Required when script is provided.')
+                    .optional(),
+                provider: z
+                    .string()
+                    .describe('Voice provider for script-driven lipsync. Defaults to elevenlabs.')
+                    .optional(),
+                stability: z
+                    .number()
+                    .describe('Optional ElevenLabs voice stability for script input.')
+                    .optional(),
+                similarityBoost: z
+                    .number()
+                    .describe('Optional ElevenLabs similarity boost for script input.')
+                    .optional(),
+                video: z
+                    .object(fileInput.shape)
+                    .describe('Uploaded video file from ChatGPT. Use videoUrl for public URLs instead.')
+                    .optional(),
+                image: z
+                    .object(fileInput.shape)
+                    .describe('Uploaded still image file from ChatGPT. Use imageUrl for public URLs instead.')
+                    .optional(),
+                audio: z
+                    .object(fileInput.shape)
+                    .describe('Uploaded audio file from ChatGPT. Use audioUrl for public URLs instead.')
+                    .optional(),
+                model: z
+                    .string()
+                    .describe('Optional model override. Image and video inputs default to sync-3.')
+                    .optional(),
+                options: modelOptionsSchema
+                    .optional()
+                    .describe('Model-specific generation preferences. Keep unchanged when retrying the same idempotency key.'),
+                idempotencyKey: z
+                    .string()
+                    .regex(/^[A-Za-z0-9._~-]{1,128}$/)
+                    .describe('Unique key for one generation action. Persist and reuse the same key, projectCreationKey (for new projects) or explicit projectId, model, and inputs when retrying after a lost response. Use durable asset IDs or stable URLs; upload files before starting the keyed action. A new intentional generation needs a new key. Passed as the Sync API Idempotency-Key header.')
+                    .optional(),
+                ...newProjectFields,
+                projectId: z
+                    .string()
+                    .trim()
+                    .min(1)
+                    .describe('Existing Sync project ID returned by projects_list or projects_get. Use this to select the same project as the web app. Cannot be combined with projectName.')
+                    .optional(),
+                projectName: z
+                    .string()
+                    .trim()
+                    .min(1)
+                    .describe('Name for a NEW project only. Never search or reuse a matching name. Cannot be combined with projectId.')
+                    .optional(),
+            },
+            outputSchema: generationOutputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: true,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+            meta: {
+                'openai/fileParams': ['video', 'image', 'audio'],
+                'openai/toolInvocation/invoking': 'Creating your lipsync video…',
+                'openai/toolInvocation/invoked': 'Lipsync generation started.',
+            },
+            handler: async (args, context) => {
+                const signal = context?.signal;
+                signal?.throwIfAborted();
+                const { videoUrl, videoAssetId, imageUrl, imageAssetId, audioUrl, audioAssetId, script, voiceId, provider, stability, similarityBoost, video, image, audio, model, projectName, projectId: requestedProjectId, idempotencyKey, projectCreationKey, } = args;
+                const resolvedModel = model ?? 'sync-3';
+                const options = parseModelOptions(args.options, {
+                    model: resolvedModel,
+                    image: providedCount(imageUrl, imageAssetId, image) > 0,
+                });
+                if (args.continuation !== undefined) {
+                    generationContextSchema.parse(args.continuation);
+                    z.uuid().parse(requestedProjectId);
+                }
+                // Validate the shape up front, before re-hosting any bytes.
+                const audioSourceCount = providedCount(audioUrl, audioAssetId, audio);
+                const videoSourceCount = providedCount(videoUrl, videoAssetId, video);
+                const imageSourceCount = providedCount(imageUrl, imageAssetId, image);
+                assertSingleSource('audio', audioSourceCount);
+                assertSingleSource('video', videoSourceCount);
+                assertSingleSource('image', imageSourceCount);
+                const hasAudio = audioSourceCount > 0;
+                const hasScript = Boolean(script);
+                const hasVideo = videoSourceCount > 0;
+                const hasImage = imageSourceCount > 0;
+                if (!hasAudio && !hasScript) {
+                    throw new Error('Audio or script is required - pass `audioAssetId`, or pass `script` with a `voiceId` from voices_list. lipsync_create also accepts `audioUrl` or an uploaded audio file.');
+                }
+                if (hasAudio && hasScript) {
+                    throw new Error('Provide either audio or script, not both.');
+                }
+                if (hasScript && !voiceId) {
+                    throw new Error('voiceId is required when using script — call voices_list first.');
+                }
+                if (!hasVideo && !hasImage) {
+                    throw new Error('Provide a video or an image - pass `videoAssetId` or `imageAssetId`. lipsync_create also accepts `videoUrl`/`imageUrl` or an uploaded file.');
+                }
+                if (hasVideo && hasImage) {
+                    throw new Error('Provide either a video or an image, not both.');
+                }
+                assertProjectDestination(requestedProjectId, projectName, projectCreationKey);
+                // Reject malformed ChatGPT file params before making project or upload requests.
+                assertValidFileParam('video', video);
+                assertValidFileParam('image', image);
+                assertValidFileParam('audio', audio);
+                const submit = async () => {
+                    const projectId = requestedProjectId?.trim() ??
+                        (await createProjectId(httpClient, {
+                            name: projectName?.trim() ||
+                                (context?.clientProfile ?? getProfile()).defaultProjectName,
+                            projectCreationKey,
+                            idempotencyKey,
+                            defaultWorkflow: hasImage ? 'image_to_video' : 'lipsync',
+                        }, signal));
+                    if (requestedProjectId !== undefined) {
+                        // Check access before transferring files. Generation admission checks it again.
+                        await httpClient.request('get', `/v2/projects/${encodeURIComponent(projectId)}`, {
+                            signal,
+                        });
+                    }
+                    const lineage = await generationContextHeaders(httpClient, args, ['lipsync', 'image_to_video', 'translate_and_dub'], signal);
+                    // URLs go through verbatim; uploaded files are re-hosted; assetIds are reused.
+                    const driver = hasScript
+                        ? {
+                            type: 'text',
+                            provider: {
+                                name: provider ?? 'elevenlabs',
+                                voiceId,
+                                script,
+                                ...(stability === undefined ? {} : { stability }),
+                                ...(similarityBoost === undefined ? {} : { similarityBoost }),
+                            },
+                        }
+                        : await resolveMedia(httpClient, 'audio', audioUrl, audioAssetId, audio, runtime, signal);
+                    const visual = hasImage
+                        ? await resolveMedia(httpClient, 'image', imageUrl, imageAssetId, image, runtime, signal)
+                        : await resolveMedia(httpClient, 'video', videoUrl, videoAssetId, video, runtime, signal);
+                    signal?.throwIfAborted();
+                    const generation = await httpClient.request('post', '/v2/generate', {
+                        signal,
+                        ...(idempotencyKey || Object.keys(lineage).length
+                            ? {
+                                headers: {
+                                    ...lineage,
+                                    ...(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : {}),
+                                },
+                            }
+                            : {}),
+                        body: {
+                            model: resolvedModel,
+                            ...(options === undefined ? {} : { options }),
+                            input: [visual, driver],
+                            projectId,
+                        },
+                    });
+                    return generation;
+                };
+                const client = (context?.clientProfile ?? getProfile()).name;
+                return submissions.once(lipsyncSubmission(args, resolvedModel, options, client), submit, signal);
+            },
+        },
+    ];
+    const lipsync = tools.find((tool) => tool.name === 'lipsync_create');
+    // Embedded apps cannot invoke tools annotated with fileParams, even with
+    // asset-only arguments. Reuse generation admission/execution without exposing
+    // the host's attachment transport to this app-only entry point.
+    const inputSchema = { ...lipsync.inputSchema };
+    for (const key of ['video', 'image', 'audio', 'videoUrl', 'imageUrl', 'audioUrl']) {
+        delete inputSchema[key];
+    }
+    const { 'openai/fileParams': _fileParams, ...meta } = lipsync.meta ?? {};
+    tools.push({
+        ...lipsync,
+        name: 'lipsync_create-from-assets',
+        description: 'Create one lipsync generation from saved Sync image/video and audio asset IDs, or a saved visual asset plus script and voiceId. Uses the same project access, options, and idempotency rules as lipsync_create. For embedded Sync interfaces only.',
+        inputSchema,
+        meta: { ...meta, ui: { visibility: ['app'] }, 'openai/widgetAccessible': true },
+    });
+    return tools;
+}

package/dist/tools/asset-analysis.d.ts

@@ -0,0 +1,4 @@
+import { type HttpClient } from '../http-client.js';
+import type { McpToolDefinition } from './generator.js';
+export declare function createAssetAnalysisTools(http: HttpClient): McpToolDefinition[];
+//# sourceMappingURL=asset-analysis.d.ts.map

package/dist/tools/asset-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-analysis.d.ts","sourceRoot":"","sources":["../../src/tools/asset-analysis.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AA0MxD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,iBAAiB,EAAE,CAE9E"}

package/dist/tools/asset-analysis.js

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+import { ApiRequestError } from '../http-client.js';
+import { pollUntil, waitInput } from './job-wait.js';
+/**
+ * Scene detection and stem separation. Their API routes are internal and behind
+ * server-side feature flags, so they are not in the public spec and are written by hand.
+ * They are listed only to accounts whose features include them (account-features.ts);
+ * a call from any other account still gets the API's 404, reported as not enabled.
+ */
+const assetId = z.uuid();
+// A disabled flag answers Nest's bare 404 ({ statusCode, message: 'Not Found' }, no
+// errorCode), and an API without the route answers "Cannot GET …". Coded 404s, such
+// as asset_not_found, keep their own error.
+const MISSING_ROUTE = / - (?:Not Found|Cannot (?:GET|POST) \S+)$/;
+async function whenEnabled(feature, call) {
+    try {
+        return await call();
+    }
+    catch (error) {
+        if (error instanceof ApiRequestError &&
+            error.status === 404 &&
+            error.code === undefined &&
+            MISSING_ROUTE.test(error.message))
+            throw new ApiRequestError(`${feature} isn't enabled for this account yet.`, 404, 'feature_not_enabled');
+        throw error;
+    }
+}
+const sceneSchema = z.object({
+    startFrame: z
+        .number()
+        .int()
+        .nonnegative()
+        .describe('First frame of the shot, counted from 0, inclusive.'),
+    endFrame: z
+        .number()
+        .int()
+        .nonnegative()
+        .describe('Last frame of the shot, inclusive. The next scene starts at endFrame + 1.'),
+    startSeconds: z
+        .number()
+        .nullable()
+        .describe('Shot start in seconds from the start of the video (startFrame / fps).'),
+    endSeconds: z
+        .number()
+        .nullable()
+        .describe('Shot end in seconds, (endFrame + 1) / fps: the next scene startSeconds. Null when fps is unknown.'),
+});
+const scenesSchema = z.object({
+    status: z
+        .enum(['not_requested', 'pending', 'completed', 'failed'])
+        .describe('completed: scenes holds the shots. pending: detection is running. failed: the last run stored no scenes; call again to retry.'),
+    fps: z.number().positive().nullable().describe('Frame rate used for seconds; null if unknown.'),
+    scenes: z.array(sceneSchema).describe('Shots in video order. Empty unless completed.'),
+});
+const scenesOutput = {
+    assetId: assetId.describe('The VIDEO asset.'),
+    ...scenesSchema.shape,
+    jobId: z.string().optional().describe('Detection job started by this call, if it started one.'),
+};
+const sceneStart = z.object({
+    success: z.boolean(),
+    jobId: z.string().optional(),
+    reason: z.string().optional(),
+});
+function createScenesTool(http) {
+    const input = z.object({ assetId, wait: waitInput });
+    return {
+        name: 'scenes_detect',
+        title: 'Detect scenes in a video',
+        description: 'Find the shots in a saved VIDEO asset. A scene is one continuous shot between two camera cuts. Returns scenes in video order, each with startFrame and endFrame (frames from 0, both inclusive; the next scene starts at endFrame + 1) and startSeconds and endSeconds (seconds from the start of the video; endSeconds equals the next scene startSeconds). ' +
+            'Starts detection only when the asset has no stored scenes or the last run failed; otherwise it returns the stored or running result, so calling again never reruns a finished detection. Pass wait: true to wait on the server; while status is pending, call again with wait: true. ' +
+            'Typical use: shot-aware lipsync with lipsync_create-timeline. Give each speaker one clip per shot and start and end clips on scene boundaries, so the lipsynced face never switches mid-shot; clip startFrame and endFrame are inclusive too, so a scene maps onto a clip as is.',
+        inputSchema: input.shape,
+        outputSchema: scenesOutput,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        handler: (args, context) => whenEnabled('Scene detection', async () => {
+            const { assetId: id, wait } = input.parse(args);
+            const read = async (signal = context?.signal) => scenesSchema.parse(await http.request('get', '/v2/asset-metadata/scenes', {
+                query: { assetId: id },
+                signal,
+            }));
+            let state = await read();
+            let jobId;
+            // A new request clears stored scenes, so only start when there are none to keep.
+            if (state.status === 'not_requested' || state.status === 'failed') {
+                const started = sceneStart.parse(await http.request('post', '/v2/asset-metadata/scene-detection', {
+                    body: { assetId: id },
+                    signal: context?.signal,
+                }));
+                if (!started.success)
+                    throw new Error(started.reason === 'unsupported_asset_type'
+                        ? `Asset ${id} is not a video. Scene detection needs a VIDEO asset.`
+                        : `Scene detection did not start for asset ${id}${started.reason ? `: ${started.reason}` : ''}.`);
+                jobId = started.jobId;
+                state = { ...state, status: 'pending', scenes: [] };
+            }
+            if (wait && state.status === 'pending')
+                state = await pollUntil(read, (scenes) => scenes.status !== 'pending', context, {
+                    describe: (scenes) => `scene detection ${scenes.status}`,
+                });
+            return { assetId: id, ...state, ...(jobId ? { jobId } : {}) };
+        }),
+    };
+}
+const stemJobSchema = z.object({
+    id: z.uuid().describe('Stem separation job ID.'),
+    assetId: assetId.describe('The AUDIO or VIDEO asset whose audio is separated.'),
+    status: z
+        .enum(['pending', 'processing', 'completed', 'failed'])
+        .describe('pending: queued. processing: extracting and separating. completed: both stem assets exist. failed: see error; call again to retry.'),
+    vocalsAssetId: z
+        .uuid()
+        .nullable()
+        .describe('AUDIO asset with only the voices (speech and singing). Null until completed.'),
+    backgroundAssetId: z
+        .uuid()
+        .nullable()
+        .describe('AUDIO asset with everything but the voices: music, ambience and effects in one track. Null until completed.'),
+    vocalsUrl: z.string().nullable().describe('URL of the vocals WAV. Null until completed.'),
+    backgroundUrl: z.string().nullable().describe('URL of the background WAV. Null until completed.'),
+    error: z
+        .object({ code: z.string(), message: z.string() })
+        .nullable()
+        .describe('Why the job failed, such as stem_separation_duration_exceeded. Null otherwise.'),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+function createStemsTool(http) {
+    const input = z.object({ assetId, wait: waitInput });
+    return {
+        name: 'stems_separate',
+        title: 'Separate vocals from background audio',
+        description: 'Split the audio of a saved AUDIO or VIDEO asset into two new AUDIO assets: vocals, the voices alone (speech and singing), and background, everything else (music, ambience and effects) in one track. A video has its audio extracted first. Both stems are mono 44.1 kHz WAV with the same length and timing as the source, in seconds, and add back up to it. ' +
+            'Typical use: keep the source soundtrack under a dub. Sync tools do not mix audio, so mix the dubbed voice over backgroundUrl yourself (for example with ffmpeg amix), upload the mix and use it as the lipsync audio. The vocals stem is a clean voice track, for example a voice clone sample. ' +
+            'The source must be in Sync storage; for stem_separation_source_not_hosted, upload the file and separate the new asset. Starts a job only when this asset has none or the last one failed; a running or completed separation is returned as is, so calling again never runs it twice. A job can take several minutes (at most 20). Pass wait: true to wait on the server; while status is pending or processing, call again with wait: true.',
+        inputSchema: input.shape,
+        outputSchema: stemJobSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        handler: (args, context) => whenEnabled('Stem separation', async () => {
+            const { assetId: id, wait } = input.parse(args);
+            const path = `/v2/assets/${id}/separate-stems`;
+            const request = async (method, signal = context?.signal) => stemJobSchema.parse(await http.request(method, path, { signal }));
+            // Read first: the start route is limited to 60 calls an hour, and polling uses this one.
+            let job = await request('get').catch((error) => {
+                if (error instanceof ApiRequestError && error.code === 'stem_separation_not_found')
+                    return undefined;
+                throw error;
+            });
+            if (!job || job.status === 'failed')
+                job = await request('post');
+            if (wait && !settled(job))
+                job = await pollUntil((signal) => request('get', signal), settled, context, {
+                    describe: (stems) => `stem separation ${stems.status}`,
+                });
+            return job;
+        }),
+    };
+}
+const settled = (job) => job.status === 'completed' || job.status === 'failed';
+export function createAssetAnalysisTools(http) {
+    return [createScenesTool(http), createStemsTool(http)];
+}

package/dist/tools/asset-creators.d.ts

@@ -0,0 +1,4 @@
+import type { HttpClient } from '../http-client.js';
+import type { McpToolDefinition } from './generator.js';
+export declare function createAssetCreatorsTool(http: HttpClient): McpToolDefinition;
+//# sourceMappingURL=asset-creators.d.ts.map

package/dist/tools/asset-creators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-creators.d.ts","sourceRoot":"","sources":["../../src/tools/asset-creators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAcxD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,UAAU,GAAG,iBAAiB,CA4B3E"}

package/dist/tools/asset-creators.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+const member = z.object({
+    userId: z.uuid(),
+    user: z
+        .object({
+        id: z.uuid(),
+        displayName: z.string().nullable(),
+        email: z.string().nullable(),
+        avatarUrl: z.string().nullable(),
+    })
+        .nullish(),
+});
+export function createAssetCreatorsTool(http) {
+    return {
+        name: 'assets_list-creators',
+        title: 'Read Sync asset creators',
+        description: "Read the connected organization's members (display name, email and avatar) for the Sync interface's asset creator filter. Organization scope is resolved from the authenticated connection.",
+        // The creator filter needs member emails; keep them out of the model's context.
+        meta: { ui: { visibility: ['app'] } },
+        inputSchema: {},
+        outputSchema: { members: member.array() },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        handler: async (_args, context) => {
+            const identity = z
+                .object({ organization: z.object({ id: z.uuid() }) })
+                .parse(await http.request('get', '/v2/oauth/account', { signal: context?.signal }));
+            const members = member.array().parse(await http.request('get', `/v2/organizations/${identity.organization.id}/members`, {
+                signal: context?.signal,
+            }));
+            return { members };
+        },
+    };
+}

package/dist/tools/audio-trim.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 supportsAudioTrimming(operations: ParsedOperation[]): boolean;
+export declare function createAudioTrimTools(operations: ParsedOperation[], http: HttpClient): McpToolDefinition[];
+//# sourceMappingURL=audio-trim.d.ts.map

package/dist/tools/audio-trim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-trim.d.ts","sourceRoot":"","sources":["../../src/tools/audio-trim.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,OAAO,CAS5E;AAUD,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,eAAe,EAAE,EAC7B,IAAI,EAAE,UAAU,GACf,iBAAiB,EAAE,CAmErB"}