user-majico-mcp 0.7.5

package/dist/tools/constants.d.ts

@@ -0,0 +1,47 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare const MCP_SERVER_VERSION = "0.9.0";
+export declare const ASK_USER_PROJECT_SCOPE = " Before other tools: call ping, then ask the user whether to use an existing Majico project (list_projects) or create_project for this request; pass projectId on tool calls once confirmed.";
+export declare const MCP_AUTH_TOOL_DESCRIPTION = "Authenticate the Majico MCP server with OAuth in Cursor. If ping fails or any tool returns authRequired: true, stop and ask the user to Connect before other tools. Call this tool to get the exact user-facing prompt to display verbatim.";
+export declare function withBrandingAuthStep(tool: Tool): Tool;
+export declare const optionalCredentialProps: {
+    readonly projectId: {
+        readonly type: "string";
+        readonly description: "Majico project UUID (optional when connected via Cursor OAuth or env defaults)";
+    };
+    readonly apiKey: {
+        readonly type: "string";
+        readonly description: "Project API key (optional when connected via Cursor OAuth or env defaults)";
+    };
+};
+export declare const projectContextProps: {
+    readonly consumerRepo: {
+        readonly type: "string";
+        readonly description: "Consumer repo path or folder name (e.g. reeldemo-ableton) for relevance ranking. Defaults to MAJICO_CONSUMER_REPO or process.cwd().";
+    };
+    readonly requestContext: {
+        readonly type: "string";
+        readonly description: "Short summary of the user's request (product, task, audience) to rank the 3–5 most relevant projects by name and description.";
+    };
+};
+export declare function resolveProjectRelevanceContext(args?: Record<string, unknown>): {
+    consumerRepoPath: string;
+    requestContext: string | undefined;
+};
+export declare const stableBrandMarkdownProps: {
+    readonly productName: {
+        readonly type: "string";
+        readonly description: "Product or brand name";
+    };
+    readonly positioningConcept: {
+        readonly type: "string";
+        readonly description: "One-line positioning or concept statement";
+    };
+    readonly audience: {
+        readonly type: "string";
+        readonly description: "Primary audience or customer segment";
+    };
+    readonly tone: {
+        readonly type: "string";
+        readonly description: "Brand tone or voice guidelines";
+    };
+};

package/dist/tools/constants.js

@@ -0,0 +1,95 @@
+import { AUTH_FIRST_STEP } from "../auth-prompt.js";
+export const MCP_SERVER_VERSION = "0.9.0";
+export const ASK_USER_PROJECT_SCOPE = " Before other tools: call ping, then ask the user whether to use an existing Majico project (list_projects) or create_project for this request; pass projectId on tool calls once confirmed.";
+export const MCP_AUTH_TOOL_DESCRIPTION = "Authenticate the Majico MCP server with OAuth in Cursor. If ping fails or any tool returns authRequired: true, stop and ask the user to Connect before other tools. Call this tool to get the exact user-facing prompt to display verbatim.";
+const BRANDING_TOOL_NAMES = new Set([
+    "get_brand_profile",
+    "get_design_tokens",
+    "get_logo_svg",
+    "list_logo_candidates",
+    "select_logo",
+    "get_cursor_handoff",
+    "ack_cursor_handoff",
+    "get_guidelines",
+    "get_design_md",
+    "get_brand_md",
+    "get_ui_ux_skills",
+    "sync_cursor_skills",
+    "update_cursor_skill",
+    "get_studio_canvas",
+    "get_export_manifest",
+    "download_export_zip",
+    "submit_brief",
+    "list_palette_options",
+    "select_palette",
+    "update_studio_html_frame",
+    "generate_creative",
+    "refine_creative",
+    "push_design_tokens_to_figma",
+    "sync_project_assets_to_figma",
+    "import_repo",
+    "publish_landing_page",
+    "brand",
+    "tokens",
+    "logos",
+    "guidelines",
+    "design_md",
+    "studio",
+    "export_manifest",
+    "submit_brief",
+    "cursor_handoff",
+]);
+export function withBrandingAuthStep(tool) {
+    if (!BRANDING_TOOL_NAMES.has(tool.name))
+        return tool;
+    return {
+        ...tool,
+        description: AUTH_FIRST_STEP + tool.description,
+    };
+}
+export const optionalCredentialProps = {
+    projectId: {
+        type: "string",
+        description: "Majico project UUID (optional when connected via Cursor OAuth or env defaults)",
+    },
+    apiKey: {
+        type: "string",
+        description: "Project API key (optional when connected via Cursor OAuth or env defaults)",
+    },
+};
+export const projectContextProps = {
+    consumerRepo: {
+        type: "string",
+        description: "Consumer repo path or folder name (e.g. reeldemo-ableton) for relevance ranking. Defaults to MAJICO_CONSUMER_REPO or process.cwd().",
+    },
+    requestContext: {
+        type: "string",
+        description: "Short summary of the user's request (product, task, audience) to rank the 3–5 most relevant projects by name and description.",
+    },
+};
+export function resolveProjectRelevanceContext(args) {
+    return {
+        consumerRepoPath: args?.consumerRepo?.trim() ||
+            process.env.MAJICO_CONSUMER_REPO?.trim() ||
+            process.cwd(),
+        requestContext: args?.requestContext?.trim(),
+    };
+}
+export const stableBrandMarkdownProps = {
+    productName: {
+        type: "string",
+        description: "Product or brand name",
+    },
+    positioningConcept: {
+        type: "string",
+        description: "One-line positioning or concept statement",
+    },
+    audience: {
+        type: "string",
+        description: "Primary audience or customer segment",
+    },
+    tone: {
+        type: "string",
+        description: "Brand tone or voice guidelines",
+    },
+};

