@tday-com/mcp 0.0.0-stage → 0.3.0

package/dist/tools-launch.js

@@ -0,0 +1,358 @@
+import { constants } from "node:fs";
+import { open, rm } from "node:fs/promises";
+import { z } from "zod";
+import { api } from "./api-client.js";
+import { prepareOutputFilePath, validateImageUrl } from "./download-safety.js";
+import { argsObject, readOnly, safeIdSchema, safePath, writeLocal, writeRemote, } from "./tool-schemas.js";
+const MAX_TITLE_CHARS = 160;
+const MAX_DESCRIPTION_CHARS = 4000;
+const MAX_DIRECTION_CHARS = 600;
+export const MAX_VIDEO_BYTES = 250 * 1024 * 1024;
+const MUSIC_MOODS = ["Cinematic", "Upbeat", "Minimal", "Warm", "Driving"];
+const NARRATION_STYLES = ["talk", "thread", "story", "duo", "team", "launch", "doc"];
+const STYLES = "talk (one person talking to one viewer who has the problem, the default); thread (says how many updates there are, then goes through each by name, the default for a product update); " +
+    "story (a day in the life of one person in your audience); duo (two voices: the viewer's inner voice and a narrator); team (from the team who built it); launch (quick and bright); doc (a calm, third-person documentary)";
+const VOICE_NAMES = ["Reece", "Ivy", "Janet", "Sarah", "Craig"];
+const VOICES = "Reece, warm conversational narrator; Ivy, bright friendly presenter; Janet, warm expressive explainer; " +
+    "Sarah, upbeat lively presenter; Craig, deep polished broadcast voice";
+const POLL_GUIDANCE = "Poll tday_poll_launch_video with this videoId every 20-30 seconds until it is ready.";
+const VOICEOVER_NOT_INCLUDED = "Voiceover is not included on this organisation's plan, so the film is silent and no voice was charged.";
+const videoIdSchema = safeIdSchema.describe("videoId returned by tday_create_launch_video");
+const outputSchemas = {
+    create: z
+        .object({ videoId: z.string(), status: z.string(), narration: z.string(), reviewUrl: z.string() })
+        .passthrough(),
+    poll: z
+        .object({ videoId: z.string(), status: z.string(), state: z.string(), terminal: z.boolean(), reviewUrl: z.string() })
+        .passthrough(),
+    mp4: z
+        .object({
+        videoId: z.string(),
+        versionId: z.string(),
+        fps: z.number(),
+        state: z.enum(["ready", "rendering", "failed"]),
+        mp4Url: z.string().optional(),
+        progress: z.number().nullable().optional(),
+        saved: z.boolean().optional(),
+        path: z.string().optional(),
+        size: z.number().optional(),
+    })
+        .passthrough(),
+    revise: z.object({ videoId: z.string(), status: z.string(), reviewUrl: z.string() }).passthrough(),
+};
+const FIRST_EXPORT = "The first request for a cut at a frame rate renders its file, which usually takes a minute or two";
+export const launchTools = [
+    {
+        name: "tday_create_launch_video",
+        title: "Create launch video",
+        description: "Make a launch video: a short animated film announcing a feature or product, in the brand's own look. tday's pipeline writes the brief, storyboard, motion, music and narration from the title and description; describe the subject well and pick the options. " +
+            "For a feature tday already has (tday_list_features), pass its featureId instead of brandId, title and description: the film is made of that feature, with what tday knows about it. " +
+            "It spends credits from the brand's organisation: a standard (20s), scored, silent film is 40 credits, and a voiceover or another length changes that (tday_get_credit_prices has the full list). " +
+            "A 402 means the balance cannot cover it: nothing was started, so do not retry. Returns a videoId and a reviewUrl at once; the film takes about 2-5 minutes, so poll tday_poll_launch_video.",
+        inputSchema: argsObject({
+            featureId: safeIdSchema
+                .optional()
+                .describe("A feature's id from tday_list_features: the film is made of it, and brandId, title and description are not needed."),
+            brandId: safeIdSchema
+                .optional()
+                .describe("Brand ID from tday_list_brands, for a new subject (without featureId). The film uses this brand's colours, fonts and logo."),
+            title: z
+                .string()
+                .trim()
+                .min(1)
+                .max(MAX_TITLE_CHARS)
+                .optional()
+                .describe("The feature or product the film launches, as a short name (without featureId)."),
+            description: z
+                .string()
+                .trim()
+                .min(1)
+                .max(MAX_DESCRIPTION_CHARS)
+                .optional()
+                .describe("What the feature or product does and who it is for (without featureId). The film's brief is written from this, so be specific."),
+            length: z
+                .enum(["short", "standard", "long"])
+                .default("standard")
+                .describe("short (about 10s), standard (about 20s, the default) or long (about 50s)."),
+            narration: z
+                .enum(["silent", "voiceover"])
+                .default("silent")
+                .describe("silent (music and motion carry it, the default) or voiceover (narrated, with captions; costs more)."),
+            music: z.enum(["score", "none"]).default("score").describe("score (a bed written to the film's length, the default) or none."),
+            musicMood: z.enum(MUSIC_MOODS).optional().describe("A mood for the score. Omit to let the planner choose."),
+            voice: z.enum(VOICE_NAMES).optional().describe(`The narrator of a voiceover film. Omit for the default. One of: ${VOICES}.`),
+            narrationStyle: z.enum(NARRATION_STYLES).optional().describe(`How a voiceover film tells its story. Omit for the default. One of: ${STYLES}.`),
+            direction: z
+                .string()
+                .trim()
+                .min(1)
+                .max(MAX_DIRECTION_CHARS)
+                .optional()
+                .describe("Optional creative notes in plain words, for example 'lead on the scrubbing, end on the call to action'."),
+        }),
+        outputSchema: outputSchemas.create,
+        annotations: writeRemote,
+        handler: async (args, config) => {
+            const existing = typeof args.featureId === "string" ? args.featureId : null;
+            const featureId = existing ?? (await saveSubject(args, config));
+            const created = await api(config, safePath("/api/showcase/features/:id/create-launch-video", { id: featureId }), { method: "POST", body: JSON.stringify(launchAxes(args)) }).catch((error) => {
+                if (existing)
+                    throw error;
+                throw new Error(`${error instanceof Error ? error.message : String(error)} ${subjectSaved(args.title)}`);
+            });
+            const videoId = created?.runFeatureId;
+            if (typeof videoId !== "string")
+                throw new Error("tday could not start that film. Try again in a moment.");
+            const narration = created?.narration === "voiceover" || created?.narration === "silent" ? created.narration : args.narration;
+            return {
+                videoId,
+                status: "queued",
+                length: args.length,
+                narration,
+                music: args.music,
+                reviewUrl: reviewUrl(config, videoId),
+                ...(args.narration === "voiceover" && narration === "silent" ? { note: VOICEOVER_NOT_INCLUDED } : {}),
+                next: `A film takes about 2-5 minutes. ${POLL_GUIDANCE}`,
+            };
+        },
+    },
+    {
+        name: "tday_poll_launch_video",
+        title: "Poll launch video",
+        description: "Check a launch video made with tday_create_launch_video or revised with tday_revise_launch_video. state is in_progress, ready or failed; terminal is true once it is ready or failed. " +
+            "Poll every 20-30 seconds while it is in progress. When it is ready, watch it at reviewUrl or call tday_get_launch_video_mp4 for the MP4 file. Spends no credits.",
+        inputSchema: argsObject({ videoId: videoIdSchema }),
+        outputSchema: outputSchemas.poll,
+        annotations: readOnly,
+        handler: async (args, config) => {
+            const videoId = String(args.videoId);
+            const payload = await api(config, safePath("/api/showcase/videos/:videoId", args));
+            return summarizeLaunchVideo(videoId, payload ?? {}, reviewUrl(config, videoId));
+        },
+    },
+    {
+        name: "tday_get_launch_video_mp4",
+        title: "Get launch video MP4",
+        description: "Get a ready launch video as an MP4 file URL. A launch video is ready before its file: " + FIRST_EXPORT + ", so this answers state rendering " +
+            "(with progress) until the file exists - call it again every 20-30 seconds until state is ready. Later requests return the stored file at once. Spends no credits. " +
+            "If state is failed, call it again with retry: true. versionId defaults to the newest ready cut (readyVersionId from tday_poll_launch_video). " +
+            `Pass download: true to also save it inside the current working directory once it is ready (at most ${MAX_VIDEO_BYTES / 1024 / 1024}MB).`,
+        inputSchema: argsObject({
+            videoId: videoIdSchema,
+            versionId: safeIdSchema.optional().describe("A cut's versionId from tday_poll_launch_video. Omit for the newest ready cut."),
+            fps: z.union([z.literal(60), z.literal(30)]).default(60).describe("The file's frame rate: 60 (the default, smoothest) or 30 (a smaller file). Older cuts that cannot be rendered again offer only 60 and answer 409 for 30."),
+            retry: z.boolean().default(false).describe("Ask again after state failed. Defaults to false."),
+            download: z.boolean().default(false).describe("Also save the MP4 into the current working directory. Defaults to false."),
+            filePath: z
+                .string()
+                .trim()
+                .min(1)
+                .max(500)
+                .optional()
+                .describe("Where to save it, relative to cwd. Defaults to ./tday-launch-videos/<videoId>-<versionId>.mp4 (<videoId>-<versionId>-30fps.mp4 at 30 fps, so both rates can sit side by side). Only used with download."),
+            overwrite: z.boolean().default(false).describe("Whether to overwrite an existing regular file. Defaults to false for safety."),
+        }),
+        outputSchema: outputSchemas.mp4,
+        annotations: writeLocal,
+        handler: async (args, config) => {
+            const videoId = String(args.videoId);
+            const versionId = typeof args.versionId === "string" ? args.versionId : await newestReadyVersion(config, videoId);
+            const fps = args.fps === 30 ? 30 : 60;
+            const answer = await api(config, safePath("/api/showcase/videos/:videoId/render", args), {
+                method: "POST",
+                body: JSON.stringify({ versionId, ...(fps === 30 ? { fps } : {}), ...(args.retry ? { retry: true } : {}) }),
+            });
+            const waiting = exportWaiting(answer, { videoId, versionId, fps, reviewUrl: reviewUrl(config, videoId) });
+            if (waiting)
+                return waiting;
+            const mp4Url = answer?.mp4Url;
+            if (typeof mp4Url !== "string")
+                throw new Error("tday could not prepare the video. Try again in a moment.");
+            const film = { videoId, versionId, fps, state: "ready", mp4Url, reviewUrl: reviewUrl(config, videoId) };
+            if (!args.download)
+                return film;
+            const filePath = typeof args.filePath === "string" ? args.filePath : `./tday-launch-videos/${videoId}-${versionId}${fps === 30 ? "-30fps" : ""}.mp4`;
+            return { ...film, saved: true, ...(await saveVideo(mp4Url, filePath, Boolean(args.overwrite))) };
+        },
+    },
+    {
+        name: "tday_revise_launch_video",
+        title: "Revise launch video",
+        description: "Make a new cut of a ready launch video from notes, for example 'slow the ending down' or 'lead with the search box'. The kept film is edited to the notes, so the rest stays as it was. " +
+            "It spends tweak credits from the brand's organisation (13 credits for a standard film; tday_get_credit_prices has the full list), and a 402 means the balance cannot cover it. " +
+            "A 409 means a cut is already being made: poll until it finishes. The previous cut stays available while the new one is made. " + POLL_GUIDANCE,
+        inputSchema: argsObject({
+            videoId: videoIdSchema,
+            notes: z.string().trim().min(1).max(MAX_DIRECTION_CHARS).describe("What to change, in plain words."),
+        }),
+        outputSchema: outputSchemas.revise,
+        annotations: writeRemote,
+        handler: async (args, config) => {
+            const videoId = String(args.videoId);
+            const cut = await api(config, safePath("/api/showcase/videos/:videoId/regenerate", args), {
+                method: "POST",
+                body: JSON.stringify({ instructions: args.notes }),
+            });
+            return {
+                videoId,
+                ...(typeof cut?.versionId === "string" ? { versionId: cut.versionId } : {}),
+                status: "queued",
+                reviewUrl: reviewUrl(config, videoId),
+                next: `A new cut takes a few minutes. ${POLL_GUIDANCE}`,
+            };
+        },
+    },
+];
+async function saveSubject(args, config) {
+    if (typeof args.brandId !== "string" || typeof args.title !== "string" || typeof args.description !== "string") {
+        throw new Error("Pass featureId (from tday_list_features), or brandId with a title and description for a new subject.");
+    }
+    const saved = await api(config, "/api/showcase/features", {
+        method: "POST",
+        body: JSON.stringify({ brandId: args.brandId, title: args.title, description: args.description, typeId: null }),
+    });
+    const featureId = saved?.feature?.id;
+    if (typeof featureId !== "string")
+        throw new Error("tday could not start that film. Try again in a moment.");
+    return featureId;
+}
+function subjectSaved(title) {
+    return `The subject "${String(title)}" was saved on the brand's Launch page, where a film can be made from it later.`;
+}
+function launchAxes(args) {
+    return {
+        length: args.length,
+        narration: args.narration,
+        music: args.music,
+        ...(args.musicMood ? { musicMood: args.musicMood } : {}),
+        ...(args.voice ? { voiceId: args.voice } : {}),
+        ...(args.narrationStyle ? { narrationStyle: args.narrationStyle } : {}),
+        ...(args.direction ? { direction: args.direction } : {}),
+    };
+}
+function reviewUrl(config, videoId) {
+    return `${config.webBaseUrl}/showcase/review/${encodeURIComponent(videoId)}`;
+}
+async function newestReadyVersion(config, videoId) {
+    const payload = await api(config, safePath("/api/showcase/videos/:videoId", { videoId }));
+    const versionId = payload?.video?.versionId;
+    if (typeof versionId !== "string") {
+        throw new Error("This launch video has no finished cut yet. Poll tday_poll_launch_video until it is ready, then try again.");
+    }
+    return versionId;
+}
+function summarizeLaunchVideo(videoId, payload, url) {
+    const status = stringOr(payload.feature?.status, "unknown");
+    const first = Array.isArray(payload.versions) ? payload.versions[0] : undefined;
+    const latest = typeof first === "object" && first !== null ? first : null;
+    const latestStatus = stringOr(latest?.status, null);
+    const readyVersionId = stringOr(payload.video?.versionId, null);
+    const state = launchState(status, latestStatus);
+    const failureMessage = state === "failed" ? stringOr(latest?.failureMessage, null) : null;
+    const durationMs = typeof payload.video?.durationMs === "number" ? payload.video.durationMs : null;
+    return {
+        videoId,
+        ...(typeof payload.feature?.title === "string" ? { title: payload.feature.title } : {}),
+        status,
+        state,
+        terminal: state !== "in_progress",
+        latestVersion: latest
+            ? { versionId: stringOr(latest.versionId, null), versionNumber: latest.versionNumber ?? null, status: latestStatus }
+            : null,
+        ...(readyVersionId ? { readyVersionId } : {}),
+        ...(durationMs !== null ? { durationMs } : {}),
+        ...(failureMessage ? { failureMessage } : {}),
+        reviewUrl: url,
+        next: nextStep(state, readyVersionId),
+    };
+}
+function exportWaiting(answer, film) {
+    if (answer?.status === "rendering" || answer?.status === "none") {
+        const progress = typeof answer.progress === "number" ? answer.progress : null;
+        return {
+            ...film,
+            state: "rendering",
+            progress,
+            next: `The file is being rendered${progress === null ? "" : ` (${Math.round(progress * 100)}% done)`}. ${FIRST_EXPORT}. Call tday_get_launch_video_mp4 again in 20-30 seconds.`,
+        };
+    }
+    if (answer?.status === "failed") {
+        return {
+            ...film,
+            state: "failed",
+            error: typeof answer.error === "string" ? answer.error : "The file could not be rendered.",
+            next: "The file could not be rendered and spent no credits. Call tday_get_launch_video_mp4 again with retry: true to try again.",
+        };
+    }
+    return null;
+}
+function launchState(featureStatus, latestStatus) {
+    if (latestStatus === "ready")
+        return "ready";
+    if (latestStatus === "failed" || featureStatus === "failed")
+        return "failed";
+    if (!latestStatus && (featureStatus === "review" || featureStatus === "published"))
+        return "ready";
+    return "in_progress";
+}
+function nextStep(state, readyVersionId) {
+    if (state === "ready") {
+        return "Ready. Watch it at reviewUrl, call tday_get_launch_video_mp4 for the MP4 file (its first request renders the file, usually a minute or two), or tday_revise_launch_video to change it.";
+    }
+    if (state === "in_progress")
+        return "Still being made. Poll again in 20-30 seconds.";
+    return readyVersionId
+        ? "This cut failed and was not charged. The previous cut is still available: tday_get_launch_video_mp4 returns it, and tday_revise_launch_video can try the change again."
+        : "This film failed and was not charged. Start a new one with tday_create_launch_video.";
+}
+function stringOr(value, fallback) {
+    return typeof value === "string" && value ? value : fallback;
+}
+async function saveVideo(mp4Url, rawPath, overwrite) {
+    const url = validateImageUrl(mp4Url);
+    const filePath = await prepareOutputFilePath(rawPath, { overwrite });
+    const res = await fetch(url.href);
+    if (res.url)
+        validateImageUrl(res.url);
+    if (!res.ok)
+        throw new Error(`Failed to download the video: ${res.status} ${res.statusText}`);
+    const declared = Number(res.headers.get("content-length") ?? 0);
+    if (Number.isFinite(declared) && declared > MAX_VIDEO_BYTES) {
+        throw new Error(`The video exceeds the ${MAX_VIDEO_BYTES / 1024 / 1024}MB download limit. Use mp4Url instead.`);
+    }
+    const contentType = res.headers.get("content-type")?.toLowerCase();
+    if (contentType && !/^(video\/|application\/octet-stream|binary\/octet-stream)/.test(contentType)) {
+        throw new Error(`The download is not a video (content-type: ${contentType}).`);
+    }
+    const reader = res.body?.getReader();
+    if (!reader)
+        throw new Error("No response body from the video URL.");
+    const flags = constants.O_WRONLY |
+        constants.O_CREAT |
+        (overwrite ? constants.O_TRUNC : constants.O_EXCL) |
+        (constants.O_NOFOLLOW ?? 0);
+    const handle = await open(filePath, flags, 0o600);
+    let size = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > MAX_VIDEO_BYTES) {
+                throw new Error(`The video exceeds the ${MAX_VIDEO_BYTES / 1024 / 1024}MB download limit. Use mp4Url instead.`);
+            }
+            await handle.write(value);
+        }
+    }
+    catch (error) {
+        await handle.close();
+        await rm(filePath, { force: true });
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
+    }
+    await handle.close();
+    return { path: filePath, size };
+}

