@sync.so/mcp-server 0.1.3 → 0.2.0

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

package/dist/tools/project-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-history.d.ts","sourceRoot":"","sources":["../../src/tools/project-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEvE,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAazF;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,eAAe,EAAE,EAC7B,UAAU,EAAE,UAAU,GACrB,iBAAiB,EAAE,CA8CrB"}

package/dist/tools/project-history.js

@@ -0,0 +1,45 @@
+import { generateTools } from './generator.js';
+export function projectHistoryOperations(operations) {
+    const history = operations.find((operation) => operation.operationId === 'GenerateController_getGenerations' &&
+        operation.method === 'get' &&
+        operation.parameters.some((parameter) => parameter.in === 'query' && parameter.name === 'projectId'));
+    const project = operations.find((operation) => operation.operationId === 'ProjectsController_get' && operation.method === 'get');
+    return history && project ? [history, project] : [];
+}
+export function createProjectHistoryTools(operations, httpClient) {
+    const [history, project] = generateTools(projectHistoryOperations(operations), httpClient);
+    if (!history || !project)
+        return [];
+    return [
+        {
+            name: 'projects_list-generations',
+            title: 'Read project history',
+            description: 'Read generation history for an accessible Sync project. Requires a projectId returned by projects_list. Pass limit and the last returned generation id as cursor to load another page. These are the same records used by the Sync web app.',
+            inputSchema: {
+                ...history.inputSchema,
+                projectId: history.inputSchema.projectId.nonoptional(),
+            },
+            annotations: history.annotations,
+            handler: async (args, context) => {
+                // Check access independently before a read that an old API instance may
+                // treat as an organization feed during a rolling deployment.
+                const selected = await project.handler({ id: args.projectId }, context);
+                if (!selected ||
+                    typeof selected !== 'object' ||
+                    !('id' in selected) ||
+                    selected.id !== args.projectId) {
+                    throw new Error('Sync could not verify access to this project. Refresh and try again.');
+                }
+                const result = await history.handler(args, context);
+                if (!Array.isArray(result) ||
+                    result.some((item) => !item ||
+                        typeof item !== 'object' ||
+                        !('projectId' in item) ||
+                        item.projectId !== args.projectId)) {
+                    throw new Error('Project history is temporarily unavailable. Sync did not return history scoped to this project.');
+                }
+                return result;
+            },
+        },
+    ];
+}

package/dist/tools/project-intent.d.ts

@@ -0,0 +1,8 @@
+import { ApiRequestError } from '../http-client.js';
+import type { McpToolDefinition } from './generator.js';
+/** Whether writing into projectId is allowed: explicit intent, or a project created here. */
+export declare function projectUseAllowed(projectId: unknown, projectIntent: unknown): boolean;
+/** The refusal every write tool gives for an existing project without explicit intent. */
+export declare function projectIntentError(prefix?: string): ApiRequestError;
+export declare function withProjectIntent(tool: McpToolDefinition): McpToolDefinition;
+//# sourceMappingURL=project-intent.d.ts.map

package/dist/tools/project-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-intent.d.ts","sourceRoot":"","sources":["../../src/tools/project-intent.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,gBAAgB,CAAC;AA+B5E,6FAA6F;AAC7F,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,GAAG,OAAO,CAMrF;AAED,0FAA0F;AAC1F,wBAAgB,kBAAkB,CAAC,MAAM,SAAK,GAAG,eAAe,CAE/D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,GAAG,iBAAiB,CAmD5E"}

