@sync.so/mcp-server 0.1.4 → 0.2.0

package/dist/tool-names.js

@@ -0,0 +1,133 @@
+/**
+ * Tool names follow one `<noun>_<verb>` scheme (CRAFT-7786). This is the permanent record
+ * of every rename, old → new: operationIdToToolName names generated tools through it,
+ * nameTakenByRenamedTool reserves its new names, and analytics report the old names.
+ * Never delete entries; ending the old names' deprecation is OLD_NAME_ALIASES below.
+ */
+export const RENAMED_TOOLS = {
+    'create-lipsync': 'lipsync_create',
+    'create-lipsync-from-assets': 'lipsync_create-from-assets',
+    'create-timeline-lipsync': 'lipsync_create-timeline',
+    'generate_create-generation': 'generations_create',
+    'generate_get-generation': 'generations_get',
+    'generate_get-generations': 'generations_list',
+    'generate_estimate-cost': 'generations_estimate-cost',
+    'generations_estimate-cost': 'generations_estimate',
+    'generations_get-by-id': 'generations_get-details',
+    'generations_get-count': 'generations_count',
+    'get-generation-costs': 'generations_get-costs',
+    'get-generation-continuation': 'generations_get-continuation',
+    models_get: 'models_list',
+    'create-translate-and-dub': 'dubbing_create',
+    'get-translation-options': 'dubbing_get-options',
+    'estimate-translation-preview': 'translation-previews_estimate',
+    'create-translation-preview': 'translation-previews_create',
+    'get-translation-preview': 'translation-previews_get',
+    'get-speech-options': 'speech-previews_get-options',
+    'create-speech-preview': 'speech-previews_create',
+    'get-speech-preview': 'speech-previews_get',
+    'voices_get-voices': 'voices_list',
+    'voices_get-voice': 'voices_get',
+    'voices_clone-voice': 'voices_clone',
+    'voices_delete-voice': 'voices_delete',
+    'tts_create-job': 'tts-jobs_create',
+    'tts_get-job': 'tts-jobs_get',
+    'get-dialogue-options': 'dialogue_get-options',
+    'upload-dialogue-source': 'dialogue_upload-source',
+    'create-dialogue-transcription': 'dialogue-transcriptions_create',
+    'get-dialogue-transcription': 'dialogue-transcriptions_get',
+    'create-dialogue-preview': 'dialogue-previews_create',
+    'get-dialogue-preview': 'dialogue-previews_get',
+    'estimate-dialogue-video': 'dialogue-videos_estimate',
+    'create-dialogue-video': 'dialogue-videos_create',
+    'dialogue-edits_create-dialogue-edit': 'dialogue-edits_create',
+    'dialogue-edits_get-dialogue-edit-job': 'dialogue-edits_get',
+    'transcriptions_create-transcription': 'transcriptions_create',
+    'transcriptions_get-transcription-job': 'transcriptions_get',
+    'assets_get-all': 'assets_list',
+    'get-playback-metadata': 'assets_get-playback-metadata',
+    'get-asset-creators': 'assets_list-creators',
+    'upload-media': 'assets_upload',
+    'open-upload-widget': 'assets_open-upload-widget',
+    'trim-audio': 'audio-trims_create',
+    'get-audio-trim': 'audio-trims_get',
+    'projects_get-all': 'projects_list',
+    'projects_get-generations': 'projects_list-generations',
+    'rename-project': 'projects_rename',
+    'get-account-context': 'account_get-context',
+    'get-account-usage': 'account_get-usage',
+    'send-feedback': 'feedback_send',
+    'track-chatgpt-event': 'analytics_track-event',
+    'open-sync-app': 'app_open',
+    'get-studio-view': 'studio-views_get',
+    'open-studio-project': 'studio-views_open-project',
+    'refresh-studio-project': 'studio-views_refresh-project',
+    'refresh-studio-assets': 'studio-views_refresh-assets',
+    'show-studio-generation': 'studio-views_show-generation',
+    'continue-studio-generation': 'studio-views_continue-generation',
+    'register-studio-view': 'studio-views_register',
+    'ack-studio-view': 'studio-views_ack',
+    'get-studio-draft': 'studio-drafts_get',
+    'update-studio-draft': 'studio-drafts_update',
+    'save-studio-draft': 'studio-drafts_save',
+    'ack-studio-draft': 'studio-drafts_ack',
+};
+const LEGACY_BY_NAME = new Map(Object.entries(RENAMED_TOOLS).map(([legacy, name]) => [name, legacy]));
+/** The current name for a name derived from an operationId or used before the rename. */
+export function currentToolName(name) {
+    return RENAMED_TOOLS[name] ?? name;
+}
+const CURRENT_NAMES = new Set(Object.values(RENAMED_TOOLS));
+/**
+ * True when a generated tool's derived name is already a renamed tool's new name, such as
+ * StudioViewsController_get → studio-views_get. The hand-written tool owns that name, so
+ * the raw operation is never exposed under it.
+ */
+export function nameTakenByRenamedTool(derived) {
+    return !(derived in RENAMED_TOOLS) && CURRENT_NAMES.has(derived);
+}
+/** The name a tool had before the rename, if it changed. Permanent; see oldNameAlias. */
+export function previousToolName(name) {
+    return LEGACY_BY_NAME.get(name);
+}
+/**
+ * Temporary: the old names that stay callable, as unlisted aliases that add a notice
+ * naming the new tool, and that app profiles list as app-only tools because retained
+ * Studio bundles and widget templates call them. Remove names here (eventually all of
+ * them) to end the deprecation; RENAMED_TOOLS and generated tool names stay as they are.
+ */
+export const OLD_NAME_ALIASES = new Set(Object.keys(RENAMED_TOOLS));
+/** The old name still callable for this tool during the deprecation, if any. */
+export function oldNameAlias(name, aliases = OLD_NAME_ALIASES) {
+    const previous = previousToolName(name);
+    return previous !== undefined && aliases.has(previous) ? previous : undefined;
+}
+export function renamedToolNotice(legacy, name) {
+    return `Tool ${legacy} is now named ${name}; call ${name} from now on, as the old name will stop working after the deprecation period.`;
+}
+/**
+ * Widgets cannot call a tool that is not listed, and ChatGPT keeps earlier Studio bundles
+ * and widget templates that call tools by their old names. On app profiles, list those
+ * old names as app-only tools (the model does not see them) for the deprecation period.
+ */
+export function withLegacyAppDescriptors(descriptors) {
+    const current = new Set(descriptors.map((descriptor) => descriptor.name));
+    const legacy = descriptors.flatMap((descriptor) => {
+        const name = oldNameAlias(descriptor.name);
+        const meta = descriptor._meta ?? {};
+        const ui = (meta.ui ?? {});
+        const forApp = (Array.isArray(ui.visibility) && ui.visibility.includes('app')) ||
+            meta['openai/widgetAccessible'] === true;
+        if (!name || !forApp || current.has(name))
+            return [];
+        return [
+            {
+                ...descriptor,
+                name,
+                description: `Deprecated name of ${descriptor.name}, kept for Sync app widgets. Call ${descriptor.name}.`,
+                _meta: { ...meta, ui: { ...ui, visibility: ['app'] } },
+            },
+        ];
+    });
+    return [...descriptors, ...legacy];
+}