package/dist/tools.js

@@ -0,0 +1,275 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { z } from "zod";
+import { api, firstImageUrl, normalizeWebsite, query, } from "./api-client.js";
+import { MAX_IMAGE_BYTES, prepareOutputFilePath, validateImageUrl, } from "./download-safety.js";
+import { argsObject, emptyArgsSchema, listArgsSchema, outputSchemas, readOnly, safeIdSchema, safePath, stripPresentationArgs, writeLocal, writeRemote, } from "./tool-schemas.js";
+import { accountTools, imageFormatSchema } from "./tools-account.js";
+import { launchTools } from "./tools-launch.js";
+import { featureTools } from "./tools-features.js";
+const PLATFORM_BADGE_NOTE = 'This image carries a "Made with tday.com" badge because the organisation is on the Free plan. The owner can remove it by upgrading (tday_whoami has the link).';
+export { responseFormatFromArgs, safePath } from "./tool-schemas.js";
+export { ALLOWED_IMAGE_HOSTS, MAX_IMAGE_BYTES, prepareOutputFilePath, sandboxFilePath, validateImageUrl, } from "./download-safety.js";
+export { formatToolResultText, stringifyResult, toStructuredContent, } from "./result-format.js";
+export const tools = [
+    {
+        name: "tday_whoami",
+        title: "Who am I?",
+        description: "Get the linked tday account: every organisation the person belongs to, their role in it (owner, admin or member), its plan, its credit balance and when it refreshes, what the plan's output includes (sizes, the Free badge, voiceover), what upgrading would change, its brands, and links to its usage and billing pages. Each organisation has a `summary` sentence to show the person as it is. A design or launch video spends the credits of its BRAND's organisation, so check the organisation that owns the brand before quoting a balance. Only an owner can change a plan; for an admin or member, say who the owner is instead of telling them to upgrade. Use first to verify MCP is connected to the expected account.",
+        inputSchema: emptyArgsSchema,
+        outputSchema: outputSchemas.whoami,
+        annotations: readOnly,
+        handler: (_args, config) => api(config, "/api/v1/account"),
+    },
+    {
+        name: "tday_list_brands",
+        title: "List brands",
+        description: "List brands accessible to the authenticated user as lightweight summaries. Supports API-backed limit/offset pagination.",
+        inputSchema: listArgsSchema,
+        outputSchema: outputSchemas.listBrands,
+        annotations: readOnly,
+        handler: (args, config) => api(config, `/api/brands/summary${query({ limit: Number(args.limit), offset: Number(args.offset) })}`),
+    },
+    {
+        name: "tday_get_brand",
+        title: "Get brand",
+        description: "Fetch a single brand with its colors, logos, fonts, images, and knowledge base. Use after tday_list_brands when detailed brand context is needed.",
+        inputSchema: argsObject({
+            brandId: safeIdSchema.describe("Brand ID from tday"),
+        }),
+        outputSchema: outputSchemas.getBrand,
+        annotations: readOnly,
+        handler: (args, config) => api(config, safePath("/api/brands/:brandId", args)),
+    },
+    {
+        name: "tday_list_designs",
+        title: "List designs",
+        description: "List the authenticated user's designs as lightweight summaries. Supports API-backed limit/offset pagination.",
+        inputSchema: listArgsSchema,
+        outputSchema: outputSchemas.listDesigns,
+        annotations: readOnly,
+        handler: (args, config) => api(config, `/api/designs/summary${query({ limit: Number(args.limit), offset: Number(args.offset) })}`),
+    },
+    {
+        name: "tday_get_design",
+        title: "Get design",
+        description: "Fetch a single design by id, including its generations. Use after tday_list_designs when generation IDs or full design details are needed.",
+        inputSchema: argsObject({
+            designId: safeIdSchema.describe("Design ID from tday"),
+        }),
+        outputSchema: outputSchemas.getDesign,
+        annotations: readOnly,
+        handler: (args, config) => api(config, safePath("/api/designs/:designId", args)),
+    },
+    {
+        name: "tday_generate_design",
+        title: "Generate design",
+        description: "Generate a new tday design from a text prompt against a brand, then poll with tday_poll_generation until it is completed or failed. An image costs 10 credits from the brand's organisation (tday_get_credit_prices has every price; tday_whoami has the balance) and a failed generation gives them back. The response says which organisation paid and what it has left; a refusal for credits means nothing was started, so do not retry. Omit format for square (1080x1080), or landscape (1200x630) where the plan does not include square.",
+        inputSchema: argsObject({
+            prompt: z
+                .string()
+                .trim()
+                .min(1)
+                .max(5000)
+                .describe("Design prompt. Be specific about audience, format, copy, and visual direction."),
+            brandId: safeIdSchema.describe("Brand ID from tday"),
+            name: z.string().trim().min(1).max(200).optional().describe("Short design name"),
+            format: imageFormatSchema,
+        }),
+        outputSchema: outputSchemas.generate,
+        annotations: writeRemote,
+        handler: (args, config) => api(config, "/api/v1/generate", {
+            method: "POST",
+            body: JSON.stringify(stripPresentationArgs(args)),
+        }),
+    },
+    {
+        name: "tday_poll_generation",
+        title: "Poll generation",
+        description: "Poll a design generation. Returns status (pending/ideating/generating/visualising/reviewing/refining/completed/failed), editorUrl, imageUrl when completed, and platformBadge when the image carries the Free plan's badge. Call repeatedly until status is completed or failed.",
+        inputSchema: argsObject({
+            designId: safeIdSchema.describe("Design ID from tday"),
+            generationId: safeIdSchema.describe("Generation ID from tday"),
+        }),
+        outputSchema: outputSchemas.poll,
+        annotations: { ...readOnly, idempotentHint: true },
+        handler: async (args, config) => {
+            const path = safePath("/api/designs/:designId/generate/:generationId/status?poll=1", args);
+            const data = await api(config, path);
+            const generation = data.complete?.generation;
+            const status = data.status ?? generation?.status ?? "unknown";
+            const imageUrl = firstImageUrl(generation);
+            return {
+                designId: args.designId,
+                generationId: args.generationId,
+                status,
+                editorUrl: `${config.webBaseUrl}/designs/${args.designId}`,
+                ...(imageUrl ? { imageUrl } : {}),
+                ...(generation?.completedAt ? { completedAt: generation.completedAt } : {}),
+                ...(data.platformBadge ? { platformBadge: true, badgeNote: PLATFORM_BADGE_NOTE } : {}),
+                ...(status === "failed"
+                    ? { failureMessage: data.complete?.message ?? "Generation did not complete." }
+                    : {}),
+            };
+        },
+    },
+    {
+        name: "tday_create_brand",
+        title: "Create brand",
+        description: "Create a new brand from a website URL. Extracts colors, fonts, and logos automatically from the site. You can also pass a name and description.",
+        inputSchema: argsObject({
+            website: z
+                .string()
+                .trim()
+                .min(1)
+                .max(2048)
+                .describe("Website URL to extract brand assets from, for example stripe.com or https://stripe.com"),
+            name: z.string().trim().min(1).max(200).optional().describe("Brand name, auto-detected from website if omitted"),
+            description: z.string().trim().min(1).max(1000).optional().describe("Short brand description"),
+            industry: z.string().trim().min(1).max(120).optional().describe("Industry category"),
+        }),
+        outputSchema: outputSchemas.createBrand,
+        annotations: writeRemote,
+        handler: (args, config) => {
+            const body = { website: normalizeWebsite(String(args.website)) };
+            if (args.name)
+                body.name = args.name;
+            if (args.description)
+                body.description = args.description;
+            if (args.industry)
+                body.industry = args.industry;
+            return api(config, "/api/brands", {
+                method: "POST",
+                body: JSON.stringify(body),
+            });
+        },
+    },
+    {
+        name: "tday_download_image",
+        title: "Download image",
+        description: "Download a completed generated design image to a local file. Pass designId + generationId to save the exported file (what a download from tday gives you), or an imageUrl to save that exact image. Writes only inside the current working directory and caps downloads at 50MB.",
+        inputSchema: argsObject({
+            imageUrl: z
+                .string()
+                .trim()
+                .url()
+                .optional()
+                .describe("Completed generation image URL. Optional if designId and generationId are provided."),
+            designId: safeIdSchema.optional().describe("Design ID from tday. Optional if imageUrl is provided."),
+            generationId: safeIdSchema.optional().describe("Generation ID from tday. Optional if imageUrl is provided."),
+            filePath: z
+                .string()
+                .trim()
+                .min(1)
+                .max(500)
+                .describe("Local path to save the image, relative to cwd, for example ./tday-designs/poster.png"),
+            overwrite: z
+                .boolean()
+                .default(false)
+                .describe("Whether to overwrite an existing regular file. Defaults to false for safety."),
+        }),
+        outputSchema: outputSchemas.download,
+        annotations: writeLocal,
+        handler: async (args, config) => {
+            const hasUrl = Boolean(args.imageUrl);
+            const hasIds = Boolean(args.designId && args.generationId);
+            if (!hasUrl && !hasIds) {
+                throw new Error("Provide either imageUrl, or both designId and generationId.");
+            }
+            if ((args.designId && !args.generationId) || (!args.designId && args.generationId)) {
+                throw new Error("designId and generationId must be provided together.");
+            }
+            const imageUrl = hasIds
+                ? await imageUrlForGeneration(args, config)
+                : String(args.imageUrl);
+            const url = validateImageUrl(imageUrl);
+            const filePath = await prepareOutputFilePath(String(args.filePath), {
+                overwrite: Boolean(args.overwrite),
+            });
+            const res = await fetch(url.href);
+            if (res.url)
+                validateImageUrl(res.url);
+            if (!res.ok) {
+                throw new Error(`Failed to download image: ${res.status} ${res.statusText}`);
+            }
+            const contentLength = Number(res.headers.get("content-length") ?? 0);
+            if (Number.isFinite(contentLength) && contentLength > MAX_IMAGE_BYTES) {
+                throw new Error(`Image exceeds ${MAX_IMAGE_BYTES / 1024 / 1024}MB limit according to content-length. Download aborted.`);
+            }
+            const contentType = res.headers.get("content-type");
+            if (contentType &&
+                !contentType.toLowerCase().startsWith("image/") &&
+                !contentType.toLowerCase().startsWith("application/octet-stream")) {
+                throw new Error(`Download did not return an image (content-type: ${contentType})`);
+            }
+            const chunks = [];
+            let totalBytes = 0;
+            const reader = res.body?.getReader();
+            if (!reader) {
+                throw new Error("No response body from image URL");
+            }
+            try {
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    totalBytes += value.byteLength;
+                    if (totalBytes > MAX_IMAGE_BYTES) {
+                        throw new Error(`Image exceeds ${MAX_IMAGE_BYTES / 1024 / 1024}MB limit. Download aborted.`);
+                    }
+                    chunks.push(value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            const buffer = Buffer.concat(chunks);
+            const flags = constants.O_WRONLY |
+                constants.O_CREAT |
+                (args.overwrite ? constants.O_TRUNC : constants.O_EXCL) |
+                (constants.O_NOFOLLOW ?? 0);
+            const handle = await open(filePath, flags, 0o600);
+            try {
+                await handle.writeFile(buffer);
+            }
+            finally {
+                await handle.close();
+            }
+            return {
+                saved: true,
+                path: filePath,
+                size: buffer.byteLength,
+            };
+        },
+    },
+    ...accountTools,
+    ...launchTools,
+    ...featureTools,
+];
+async function imageUrlForGeneration(args, config) {
+    const data = await api(config, safePath("/api/designs/:designId/generations/:generationId/export", args), { method: "POST", body: JSON.stringify({ scale: 1 }) });
+    const imageUrl = typeof data?.image?.url === "string" ? data.image.url : null;
+    if (!imageUrl) {
+        throw new Error("No image URL found for this generation. Poll tday_poll_generation until status is completed, then try again.");
+    }
+    return imageUrl;
+}
+function formatZodError(name, error) {
+    const details = error.issues
+        .map((issue) => {
+        const path = issue.path.length ? issue.path.join(".") : "arguments";
+        return `${path}: ${issue.message}`;
+    })
+        .join("; ");
+    return `Invalid arguments for ${name}: ${details}`;
+}
+export async function callTool(name, args, config, available = tools) {
+    const tool = available.find((t) => t.name === name);
+    if (!tool) {
+        throw new Error(`Unknown tool: ${name}. Available tools: ${available.map((t) => t.name).join(", ")}`);
+    }
+    const parsed = tool.inputSchema.safeParse(args);
+    if (!parsed.success)
+        throw new Error(formatZodError(tool.name, parsed.error));
+    return tool.handler(parsed.data, config);
+}