package/dist/tools/project-intent.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { getAuthOwner, getAuthToken } from '../auth/async-context.js';
+import { ApiRequestError } from '../http-client.js';
+import { projectTargetTools } from './generated-adapters.js';
+// Clients holding a tool list from before projectIntent existed create a project, then
+// pass its id without projectIntent. Accept only projects this same user just created.
+const CREATED_PROJECT_TTL_MS = 30 * 60_000;
+const createdProjects = new Map();
+function createdProjectKey(projectId) {
+    const owner = getAuthOwner() ??
+        createHash('sha256')
+            .update(getAuthToken() ?? '')
+            .digest('hex');
+    return `${owner}\0${projectId}`;
+}
+function rememberCreatedProject(result) {
+    const project = z.object({ id: z.string().min(1) }).safeParse(result);
+    if (!project.success)
+        return;
+    const now = Date.now();
+    for (const [key, expires] of createdProjects)
+        if (expires <= now)
+            createdProjects.delete(key);
+    createdProjects.set(createdProjectKey(project.data.id), now + CREATED_PROJECT_TTL_MS);
+}
+function createdHere(projectId) {
+    return (createdProjects.get(createdProjectKey(projectId)) ?? 0) > Date.now();
+}
+const PROJECT_INTENT_MESSAGE = 'Existing project use requires an explicit user selection. Create a new project for a new workflow request; do not reuse a matching name or the active editor.';
+/** Whether writing into projectId is allowed: explicit intent, or a project created here. */
+export function projectUseAllowed(projectId, projectIntent) {
+    return (projectId === undefined ||
+        projectIntent === 'explicit' ||
+        (typeof projectId === 'string' && createdHere(projectId)));
+}
+/** The refusal every write tool gives for an existing project without explicit intent. */
+export function projectIntentError(prefix = '') {
+    return new ApiRequestError(`${prefix}${PROJECT_INTENT_MESSAGE}`, 400, 'PROJECT_INTENT_REQUIRED');
+}
+export function withProjectIntent(tool) {
+    if (tool.name === 'projects_create' && tool.resultFormat !== 'mcp')
+        return {
+            ...tool,
+            handler: async (args, context) => {
+                const result = await tool.handler(args, context);
+                rememberCreatedProject(result);
+                return result;
+            },
+        };
+    if (!('projectId' in tool.inputSchema) ||
+        tool.annotations?.readOnlyHint ||
+        projectTargetTools.has(tool))
+        return tool;
+    const ui = tool.meta?.ui;
+    if (ui?.visibility?.length === 1 && ui.visibility[0] === 'app')
+        return tool;
+    const definition = {
+        ...tool,
+        description: tool.description +
+            ' When supplying projectId, projectIntent=explicit is required: the user must explicitly ask to work in that project, select it in the interface, or this must be the project just created for this request. A matching workflow/name or an already-open editor is never permission to modify it. Default new work to a new project.',
+        inputSchema: {
+            ...tool.inputSchema,
+            projectIntent: z
+                .literal('explicit')
+                .optional()
+                .describe('Required with projectId. Set only for an explicit user project selection/update, or the new project just created for this request. Never infer intent from a matching project name, workflow name or active editor.'),
+        },
+    };
+    const input = (args) => {
+        const { projectIntent, ...fields } = args;
+        if (!projectUseAllowed(fields.projectId, projectIntent))
+            throw projectIntentError();
+        return fields;
+    };
+    return tool.resultFormat === 'mcp'
+        ? {
+            ...definition,
+            resultFormat: 'mcp',
+            handler: (args, context) => tool.handler(input(args), context),
+        }
+        : {
+            ...definition,
+            resultFormat: 'json',
+            handler: (args, context) => tool.handler(input(args), context),
+        };
+}

package/dist/tools/running-submissions.d.ts

@@ -0,0 +1,7 @@
+import { type HttpClient } from '../http-client.js';
+export type RunningSubmissions = {
+    /** Runs `submit` unless an identical request is still submitting or rendering. */
+    once: (request: unknown, submit: () => Promise<unknown>, signal?: AbortSignal) => Promise<unknown>;
+};
+export declare function createRunningSubmissions(http: HttpClient): RunningSubmissions;
+//# sourceMappingURL=running-submissions.d.ts.map

package/dist/tools/running-submissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"running-submissions.d.ts","sourceRoot":"","sources":["../../src/tools/running-submissions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAerE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,kFAAkF;IAClF,IAAI,EAAE,CACJ,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAC9B,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB,CAAC;AAYF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,kBAAkB,CA8D7E"}

package/dist/tools/running-submissions.js