package/dist/tools/dispatch-branding-studio.d.ts

@@ -0,0 +1,5 @@
+import type { MajicoClient } from "@majico/sdk";
+import type { CredentialSource, ResolvedCredentials } from "../credentials.js";
+import type { PresentContext } from "../present-interactive.js";
+import { type ToolCallResult } from "./tool-call-helpers.js";
+export declare function dispatchBrandingStudioTool(name: string, args: Record<string, unknown> | undefined, client: MajicoClient, creds: ResolvedCredentials, ctx: PresentContext, defaultCredentials?: CredentialSource): Promise<ToolCallResult | null>;

package/dist/tools/dispatch-branding-studio.js

@@ -0,0 +1,197 @@
+import { presentCursorHandoff, presentLogoCandidates, presentPaletteOptions, } from "../present-interactive.js";
+import { buildProjectSelectionFields, PROJECT_SELECTION_HINT, } from "../project-selection.js";
+import { pickRelevantProjects } from "../project-relevance.js";
+import { inferRepoNameHints } from "../project-selection-hints.js";
+import { validateUserPickGate } from "../user-pick-policy.js";
+import { MCP_SERVER_VERSION, resolveProjectRelevanceContext, } from "./constants.js";
+import { toolError, toolJson, toolPresent, requireStringArg, } from "./tool-call-helpers.js";
+export async function dispatchBrandingStudioTool(name, args, client, creds, ctx, defaultCredentials) {
+    switch (name) {
+        case "ping":
+        case "health": {
+            const ping = await client.projects.ping();
+            const list = await client.projects.list();
+            const explicitProjectId = args?.projectId;
+            const relevanceContext = resolveProjectRelevanceContext(args);
+            const selection = buildProjectSelectionFields({
+                projects: list.projects,
+                activeProjectId: creds.projectId,
+                activeProjectName: ping.projectName,
+                explicitProjectId,
+                consumerRepoPath: relevanceContext.consumerRepoPath,
+                requestContext: relevanceContext.requestContext,
+            });
+            return toolJson({
+                ok: true,
+                auth: defaultCredentials?.auth ?? "api_key",
+                userId: defaultCredentials?.userId ?? ping.userId,
+                projectId: creds.projectId,
+                projectName: ping.projectName,
+                hasBrandData: ping.hasBrandData,
+                hasCanvasData: ping.hasCanvasData,
+                previewToken: ping.previewToken ?? null,
+                previewPickerUrl: ping.previewPickerUrl ?? null,
+                baseUrl: creds.baseUrl,
+                serverVersion: MCP_SERVER_VERSION,
+                ...(selection ?? {}),
+            });
+        }
+        case "list_projects": {
+            const list = await client.projects.list();
+            const relevantProjects = pickRelevantProjects(list.projects, resolveProjectRelevanceContext(args));
+            return toolJson({
+                ...list,
+                relevantProjects,
+                totalProjectCount: list.projects.length,
+                hint: PROJECT_SELECTION_HINT,
+            });
+        }
+        case "create_project": {
+            const projectName = requireStringArg(args, "name");
+            if (!projectName)
+                return toolError("name is required.");
+            return toolJson(await client.projects.create(projectName));
+        }
+        case "brand":
+        case "get_brand_profile":
+            return toolJson(await client.brand.get());
+        case "tokens":
+        case "get_design_tokens":
+            return toolJson(await client.tokens.get());
+        case "get_logo_svg":
+            return toolJson(await client.logo.get());
+        case "logos":
+        case "list_logo_candidates":
+            return toolPresent(await presentLogoCandidates(await client.logo.listCandidates(args?.flowId), ctx));
+        case "select_logo": {
+            const pickError = validateUserPickGate({
+                userConfirmed: args?.userConfirmed === true,
+                userDelegatedPick: args?.userDelegatedPick === true,
+            }, "select_logo");
+            if (pickError)
+                return toolError(pickError);
+            return toolJson(await client.logo.select({
+                candidateId: args?.candidateId,
+                templateId: args?.templateId,
+                svg: args?.svg,
+                flowId: args?.flowId,
+            }));
+        }
+        case "cursor_handoff":
+        case "get_cursor_handoff":
+            return toolPresent(presentCursorHandoff(await client.cursorHandoff.get()));
+        case "ack_cursor_handoff": {
+            const handoffId = args?.handoffId;
+            if (!handoffId?.trim())
+                return toolError("handoffId is required.");
+            return toolJson(await client.cursorHandoff.ack(handoffId.trim()));
+        }
+        case "guidelines":
+        case "get_guidelines":
+            return toolJson(await client.guidelines.get());
+        case "design_md":
+        case "get_design_md":
+            return toolJson(await client.designMd.get());
+        case "get_brand_md":
+            return toolJson(await client.brandMd.get());
+        case "sync_cursor_skills":
+            return toolJson(await client.cursorSkills.syncInstallManifest());
+        case "update_cursor_skill": {
+            const skillSlug = requireStringArg(args, "skillSlug");
+            if (!skillSlug)
+                return toolError("skillSlug is required.");
+            return toolJson(await client.cursorSkills.update({
+                skillSlug,
+                name: args?.name,
+                description: args?.description,
+                bodyMd: args?.bodyMd,
+                phase: args?.phase,
+                priority: typeof args?.priority === "number" ? args.priority : undefined,
+                enabled: typeof args?.enabled === "boolean" ? args.enabled : undefined,
+            }));
+        }
+        case "studio":
+        case "get_studio_canvas":
+            return toolJson(await client.studio.get());
+        case "export_manifest":
+        case "get_export_manifest":
+            return toolJson(await client.export.getManifest());
+        case "download_export_zip": {
+            const buffer = await client.export.downloadZip();
+            const bytes = Buffer.from(buffer);
+            const manifest = await client.export.getManifest().catch(() => null);
+            const slug = manifest?.productName?.replace(/[^a-z0-9]+/gi, "-").toLowerCase() ||
+                "brand";
+            return toolJson({
+                filename: `${slug}-brand-export.zip`,
+                sizeBytes: bytes.length,
+                base64: bytes.toString("base64"),
+                manifest: manifest ?? undefined,
+                agentInstructions: "Decode base64 and write the ZIP to disk, or extract BRAND.md, DESIGN.md, and tokens/ into the consumer repo.",
+            });
+        }
+        case "submit_brief": {
+            const productName = args?.productName;
+            const oneLiner = args?.oneLiner;
+            if (!productName?.trim() || !oneLiner?.trim()) {
+                return toolError("productName and oneLiner are required.");
+            }
+            return toolJson(await client.brief.submit({
+                productName: productName.trim(),
+                oneLiner: oneLiner.trim(),
+                audience: args?.audience,
+                nicheKeywords: args?.nicheKeywords,
+                goals: args?.goals,
+                constraints: args?.constraints,
+                marketRealityScan: args?.marketRealityScan === true,
+                operatingMode: args?.operatingMode,
+            }));
+        }
+        case "update_studio_html_frame": {
+            const elementId = args?.elementId;
+            const html = args?.html;
+            if (!elementId?.trim() || typeof html !== "string") {
+                return toolError("elementId and html are required.");
+            }
+            return toolJson(await client.studio.patchHtmlFrame({
+                elementId: elementId.trim(),
+                html,
+            }));
+        }
+        case "generate_creative":
+            return toolJson(await client.creative.generate({
+                slotId: args?.slotId,
+                prompt: args?.prompt,
+                slots: args?.slots,
+            }));
+        case "refine_creative":
+            return toolJson(await client.creative.refine({
+                slotId: args?.slotId,
+                refinePrompt: args?.refinePrompt,
+                prompt: args?.prompt,
+            }));
+        case "list_palette_options": {
+            const consumerRepoPath = args?.consumerRepo?.trim() ||
+                process.env.MAJICO_CONSUMER_REPO?.trim() ||
+                process.cwd();
+            return toolPresent(await presentPaletteOptions(await client.palette.listCandidates(), {
+                ...ctx,
+                repoHints: inferRepoNameHints(consumerRepoPath),
+            }));
+        }
+        case "select_palette": {
+            const optionId = args?.optionId;
+            if (!optionId?.trim())
+                return toolError("optionId is required.");
+            const pickError = validateUserPickGate({
+                userConfirmed: args?.userConfirmed === true,
+                userDelegatedPick: args?.userDelegatedPick === true,
+            }, "select_palette");
+            if (pickError)
+                return toolError(pickError);
+            return toolJson(await client.palette.select({ optionId: optionId.trim() }));
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/dispatch-pulse-blog.d.ts

@@ -0,0 +1,3 @@
+import type { MajicoClient } from "@majico/sdk";
+import { type ToolCallResult } from "./tool-call-helpers.js";
+export declare function dispatchPulseBlogTool(name: string, args: Record<string, unknown> | undefined, client: MajicoClient): Promise<ToolCallResult | null>;

package/dist/tools/dispatch-pulse-blog.js

@@ -0,0 +1,158 @@
+import { presentTweetDrafts, } from "../present-interactive.js";
+import { toolError, toolJson, toolPresent, } from "./tool-call-helpers.js";
+export async function dispatchPulseBlogTool(name, args, client) {
+    switch (name) {
+        case "get_pulse_status":
+            return toolJson(await client.pulse.getStatus());
+        case "generate_tweet_drafts":
+            return toolPresent(presentTweetDrafts(await client.pulse.generateTweetDrafts({
+                prompt: args?.prompt,
+            })));
+        case "select_tweet_draft": {
+            const draftId = args?.draftId;
+            const text = args?.text;
+            if (!draftId?.trim() || !text?.trim()) {
+                return toolError("draftId and text are required.");
+            }
+            return toolJson(await client.pulse.selectTweetDraft({
+                draftId: draftId.trim(),
+                text: text.trim(),
+            }));
+        }
+        case "list_pulse_posts":
+            return toolJson(await client.pulse.listPosts({
+                sort: args?.sort,
+                limit: typeof args?.limit === "number" ? args.limit : undefined,
+            }));
+        case "list_calendar_slots":
+            return toolJson(await client.pulse.listCalendarSlots({
+                limit: typeof args?.limit === "number" ? args.limit : undefined,
+                platform: args?.platform,
+            }));
+        case "generate_post_variants": {
+            const slotId = args?.slotId;
+            if (!slotId?.trim())
+                return toolError("slotId is required.");
+            return toolJson(await client.pulse.generatePostVariants({
+                slotId: slotId.trim(),
+                prompt: args?.prompt,
+            }));
+        }
+        case "select_post_variant": {
+            const slotId = args?.slotId;
+            const variantId = args?.variantId;
+            if (!slotId?.trim() || !variantId?.trim()) {
+                return toolError("slotId and variantId are required.");
+            }
+            return toolJson(await client.pulse.selectPostVariant({
+                slotId: slotId.trim(),
+                variantId: variantId.trim(),
+            }));
+        }
+        case "approve_publish_slot": {
+            const slotId = args?.slotId;
+            if (!slotId?.trim())
+                return toolError("slotId is required.");
+            return toolJson(await client.pulse.approvePublishSlot({ slotId: slotId.trim() }));
+        }
+        case "schedule_publish_slot": {
+            const slotId = args?.slotId;
+            const scheduledAt = args?.scheduledAt;
+            if (!slotId?.trim() || !scheduledAt?.trim()) {
+                return toolError("slotId and scheduledAt are required.");
+            }
+            return toolJson(await client.pulse.schedulePublishSlot({
+                slotId: slotId.trim(),
+                scheduledAt: scheduledAt.trim(),
+            }));
+        }
+        case "get_performance_insights":
+            return toolJson(await client.pulse.getPerformanceInsights());
+        case "get_product_ops_view":
+            return toolJson(await client.pulse.getProductOpsView());
+        case "list_blog_posts":
+            return toolJson(await client.blog.listPosts({
+                limit: typeof args?.limit === "number" ? args.limit : undefined,
+            }));
+        case "get_blog_post": {
+            const postId = args?.postId;
+            if (!postId?.trim())
+                return toolError("postId is required.");
+            return toolJson(await client.blog.getPost(postId.trim()));
+        }
+        case "get_blog_seo_handoff": {
+            return toolJson(await client.blog.seoHandoff({
+                postId: args?.postId?.trim() || undefined,
+            }));
+        }
+        case "suggest_blog_opportunities":
+            return toolJson(await client.blog.suggestOpportunities());
+        case "run_blog_research": {
+            const concept = args?.concept;
+            if (!concept || typeof concept !== "object") {
+                return toolError("concept object is required.");
+            }
+            return toolJson(await client.blog.runResearch({
+                concept: concept,
+                articleType: args?.articleType,
+                postId: args?.postId,
+            }));
+        }
+        case "generate_blog_outline": {
+            const concept = args?.concept;
+            const dossier = args?.dossier;
+            if (!concept || typeof concept !== "object") {
+                return toolError("concept object is required.");
+            }
+            if (!dossier || typeof dossier !== "object") {
+                return toolError("dossier object is required.");
+            }
+            return toolJson(await client.blog.generateOutline({
+                concept: concept,
+                dossier: dossier,
+                articleType: args?.articleType,
+                postId: args?.postId,
+            }));
+        }
+        case "approve_blog_outline": {
+            const postId = args?.postId;
+            if (!postId?.trim())
+                return toolError("postId is required.");
+            return toolJson(await client.blog.approveOutline({ postId: postId.trim() }));
+        }
+        case "generate_blog_section": {
+            const postId = args?.postId;
+            const sectionId = args?.sectionId;
+            if (!postId?.trim() || !sectionId?.trim()) {
+                return toolError("postId and sectionId are required.");
+            }
+            return toolJson(await client.blog.generateSection({
+                postId: postId.trim(),
+                sectionId: sectionId.trim(),
+                approve: args?.approve === true,
+            }));
+        }
+        case "assemble_blog_post": {
+            const postId = args?.postId;
+            if (!postId?.trim())
+                return toolError("postId is required.");
+            return toolJson(await client.blog.assemble({
+                postId: postId.trim(),
+                skipSeoGate: args?.skipSeoGate === true,
+            }));
+        }
+        case "publish_blog_post": {
+            const postId = args?.postId;
+            if (!postId?.trim())
+                return toolError("postId is required.");
+            const scope = args?.scope;
+            return toolJson(await client.blog.publish({
+                postId: postId.trim(),
+                scope: scope === "platform" || scope === "project" ? scope : undefined,
+                force: args?.force === true,
+            }));
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/dispatch-research-assets.d.ts

@@ -0,0 +1,3 @@
+import type { MajicoClient } from "@majico/sdk";
+import { type ToolCallResult } from "./tool-call-helpers.js";
+export declare function dispatchResearchAssetsTool(name: string, args: Record<string, unknown> | undefined, client: MajicoClient): Promise<ToolCallResult | null>;

package/dist/tools/dispatch-research-assets.js

@@ -0,0 +1,132 @@
+import { toolError, toolJson, } from "./tool-call-helpers.js";
+export async function dispatchResearchAssetsTool(name, args, client) {
+    switch (name) {
+        case "push_design_tokens_to_figma":
+            return toolJson(await client.figma.pushDesignTokens({
+                fileKey: args?.fileKey,
+            }));
+        case "sync_project_assets_to_figma":
+            return toolJson(await client.figma.syncProjectAssets({
+                fileKey: args?.fileKey,
+            }));
+        case "import_repo": {
+            const owner = args?.owner;
+            const repo = args?.repo;
+            if (!owner?.trim() || !repo?.trim()) {
+                return toolError("owner and repo are required.");
+            }
+            return toolJson(await client.git.importRepo({
+                owner: owner.trim(),
+                repo: repo.trim(),
+                ref: args?.ref,
+                provider: args?.provider,
+            }));
+        }
+        case "publish_landing_page":
+            return toolJson(await client.git.publishLandingPage({
+                target: args?.target,
+                provider: args?.provider,
+                elementId: args?.elementId,
+                html: args?.html,
+                owner: args?.owner,
+                repo: args?.repo,
+                branch: args?.branch,
+                orgLandingPath: args?.orgLandingPath,
+            }));
+        case "run_niche_research":
+            return toolJson(await client.research.runNicheResearch({
+                brief: args?.brief,
+                marketScan: typeof args?.marketScan === "boolean" ? args.marketScan : undefined,
+                sourceFlowId: args?.sourceFlowId,
+            }));
+        case "run_market_scan":
+            return toolJson(await client.research.runMarketScan({
+                keywords: args?.keywords,
+                productName: args?.productName,
+                oneLiner: args?.oneLiner,
+                audience: args?.audience,
+            }));
+        case "web_search": {
+            const query = args?.query;
+            if (!query?.trim())
+                return toolError("query is required.");
+            return toolJson(await client.research.webSearch({
+                query: query.trim(),
+                limit: typeof args?.limit === "number" ? args.limit : undefined,
+            }));
+        }
+        case "run_asset_research": {
+            const skillId = args?.skillId;
+            if (!skillId?.trim())
+                return toolError("skillId is required.");
+            return toolJson(await client.research.runAssetResearch({
+                skillId: skillId.trim(),
+                context: args?.context,
+                refresh: args?.refresh,
+            }));
+        }
+        case "generate_asset": {
+            const skillId = args?.skillId;
+            if (!skillId?.trim())
+                return toolError("skillId is required.");
+            return toolJson(await client.assets.generate({
+                skillId: skillId.trim(),
+                elementId: args?.elementId,
+                flowGroupId: args?.flowGroupId,
+                params: args?.params,
+                context: args?.context,
+                forceResearchRefresh: args?.forceResearchRefresh === true,
+            }));
+        }
+        case "patch_investor_ask_slide": {
+            const raiseAmount = args?.raiseAmount;
+            const useOfFunds = args?.useOfFunds;
+            if (!raiseAmount?.trim())
+                return toolError("raiseAmount is required.");
+            if (!Array.isArray(useOfFunds) || useOfFunds.length === 0) {
+                return toolError("useOfFunds is required.");
+            }
+            return toolJson(await client.assets.patchInvestorAskSlide({
+                raiseAmount: raiseAmount.trim(),
+                useOfFunds,
+                deckElementId: args?.deckElementId,
+                headline: args?.headline,
+            }));
+        }
+        case "get_asset_status": {
+            const jobId = args?.jobId;
+            if (!jobId?.trim())
+                return toolError("jobId is required.");
+            return toolJson(await client.assets.getStatus({ jobId: jobId.trim() }));
+        }
+        case "list_project_assets":
+            return toolJson(await client.assets.list({
+                skillId: args?.skillId,
+                limit: typeof args?.limit === "number" ? args.limit : undefined,
+            }));
+        case "quiver_generate_svg": {
+            const prompt = args?.prompt;
+            if (!prompt?.trim())
+                return toolError("prompt is required.");
+            return toolJson(await client.quiver.generateSvg({
+                prompt: prompt.trim(),
+                model: args?.model,
+                n: typeof args?.n === "number" ? args.n : undefined,
+                instructions: args?.instructions,
+            }));
+        }
+        case "quiver_vectorize_svg": {
+            const imageBase64 = args?.imageBase64;
+            if (!imageBase64?.trim())
+                return toolError("imageBase64 is required.");
+            return toolJson(await client.quiver.vectorizeSvg({
+                imageBase64: imageBase64.trim(),
+                model: args?.model,
+                autoCrop: args?.autoCrop === true,
+                targetSize: typeof args?.targetSize === "number" ? args.targetSize : undefined,
+            }));
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/handle-tool-call-pre.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialSource } from "../credentials.js";
+import { type ToolCallResult } from "./tool-call-helpers.js";
+/** Pre-client tools and plan gate checks. */
+export declare function handlePreClientToolCall(name: string, args: Record<string, unknown> | undefined, defaultCredentials?: CredentialSource): Promise<ToolCallResult | null>;