package/dist/tools/account-context.d.ts

@@ -0,0 +1,5 @@
+import { type HttpClient } from '../http-client.js';
+import type { McpToolDefinition } from './generator.js';
+import { type CredentialKind } from './organizations.js';
+export declare function createAccountContextTool(http: HttpClient, studioDraftSync?: boolean, studioViewSync?: boolean, audioTrimming?: boolean, chatgptAnalytics?: boolean, credential?: CredentialKind): McpToolDefinition;
+//# sourceMappingURL=account-context.d.ts.map

package/dist/tools/account-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-context.d.ts","sourceRoot":"","sources":["../../src/tools/account-context.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAErE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAEL,KAAK,cAAc,EAIpB,MAAM,oBAAoB,CAAC;AA8E5B,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,UAAU,EAChB,eAAe,UAAQ,EACvB,cAAc,UAAQ,EACtB,aAAa,UAAQ,EACrB,gBAAgB,UAAQ,EACxB,UAAU,GAAE,cAAuB,GAClC,iBAAiB,CA6DnB"}

package/dist/tools/account-context.js

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import { ApiRequestError } from '../http-client.js';
+import { currentOrganizationSession } from '../organization-selection.js';
+import { featuresSchema, parseAccountOverview, switchHint, } from './organizations.js';
+const accountContext = z.object({
+    account: z
+        .object({
+        id: z.uuid(),
+        email: z.string().nullable(),
+        name: z.string().nullable(),
+    })
+        .nullable(),
+    limits: z
+        .object({
+        seats: z.number().finite().nonnegative(),
+        voiceClone: z.number().finite().nonnegative(),
+    })
+        .optional(),
+    organization: z.object({
+        id: z.uuid(),
+        name: z.string().nullable(),
+        role: z.string(),
+    }),
+    plan: z.object({ id: z.string(), name: z.string() }).optional(),
+    generationLimits: z
+        .object({
+        concurrency: z.number().finite().nonnegative(),
+        maxOutputDurationSeconds: z.number().finite().nonnegative(),
+    })
+        .optional()
+        .describe('Generations that can run at once and the longest output one may produce, in seconds. Plan a job within these before creating it.'),
+    capabilities: z.object({
+        projectRenaming: z.literal(true),
+        chatgptAnalytics: z.literal(true).optional(),
+        studioDraftSync: z.literal(true).optional(),
+        studioViewSync: z.literal(true).optional(),
+        audioTrimming: z.literal(true).optional(),
+    }),
+    features: featuresSchema.optional(),
+    organizationChoice: z
+        .object({
+        selectedBy: z
+            .enum(['session', 'credential'])
+            .describe('session: chosen with organizations_select. credential: the default of this sign-in or API key.'),
+        howToSwitch: z.string(),
+    })
+        .describe('How the active organization was chosen, and how to work in another one.'),
+});
+/**
+ * GET /v2/account reflects the organization chosen for this request, so it wins over the
+ * caller identity. Remembers what was read for this MCP session, unless the session switched
+ * organization while it was read (`stamp`, taken before the read).
+ */
+function activeOrganization(caller, overview, stamp) {
+    const organization = overview?.organization
+        ? {
+            id: overview.organization.id,
+            name: overview.organization.name,
+            role: overview.organization.role ?? caller.organization.role,
+        }
+        : caller.organization;
+    const session = currentOrganizationSession();
+    if (session && !session.selected)
+        session.rememberDefault({ id: organization.id, name: organization.name });
+    if (session && overview && stamp)
+        session.recordFeatures(overview.features, stamp, overview.organization?.id);
+    return organization;
+}
+export function createAccountContextTool(http, studioDraftSync = false, studioViewSync = false, audioTrimming = false, chatgptAnalytics = false, credential = 'user') {
+    return {
+        name: 'account_get-context',
+        title: 'Read connected Sync account',
+        description: 'Read the authenticated account and the organization this session runs in (all generations are created there), for account display and personal asset scope, its plan, generation limits (concurrency and longest output), feature flags, team seats and voice-clone limits. organizationChoice says how that organization was chosen and how to switch. API keys have no signed-in account. This does not grant permissions or change the organization.',
+        inputSchema: {},
+        outputSchema: accountContext.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        handler: async (_args, context) => {
+            const identity = await http.request('get', '/v2/oauth/account', {
+                signal: context?.signal,
+            });
+            // A limits outage must not erase verified identity; expired credentials still need linking.
+            const optional = async (path) => {
+                try {
+                    return await http.request('get', path, { signal: context?.signal });
+                }
+                catch (error) {
+                    context?.signal?.throwIfAborted();
+                    if (error instanceof ApiRequestError && error.status === 401)
+                        throw error;
+                    return undefined;
+                }
+            };
+            const limits = await optional('/v2/plans/limits');
+            const stamp = currentOrganizationSession()?.featureStamp();
+            const overview = await optional('/v2/account');
+            const plan = overview === undefined ? undefined : parseAccountOverview(overview);
+            const caller = z
+                .object({
+                account: accountContext.shape.account,
+                organization: accountContext.shape.organization,
+            })
+                .parse(identity);
+            return accountContext.parse({
+                account: caller.account,
+                organization: activeOrganization(caller, plan, stamp),
+                ...(limits === undefined ? {} : { limits }),
+                ...(plan?.plan ? { plan: plan.plan } : {}),
+                ...(plan?.limits ? { generationLimits: plan.limits } : {}),
+                capabilities: {
+                    projectRenaming: true,
+                    ...(chatgptAnalytics && context?.clientProfile?.name === 'chatgpt'
+                        ? { chatgptAnalytics: true }
+                        : {}),
+                    ...(studioDraftSync ? { studioDraftSync: true } : {}),
+                    ...(studioViewSync ? { studioViewSync: true } : {}),
+                    ...(audioTrimming ? { audioTrimming: true } : {}),
+                },
+                ...(plan?.features ? { features: plan.features } : {}),
+                organizationChoice: {
+                    selectedBy: currentOrganizationSession()?.selected ? 'session' : 'credential',
+                    howToSwitch: switchHint(credential),
+                },
+            });
+        },
+    };
+}