@@ -0,0 +1,91 @@
+import { createHash } from 'node:crypto';
+import { getAuthOwner, getAuthToken } from '../auth/async-context.js';
+import { ApiRequestError } from '../http-client.js';
+import { chosenOrganization } from '../organization-selection.js';
+// Agents resubmit a request every few seconds while its generation is still rendering,
+// uploading the same files again each time. A free plan runs one generation at a time,
+// so every resubmission failed with concurrency_limit_reached. Answer an identical
+// request from the same user with the generation that is still running instead.
+const REMEMBER_MS = 30 * 60_000;
+const TERMINAL_STATUSES = new Set(['COMPLETED', 'FAILED', 'REJECTED', 'CANCELED', 'CANCELLED']);
+function untilAborted(promise, signal) {
+    if (!signal)
+        return promise;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        signal.addEventListener('abort', abort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+    });
+}
+export function createRunningSubmissions(http) {
+    const entries = new Map();
+    const keyOf = (request) => {
+        const owner = getAuthOwner() ??
+            createHash('sha256')
+                .update(getAuthToken() ?? '')
+                .digest('hex');
+        // The same request in another organization is another generation.
+        return createHash('sha256')
+            .update(JSON.stringify([owner, chosenOrganization()?.id ?? null, request]))
+            .digest('hex');
+    };
+    // A failed read leaves the entry in place: the generation may still be running.
+    async function stillRunning(id, signal) {
+        try {
+            const generation = await http.request('get', `/v2/generate/${encodeURIComponent(id)}`, {
+                signal,
+            });
+            const status = generation?.status;
+            return typeof status === 'string' && !TERMINAL_STATUSES.has(status) ? generation : undefined;
+        }
+        catch (error) {
+            if (error instanceof ApiRequestError && error.status === 404)
+                return undefined;
+            throw error;
+        }
+    }
+    return {
+        async once(request, submit, signal) {
+            const key = keyOf(request);
+            const entry = entries.get(key);
+            if (entry && entry.expires > Date.now()) {
+                // A failed or uncertain first attempt is the answer for every call that waited on it.
+                if (entry.submitting)
+                    return untilAborted(entry.submitting, signal);
+                const generation = await stillRunning(entry.id, signal);
+                if (generation)
+                    return generation;
+                // Another identical call may have started a submission during the read.
+                const current = entries.get(key);
+                if (current?.submitting)
+                    return untilAborted(current.submitting, signal);
+            }
+            if (entries.get(key) === entry)
+                entries.delete(key);
+            const now = Date.now();
+            for (const [other, { expires }] of entries)
+                if (expires <= now)
+                    entries.delete(other);
+            const submitting = submit();
+            const reservation = { submitting, expires: now + REMEMBER_MS };
+            entries.set(key, reservation);
+            try {
+                const generation = await submitting;
+                const id = generation?.id;
+                if (entries.get(key) === reservation) {
+                    if (typeof id === 'string')
+                        entries.set(key, { id, expires: Date.now() + REMEMBER_MS });
+                    else
+                        entries.delete(key);
+                }
+                return generation;
+            }
+            catch (error) {
+                if (entries.get(key) === reservation)
+                    entries.delete(key);
+                throw error;
+            }
+        },
+    };
+}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"speech.d.ts","sourceRoot":"","sources":["../../src/tools/speech.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,eAAe,EAAE,qBAI7D;AA+CD,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,eAAe,EAAE,EAC7B,UAAU,EAAE,UAAU,GACrB,iBAAiB,EAAE,CA4ErB"}

package/dist/tools/speech.js

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+const createPath = '/v2/tts/jobs';
+const readPath = '/v2/tts/jobs/{id}';
+export function speechOperations(operations) {
+    return operations.filter((operation) => operation.path === createPath || operation.path === readPath);
+}
+const projectSchema = z.object({ projectId: z.uuid() });
+const requestSchema = projectSchema.extend({
+    idempotencyKey: z
+        .uuid()
+        .describe('Persist this request identity before synthesis. Reuse it with the identical script and voice after an uncertain response.'),
+    script: z.string().min(1).max(5000),
+    voiceId: z
+        .string()
+        .min(1)
+        .describe('An id returned by voices_list. Restricted voices cannot synthesize.'),
+    stability: z.number().min(0).max(1).optional(),
+    similarityBoost: z.number().min(0).max(1).optional(),
+});
+const jobSchema = z.object({
+    id: z.uuid(),
+    status: z.enum(['PENDING', 'PROCESSING', 'SUCCESS', 'FAILED']),
+    url: z.url().nullable(),
+    duration: z.number().finite().nonnegative().nullable(),
+    error: z.object({ code: z.string(), message: z.string() }).nullable(),
+    createdAt: z.string(),
+    startedAt: z.string().nullable(),
+    finishedAt: z.string().nullable(),
+});
+// Return only the fields needed for Studio's speech quote and admission UI.
+const billingSchema = z.object({
+    plan: z.string().nullable(),
+    billingVersion: z.enum(['v2', 'v3']).optional(),
+    hasActiveCredits: z.boolean(),
+    freeTtsExhausted: z.boolean(),
+    freeGenerationsExhausted: z.boolean().optional(),
+    paymentFailureCountExceededLimit: z.boolean(),
+    freeMonthlyLimits: z
+        .object({
+        tts: z.object({ used: z.number().nonnegative(), max: z.number().nonnegative() }),
+        generations: z
+            .object({ used: z.number().nonnegative(), max: z.number().nonnegative() })
+            .optional(),
+        sync3: z.object({ used: z.number().nonnegative(), max: z.number().nonnegative() }).optional(),
+    })
+        .nullable(),
+});
+const optionsSchema = billingSchema.extend({ available: z.literal(true) });
+const readHints = { readOnlyHint: true, destructiveHint: false, openWorldHint: false };
+export function createSpeechTools(operations, httpClient) {
+    const selected = speechOperations(operations);
+    if (!selected.some((op) => op.path === createPath && op.method === 'post') ||
+        !selected.some((op) => op.path === readPath && op.method === 'get'))
+        return [];
+    async function checkProject(args, signal) {
+        signal?.throwIfAborted();
+        const { projectId } = projectSchema.parse(args);
+        const project = z
+            .object({ id: z.uuid() })
+            .parse(await httpClient.request('get', `/v2/projects/${projectId}`, { signal }));
+        if (project.id !== projectId)
+            throw new Error('Could not verify project access.');
+        signal?.throwIfAborted();
+    }
+    return [
+        {
+            name: 'speech-previews_get-options',
+            title: 'Check speech preview availability',
+            description: 'Read speech-preview availability and the connected organization’s billing mode/free allowance for a Studio quote. Does not synthesize or change billing.',
+            inputSchema: projectSchema.shape,
+            outputSchema: optionsSchema.shape,
+            annotations: readHints,
+            handler: async (args, context) => {
+                await checkProject(args, context?.signal);
+                const billing = billingSchema.parse(await httpClient.request('get', '/v2/billing', { signal: context?.signal }));
+                return { ...billing, available: true };
+            },
+        },
+        {
+            name: 'speech-previews_create',
+            title: 'Generate a speech preview',
+            description: 'Synthesize the confirmed script and selected available voice into a durable audio job for the project. This is a potentially paid action. Persist idempotencyKey before calling, reuse that same key and identical input after uncertain admission, and poll speech-previews_get by returned id. Never create again merely because attaching the resulting audio failed.',
+            inputSchema: requestSchema.shape,
+            outputSchema: jobSchema.shape,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: true,
+                openWorldHint: true,
+                // Paid, and only the model-chosen idempotencyKey deduplicates it: a retry with a new key bills again.
+                idempotentHint: false,
+            },
+            handler: async (args, context) => {
+                const { projectId: _projectId, idempotencyKey, ...body } = requestSchema.parse(args);
+                await checkProject(args, context?.signal);
+                return jobSchema.parse(await httpClient.request('post', createPath, {
+                    body: { ...body, provider: 'elevenlabs' },
+                    headers: { 'Idempotency-Key': idempotencyKey },
+                    signal: context?.signal,
+                }));
+            },
+        },
+        {
+            name: 'speech-previews_get',
+            title: 'Check a speech preview',
+            description: 'Read the same durable speech job until SUCCESS or FAILED. Reads do not synthesize. Requires an accessible project in the connected organization; the audio is attached separately by the app.',
+            inputSchema: projectSchema.extend({ id: z.uuid() }).shape,
+            outputSchema: jobSchema.shape,
+            annotations: readHints,
+            handler: async (args, context) => {
+                const id = z.uuid().parse(args.id);
+                await checkProject(args, context?.signal);
+                return jobSchema.parse(await httpClient.request('get', `${createPath}/${id}`, { signal: context?.signal }));
+            },
+        },
+    ];
+}

package/dist/tools/studio-draft.d.ts

@@ -0,0 +1,7 @@
+import { type HttpClient } from '../http-client.js';
+import type { ParsedOperation } from '../openapi/types.js';
+import type { McpToolDefinition } from './generator.js';
+export declare function supportsStudioDrafts(operations: ParsedOperation[]): boolean;
+/** The API owns authorization, persistence and compare-and-set across MCP sessions/pods. */
+export declare function createStudioDraftTools(operations: ParsedOperation[], http: HttpClient): McpToolDefinition[];
+//# sourceMappingURL=studio-draft.d.ts.map