package/dist/tools/account-management.d.ts

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

package/dist/tools/account-management.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-management.d.ts","sourceRoot":"","sources":["../../src/tools/account-management.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AA+CxD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,UAAU,GAAG,iBAAiB,EAAE,CAkFlF"}

package/dist/tools/account-management.js

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+const counter = z.object({
+    used: z.number().finite().nonnegative(),
+    max: z.number().finite().nonnegative(),
+});
+const billing = z.object({
+    plan: z.string().nullable(),
+    canManageBilling: z.boolean(),
+    credits: z
+        .object({
+        balance: z.number().finite(),
+        available: z.number().finite(),
+        inFlight: z.number().finite(),
+    })
+        .nullish(),
+    freeMonthlyLimits: z
+        .object({ generations: counter, tts: counter, monthlyResetDate: z.string().datetime() })
+        .nullable(),
+});
+const usage = z.object({
+    totalCostCents: z.number().finite(),
+    totalFrames: z.number().finite().nonnegative(),
+    totalTtsSeconds: z.number().finite().nonnegative(),
+});
+const response = billing.extend({
+    credits: billing.shape.credits.unwrap().nullable(),
+    usage: usage.nullable(),
+});
+const totals = z.object({
+    isComplete: z.boolean(),
+    items: z.array(z.union([
+        z.object({
+            totalGenerationsAmountBilledCents: z.number().finite(),
+            totalFramesCount: z.number().finite().nonnegative(),
+        }),
+        z.object({
+            totalIntegrationsAmountBilledCents: z.number().finite(),
+            totalSecondsGenerated: z.number().finite().nonnegative(),
+        }),
+    ])),
+});
+const rename = z.object({ projectId: z.uuid(), name: z.string().trim().min(1).max(255) });
+const project = z.object({ id: z.uuid(), name: z.string() });
+export function createAccountManagementTools(http) {
+    return [
+        {
+            name: 'account_get-usage',
+            title: 'Read Sync usage and balance',
+            description: 'Read the connected organization’s available credits, free allowance, or complete billed usage for the current period. Does not purchase credits, change plans, or start generation.',
+            inputSchema: {},
+            outputSchema: response.shape,
+            annotations: {
+                readOnlyHint: true,
+                destructiveHint: false,
+                openWorldHint: false,
+                idempotentHint: true,
+            },
+            handler: async (_args, context) => {
+                const identity = z
+                    .object({ organization: z.object({ role: z.string() }) })
+                    .parse(await http.request('get', '/v2/oauth/account', { signal: context?.signal }));
+                const info = billing.parse(await http.request('get', '/v2/billing', { signal: context?.signal }));
+                let summary = null;
+                if (!info.credits && !info.freeMonthlyLimits) {
+                    const data = totals.parse(await http.request('get', '/v2/usage/totals-with-completeness', {
+                        signal: context?.signal,
+                    }));
+                    if (data.isComplete)
+                        summary = data.items.reduce((sum, item) => ({
+                            totalCostCents: sum.totalCostCents +
+                                ('totalGenerationsAmountBilledCents' in item
+                                    ? item.totalGenerationsAmountBilledCents
+                                    : item.totalIntegrationsAmountBilledCents),
+                            totalFrames: sum.totalFrames + ('totalFramesCount' in item ? item.totalFramesCount : 0),
+                            totalTtsSeconds: sum.totalTtsSeconds +
+                                ('totalSecondsGenerated' in item ? item.totalSecondsGenerated : 0),
+                        }), { totalCostCents: 0, totalFrames: 0, totalTtsSeconds: 0 });
+                }
+                return response.parse({
+                    ...info,
+                    canManageBilling: info.canManageBilling && ['owner', 'admin'].includes(identity.organization.role),
+                    credits: info.credits ?? null,
+                    usage: summary,
+                });
+            },
+        },
+        {
+            name: 'projects_rename',
+            title: 'Rename a Sync project',
+            description: 'Change only the name of an accessible Sync project in the connected organization. Does not change visibility, ownership, media, or generations. Requires an explicit user request.',
+            inputSchema: rename.shape,
+            outputSchema: project.shape,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                openWorldHint: false,
+                idempotentHint: true,
+            },
+            handler: async (args, context) => {
+                const { projectId, name } = rename.parse(args);
+                const result = project.parse(await http.request('patch', `/v2/projects/${projectId}`, {
+                    body: { name },
+                    signal: context?.signal,
+                }));
+                if (result.id.toLowerCase() !== projectId.toLowerCase())
+                    throw new Error('Could not verify the renamed project.');
+                return result;
+            },
+        },
+    ];
+}

package/dist/tools/app-tools.d.ts

@@ -0,0 +1,31 @@
+import { type ClientProfile } from '../client-profile.js';
+import type { HttpClient } from '../http-client.js';
+import { type UploadRuntime } from '../upload-runtime.js';
+import type { McpToolDefinition } from './generator.js';
+/**
+ * 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 declare function createAppTools(httpClient: HttpClient, runtime?: UploadRuntime, getProfile?: () => ClientProfile): McpToolDefinition[];
+//# sourceMappingURL=app-tools.d.ts.map

package/dist/tools/app-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-tools.d.ts","sourceRoot":"","sources":["../../src/tools/app-tools.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAwB,MAAM,sBAAsB,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,sBAAsB,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAmExD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,aAA6B,EACtC,UAAU,GAAE,MAAM,aAA4C,GAC7D,iBAAiB,EAAE,CA0YrB"}