package/dist/tools/studio-draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-draft.d.ts","sourceRoot":"","sources":["../../src/tools/studio-draft.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AA0ExD,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,OAAO,CAU3E;AAED,4FAA4F;AAC5F,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,eAAe,EAAE,EAC7B,IAAI,EAAE,UAAU,GACf,iBAAiB,EAAE,CAqIrB"}

package/dist/tools/studio-draft.js

@@ -0,0 +1,195 @@
+import { z } from 'zod';
+import { ApiRequestError } from '../http-client.js';
+import { modelOptionsSchema } from './model-options.js';
+const speech = z.strictObject({
+    text: z.string().max(5000),
+    voiceId: z.string().min(1).max(200).nullable(),
+    stability: z.number().min(0).max(1),
+    similarityBoost: z.number().min(0).max(1),
+});
+// Stored drafts retain the public API's legacy model modes and speaker data.
+// New chat edits still use the narrower visible-control schema below.
+const storedOptions = modelOptionsSchema.extend({
+    model_mode: z.string().optional(),
+    active_speaker_detection: z
+        .union([
+        z.boolean(),
+        z.object({
+            auto_detect: z.boolean().optional(),
+            use_v2: z.boolean().optional(),
+            v3: z.boolean().optional(),
+            frame_number: z.number().optional(),
+            coordinates: z.tuple([z.number(), z.number()]).optional(),
+            bounding_boxes: z.array(z.array(z.number()).nullable()).optional(),
+            bounding_boxes_url: z.string().optional(),
+            face_image: z.string().optional(),
+        }),
+    ])
+        .optional(),
+});
+const state = z.strictObject({
+    workflow: z.enum(['lipsync', 'image_to_video', 'translate_and_dub', 'edit_dialogue']),
+    visualId: z.uuid().nullable(),
+    audioId: z.uuid().nullable(),
+    derivedAudioVisualId: z.uuid().nullable().default(null),
+    audioRemoved: z.boolean().default(false),
+    parentGenerationId: z.uuid().optional(),
+    model: z.string().min(1).max(100),
+    options: storedOptions,
+    targetLang: z.string().max(20),
+    sourceLang: z.string().max(20),
+    speech,
+});
+const draft = z.object({
+    id: z.uuid(),
+    projectId: z.uuid(),
+    revision: z.number().int().positive(),
+    appliedRevision: z.number().int().nonnegative(),
+    editable: z.boolean(),
+    updatedAt: z.string(),
+    state,
+});
+const identity = { projectId: z.uuid(), draftId: z.uuid() };
+const edit = z.strictObject({
+    ...identity,
+    expectedRevision: z.number().int().positive(),
+    patch: state
+        .omit({ parentGenerationId: true, derivedAudioVisualId: true, audioRemoved: true })
+        .partial()
+        .extend({
+        options: modelOptionsSchema.optional(),
+        speech: speech.partial().optional(),
+    })
+        .strict()
+        .refine((patch) => Object.keys(patch).length > 0, 'Supply a draft change.'),
+});
+const save = z.object({
+    ...identity,
+    expectedRevision: z.number().int().nonnegative(),
+    state,
+    editable: z.boolean(),
+});
+const acknowledge = z.object({ ...identity, revision: z.number().int().positive() });
+export function supportsStudioDrafts(operations) {
+    return [
+        ['StudioDraftsController_get', 'get'],
+        ['StudioDraftsController_save', 'put'],
+        ['StudioDraftsController_acknowledge', 'post'],
+    ].every(([id, method]) => operations.some((op) => op.operationId === id && op.method === method && op.studioDraftVersion === 1));
+}
+/** The API owns authorization, persistence and compare-and-set across MCP sessions/pods. */
+export function createStudioDraftTools(operations, http) {
+    if (!supportsStudioDrafts(operations))
+        return [];
+    const path = (args) => `/v2/projects/${args.projectId}/studio-drafts/${args.draftId}`;
+    async function read(args, signal) {
+        const result = draft.parse(await http.request('get', path(args), { signal }));
+        if (result.id !== args.draftId || result.projectId !== args.projectId)
+            throw new Error('Sync returned a different Studio draft.');
+        return result;
+    }
+    const writeAnnotations = {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false,
+    };
+    const appOnly = { ui: { visibility: ['app'] } };
+    return [
+        {
+            name: 'studio-drafts_get',
+            title: 'Read current Studio draft',
+            description: 'Read the draftId/projectId published by the open Studio. Use its current revision before changing selections or settings. appliedRevision equal to revision means Studio acknowledged the change; otherwise it is saved but awaiting Studio. Never infer a displayed selection from chat prose.',
+            inputSchema: identity,
+            outputSchema: draft.shape,
+            annotations: {
+                readOnlyHint: true,
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: false,
+            },
+            handler: (args, context) => read(z.object(identity).parse(args), context?.signal),
+        },
+        {
+            name: 'studio-drafts_update',
+            title: 'Change Studio selections and settings',
+            description: 'Update only the open editable Studio draft, using its published draftId/projectId and the expectedRevision returned by studio-drafts_get. Replaces the specified media selections, workflow, model options, language or unsent speech settings; changing the visual can clear audio derived from the previous visual. Only make changes requested by the user. This does not generate, translate, clone, upload, or spend credits. On a conflict, read the draft and reconcile; never automatically overwrite newer edits. A successful save is awaiting Studio until appliedRevision equals revision; only then claim the UI applied it.',
+            inputSchema: edit.shape,
+            outputSchema: draft.shape,
+            annotations: writeAnnotations,
+            handler: async (args, context) => {
+                const input = edit.parse(args);
+                const current = await read(input, context?.signal);
+                if (current.revision !== input.expectedRevision)
+                    throw new ApiRequestError('Studio has newer edits. Read the current draft before changing it.', 409, 'STUDIO_DRAFT_CONFLICT');
+                if (!current.editable)
+                    throw new ApiRequestError('Studio is protecting an active request or recovery. Return to an editable draft first.', 409, 'STUDIO_DRAFT_BUSY');
+                const patch = input.patch;
+                const next = {
+                    ...current.state,
+                    ...patch,
+                    options: { ...current.state.options, ...patch.options },
+                    speech: { ...current.state.speech, ...patch.speech },
+                };
+                if (patch.audioId !== undefined) {
+                    next.audioRemoved = patch.audioId === null;
+                    next.derivedAudioVisualId = null;
+                }
+                else if (patch.visualId !== undefined &&
+                    patch.visualId !== current.state.visualId &&
+                    current.state.derivedAudioVisualId) {
+                    next.audioId = null;
+                    next.audioRemoved = true;
+                    next.derivedAudioVisualId = null;
+                }
+                return draft.parse(await http.request('put', path(input), {
+                    body: {
+                        expectedRevision: input.expectedRevision,
+                        state: state.parse(next),
+                        editable: true,
+                    },
+                    signal: context?.signal,
+                }));
+            },
+        },
+        {
+            name: 'studio-drafts_save',
+            title: 'Save Studio draft',
+            description: 'Studio-only save of its own editable snapshot and recovery lock. Compare-and-set against the revision Studio last read, so it never replaces newer edits from chat or another Studio. No provider work is performed.',
+            inputSchema: save.shape,
+            outputSchema: draft.shape,
+            meta: appOnly,
+            // ChatGPT asks the user before a destructive widget call (and Android fails it), so a
+            // background autosave marked destructive never reached the API and Studio re-read
+            // the missing draft about once a minute. Compare-and-set cannot discard unseen edits.
+            annotations: { ...writeAnnotations, destructiveHint: false },
+            handler: async (args, context) => {
+                const input = save.parse(args);
+                return draft.parse(await http.request('put', path(input), {
+                    body: {
+                        expectedRevision: input.expectedRevision,
+                        state: input.state,
+                        editable: input.editable,
+                    },
+                    signal: context?.signal,
+                }));
+            },
+        },
+        {
+            name: 'studio-drafts_ack',
+            title: 'Acknowledge applied Studio draft',
+            description: 'Studio-only acknowledgement after validating, applying and persisting the exact revision. Does not edit settings or start jobs.',
+            inputSchema: acknowledge.shape,
+            outputSchema: draft.shape,
+            meta: appOnly,
+            annotations: { ...writeAnnotations, destructiveHint: false, idempotentHint: true },
+            handler: async (args, context) => {
+                const input = acknowledge.parse(args);
+                return draft.parse(await http.request('post', `${path(input)}/acknowledgement`, {
+                    body: { revision: input.revision },
+                    signal: context?.signal,
+                }));
+            },
+        },
+    ];
+}