@meshy-ai/meshy-mcp-server 0.2.0

package/dist/schemas/output.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Output schemas for MCP structured content.
+ * These define the shape of structuredContent returned by tools.
+ */
+import { z } from "zod";
+/**
+ * Output schema for task creation tools (text-to-3d, image-to-3d, remesh, etc.)
+ */
+export declare const TaskCreatedOutputSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    status: z.ZodString;
+    message: z.ZodString;
+    estimated_time: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    status: string;
+    task_id: string;
+    estimated_time: string;
+}, {
+    message: string;
+    status: string;
+    task_id: string;
+    estimated_time: string;
+}>;
+/**
+ * Output schema for meshy_check_balance
+ */
+export declare const BalanceOutputSchema: z.ZodObject<{
+    balance: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    balance: number;
+}, {
+    balance: number;
+}>;
+/**
+ * Output schema for meshy_get_task_status
+ * Covers all outcomes: SUCCEEDED, FAILED, CANCELED, TIMEOUT, IN_PROGRESS, PENDING
+ */
+export declare const TaskStatusOutputSchema: z.ZodObject<{
+    outcome: z.ZodEnum<["SUCCEEDED", "FAILED", "CANCELED", "TIMEOUT", "IN_PROGRESS", "PENDING"]>;
+    task_id: z.ZodString;
+    status: z.ZodString;
+    progress: z.ZodNumber;
+    wait_time_seconds: z.ZodOptional<z.ZodNumber>;
+    poll_count: z.ZodOptional<z.ZodNumber>;
+    model_urls: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    vertex_count: z.ZodOptional<z.ZodNumber>;
+    face_count: z.ZodOptional<z.ZodNumber>;
+    error_code: z.ZodOptional<z.ZodString>;
+    error_message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    task_id: string;
+    outcome: "PENDING" | "IN_PROGRESS" | "SUCCEEDED" | "FAILED" | "CANCELED" | "TIMEOUT";
+    progress: number;
+    wait_time_seconds?: number | undefined;
+    poll_count?: number | undefined;
+    model_urls?: Record<string, string> | undefined;
+    vertex_count?: number | undefined;
+    face_count?: number | undefined;
+    error_code?: string | undefined;
+    error_message?: string | undefined;
+}, {
+    status: string;
+    task_id: string;
+    outcome: "PENDING" | "IN_PROGRESS" | "SUCCEEDED" | "FAILED" | "CANCELED" | "TIMEOUT";
+    progress: number;
+    wait_time_seconds?: number | undefined;
+    poll_count?: number | undefined;
+    model_urls?: Record<string, string> | undefined;
+    vertex_count?: number | undefined;
+    face_count?: number | undefined;
+    error_code?: string | undefined;
+    error_message?: string | undefined;
+}>;

package/dist/schemas/output.js

@@ -0,0 +1,41 @@
+/**
+ * Output schemas for MCP structured content.
+ * These define the shape of structuredContent returned by tools.
+ */
+import { z } from "zod";
+/**
+ * Output schema for task creation tools (text-to-3d, image-to-3d, remesh, etc.)
+ */
+export const TaskCreatedOutputSchema = z.object({
+    task_id: z.string().describe("Unique task identifier for polling with meshy_get_task_status"),
+    status: z.string().describe("Initial task status (typically 'PENDING')"),
+    message: z.string().describe("Human-readable status message"),
+    estimated_time: z.string().describe("Estimated completion time")
+});
+/**
+ * Output schema for meshy_check_balance
+ */
+export const BalanceOutputSchema = z.object({
+    balance: z.number().describe("Current credit balance")
+});
+/**
+ * Output schema for meshy_get_task_status
+ * Covers all outcomes: SUCCEEDED, FAILED, CANCELED, TIMEOUT, IN_PROGRESS, PENDING
+ */
+export const TaskStatusOutputSchema = z.object({
+    outcome: z.enum(["SUCCEEDED", "FAILED", "CANCELED", "TIMEOUT", "IN_PROGRESS", "PENDING"])
+        .describe("Final outcome of the status check"),
+    task_id: z.string().describe("Task identifier"),
+    status: z.string().describe("Current task status from the API"),
+    progress: z.number().describe("Progress percentage (0-100)"),
+    // wait mode fields
+    wait_time_seconds: z.number().optional().describe("Total wait time in seconds (wait mode only)"),
+    poll_count: z.number().optional().describe("Number of polls performed (wait mode only)"),
+    // success fields
+    model_urls: z.record(z.string()).optional().describe("Available model download URLs"),
+    vertex_count: z.number().optional().describe("Number of vertices in the model"),
+    face_count: z.number().optional().describe("Number of faces in the model"),
+    // error fields
+    error_code: z.string().optional().describe("Error code if task failed"),
+    error_message: z.string().optional().describe("Error message if task failed")
+});

package/dist/schemas/postprocessing.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Zod schemas for post-processing tools (remesh, retexture, rig, animate)
+ */
+import { z } from "zod";
+import { AIModel, OriginAt, Topology, AnimationPostProcessOp } from "../constants.js";
+/**
+ * Remesh input schema
+ */
+export declare const RemeshInputSchema: z.ZodObject<{
+    input_task_id: z.ZodOptional<z.ZodString>;
+    model_url: z.ZodOptional<z.ZodString>;
+    target_formats: z.ZodDefault<z.ZodArray<z.ZodEnum<["glb", "fbx", "obj", "usdz", "blend", "stl", "3mf"]>, "many">>;
+    topology: z.ZodOptional<z.ZodNativeEnum<typeof Topology>>;
+    target_polycount: z.ZodOptional<z.ZodNumber>;
+    resize_height: z.ZodDefault<z.ZodNumber>;
+    auto_size: z.ZodOptional<z.ZodBoolean>;
+    origin_at: z.ZodOptional<z.ZodNativeEnum<typeof OriginAt>>;
+    convert_format_only: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+}, "strict", z.ZodTypeAny, {
+    target_formats: ("glb" | "fbx" | "usdz" | "3mf" | "obj" | "blend" | "stl")[];
+    response_format: import("../constants.js").ResponseFormat;
+    resize_height: number;
+    convert_format_only: boolean;
+    topology?: Topology | undefined;
+    target_polycount?: number | undefined;
+    auto_size?: boolean | undefined;
+    origin_at?: OriginAt | undefined;
+    input_task_id?: string | undefined;
+    model_url?: string | undefined;
+}, {
+    topology?: Topology | undefined;
+    target_polycount?: number | undefined;
+    target_formats?: ("glb" | "fbx" | "usdz" | "3mf" | "obj" | "blend" | "stl")[] | undefined;
+    auto_size?: boolean | undefined;
+    origin_at?: OriginAt | undefined;
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    input_task_id?: string | undefined;
+    model_url?: string | undefined;
+    resize_height?: number | undefined;
+    convert_format_only?: boolean | undefined;
+}>;
+/**
+ * Retexture input schema
+ */
+export declare const RetextureInputSchema: z.ZodObject<{
+    input_task_id: z.ZodOptional<z.ZodString>;
+    model_url: z.ZodOptional<z.ZodString>;
+    text_style_prompt: z.ZodOptional<z.ZodString>;
+    image_style_url: z.ZodOptional<z.ZodString>;
+    ai_model: z.ZodDefault<z.ZodNativeEnum<typeof AIModel>>;
+    enable_original_uv: z.ZodDefault<z.ZodBoolean>;
+    enable_pbr: z.ZodDefault<z.ZodBoolean>;
+    remove_lighting: z.ZodDefault<z.ZodBoolean>;
+    target_formats: z.ZodOptional<z.ZodArray<z.ZodEnum<["glb", "obj", "fbx", "stl", "usdz", "3mf"]>, "many">>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+}, "strict", z.ZodTypeAny, {
+    ai_model: AIModel;
+    response_format: import("../constants.js").ResponseFormat;
+    enable_pbr: boolean;
+    remove_lighting: boolean;
+    enable_original_uv: boolean;
+    target_formats?: ("glb" | "fbx" | "usdz" | "3mf" | "obj" | "stl")[] | undefined;
+    input_task_id?: string | undefined;
+    model_url?: string | undefined;
+    text_style_prompt?: string | undefined;
+    image_style_url?: string | undefined;
+}, {
+    ai_model?: AIModel | undefined;
+    target_formats?: ("glb" | "fbx" | "usdz" | "3mf" | "obj" | "stl")[] | undefined;
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    enable_pbr?: boolean | undefined;
+    remove_lighting?: boolean | undefined;
+    input_task_id?: string | undefined;
+    model_url?: string | undefined;
+    text_style_prompt?: string | undefined;
+    image_style_url?: string | undefined;
+    enable_original_uv?: boolean | undefined;
+}>;
+/**
+ * Rig (rigging) input schema
+ */
+export declare const RigInputSchema: z.ZodObject<{
+    input_task_id: z.ZodOptional<z.ZodString>;
+    model_url: z.ZodOptional<z.ZodString>;
+    height_meters: z.ZodDefault<z.ZodNumber>;
+    texture_image_url: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+}, "strict", z.ZodTypeAny, {
+    response_format: import("../constants.js").ResponseFormat;
+    height_meters: number;
+    texture_image_url?: string | undefined;
+    input_task_id?: string | undefined;
+    model_url?: string | undefined;
+}, {
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    texture_image_url?: string | undefined;
+    input_task_id?: string | undefined;
+    model_url?: string | undefined;
+    height_meters?: number | undefined;
+}>;
+/**
+ * Animate input schema
+ */
+export declare const AnimateInputSchema: z.ZodObject<{
+    rig_task_id: z.ZodString;
+    action_id: z.ZodNumber;
+    post_process: z.ZodOptional<z.ZodObject<{
+        operation_type: z.ZodNativeEnum<typeof AnimationPostProcessOp>;
+        fps: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<24>, z.ZodLiteral<25>, z.ZodLiteral<30>, z.ZodLiteral<60>]>>;
+    }, "strip", z.ZodTypeAny, {
+        operation_type: AnimationPostProcessOp;
+        fps?: 30 | 24 | 60 | 25 | undefined;
+    }, {
+        operation_type: AnimationPostProcessOp;
+        fps?: 30 | 24 | 60 | 25 | undefined;
+    }>>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+}, "strict", z.ZodTypeAny, {
+    response_format: import("../constants.js").ResponseFormat;
+    rig_task_id: string;
+    action_id: number;
+    post_process?: {
+        operation_type: AnimationPostProcessOp;
+        fps?: 30 | 24 | 60 | 25 | undefined;
+    } | undefined;
+}, {
+    rig_task_id: string;
+    action_id: number;
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    post_process?: {
+        operation_type: AnimationPostProcessOp;
+        fps?: 30 | 24 | 60 | 25 | undefined;
+    } | undefined;
+}>;

package/dist/schemas/postprocessing.js

@@ -0,0 +1,123 @@
+/**
+ * Zod schemas for post-processing tools (remesh, retexture, rig, animate)
+ */
+import { z } from "zod";
+import { AIModel, OriginAt, Topology, AnimationPostProcessOp } from "../constants.js";
+import { ResponseFormatSchema, UrlSchema } from "./common.js";
+/**
+ * Remesh input schema
+ */
+export const RemeshInputSchema = z.object({
+    input_task_id: z.string()
+        .min(1)
+        .optional()
+        .describe("Task ID of an existing completed task to remesh"),
+    model_url: UrlSchema
+        .optional()
+        .describe("Direct URL to a model file to remesh"),
+    target_formats: z.array(z.enum(["glb", "fbx", "obj", "usdz", "blend", "stl", "3mf"]))
+        .default(["glb"])
+        .describe("Output formats to generate (default: ['glb']). NOTE: 3MF is NOT included by default — you MUST explicitly include '3mf' to receive it."),
+    topology: z.nativeEnum(Topology)
+        .optional()
+        .describe("Mesh topology type (quad or triangle)"),
+    target_polycount: z.number()
+        .int()
+        .min(100, "Polycount must be at least 100")
+        .max(300000, "Polycount cannot exceed 300,000")
+        .optional()
+        .describe("Target polygon count for the remeshed model (100–300,000)"),
+    resize_height: z.number()
+        .default(0)
+        .describe("Resize model to this height in meters (0 = no resize). Mutually exclusive with auto_size."),
+    auto_size: z.boolean()
+        .optional()
+        .describe("Use AI to auto-estimate real-world height. Mutually exclusive with resize_height. Default false."),
+    origin_at: z.nativeEnum(OriginAt)
+        .optional()
+        .describe("Where to place the model origin: 'bottom' or 'center'. Default 'bottom' when auto_size is true."),
+    convert_format_only: z.boolean()
+        .default(false)
+        .describe("Only convert format without remeshing"),
+    response_format: ResponseFormatSchema
+}).strict();
+/**
+ * Retexture input schema
+ */
+export const RetextureInputSchema = z.object({
+    input_task_id: z.string()
+        .min(1)
+        .optional()
+        .describe("Task ID of an existing completed task to retexture"),
+    model_url: UrlSchema
+        .optional()
+        .describe("Direct URL to a model file to retexture"),
+    text_style_prompt: z.string()
+        .max(600, "Prompt must not exceed 600 characters")
+        .optional()
+        .describe("Text prompt describing the desired texture style. Max 600 characters"),
+    image_style_url: UrlSchema
+        .optional()
+        .describe("URL of an image to use as texture style reference"),
+    ai_model: z.nativeEnum(AIModel)
+        .default(AIModel.LATEST)
+        .describe("AI model: 'meshy-5', 'meshy-6', or 'latest' (default, currently resolves to Meshy 6). IMPORTANT: Before calling this tool, ask the user which model to use and explain the differences: meshy-6/latest = best quality (10 credits), meshy-5 = previous gen (10 credits)"),
+    enable_original_uv: z.boolean()
+        .default(true)
+        .describe("Preserve the original UV mapping"),
+    enable_pbr: z.boolean()
+        .default(false)
+        .describe("Enable physically-based rendering textures"),
+    remove_lighting: z.boolean()
+        .default(true)
+        .describe("Removes highlights and shadows from the base color texture for cleaner results under custom lighting. Default true. Only supported when ai_model is meshy-6 or latest"),
+    target_formats: z.array(z.enum(["glb", "obj", "fbx", "stl", "usdz", "3mf"]))
+        .optional()
+        .describe("Output formats to generate. When omitted, produces glb/obj/fbx/stl/usdz but NOT 3mf. To get 3MF, you MUST include '3mf' explicitly."),
+    response_format: ResponseFormatSchema
+}).strict();
+/**
+ * Rig (rigging) input schema
+ */
+export const RigInputSchema = z.object({
+    input_task_id: z.string()
+        .min(1)
+        .optional()
+        .describe("Task ID of an existing completed task to rig"),
+    model_url: UrlSchema
+        .optional()
+        .describe("Direct URL to a model file to rig"),
+    height_meters: z.number()
+        .default(1.7)
+        .describe("Height of the character in meters (default: 1.7)"),
+    texture_image_url: UrlSchema
+        .optional()
+        .describe("URL of a texture image to apply to the model"),
+    response_format: ResponseFormatSchema
+}).strict();
+/**
+ * Animate input schema
+ */
+export const AnimateInputSchema = z.object({
+    rig_task_id: z.string()
+        .min(1, "Rig task ID is required")
+        .describe("Task ID of the completed rigging task to animate"),
+    action_id: z.number()
+        .int("Action ID must be an integer")
+        .describe("ID of the animation action to apply"),
+    post_process: z.object({
+        operation_type: z.nativeEnum(AnimationPostProcessOp)
+            .describe("Post-processing operation to apply"),
+        fps: z.union([
+            z.literal(24),
+            z.literal(25),
+            z.literal(30),
+            z.literal(60)
+        ])
+            .optional()
+            .describe("Target FPS for change_fps operation")
+    })
+        .optional()
+        .describe("Optional post-processing to apply after animation"),
+    response_format: ResponseFormatSchema
+}).strict();

package/dist/schemas/printing.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Zod schemas for 3D printing tools
+ */
+import { z } from "zod";
+/**
+ * Send to slicer input schema
+ * Detects installed slicers and returns launch commands.
+ */
+export declare const SendToSlicerInputSchema: z.ZodObject<{
+    model_url: z.ZodString;
+    slicer_type: z.ZodDefault<z.ZodEnum<["auto", "bambu", "orcaslicer", "creality_print", "elegoo_slicer", "anycubic_slicer", "prusaslicer", "cura"]>>;
+    file_name: z.ZodDefault<z.ZodString>;
+    is_multicolor: z.ZodDefault<z.ZodBoolean>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+}, "strict", z.ZodTypeAny, {
+    response_format: import("../constants.js").ResponseFormat;
+    model_url: string;
+    slicer_type: "auto" | "bambu" | "orcaslicer" | "creality_print" | "elegoo_slicer" | "anycubic_slicer" | "prusaslicer" | "cura";
+    file_name: string;
+    is_multicolor: boolean;
+}, {
+    model_url: string;
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    slicer_type?: "auto" | "bambu" | "orcaslicer" | "creality_print" | "elegoo_slicer" | "anycubic_slicer" | "prusaslicer" | "cura" | undefined;
+    file_name?: string | undefined;
+    is_multicolor?: boolean | undefined;
+}>;
+/**
+ * Analyze printability input schema
+ */
+export declare const AnalyzePrintabilityInputSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    task_type: z.ZodDefault<z.ZodString>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+}, "strict", z.ZodTypeAny, {
+    response_format: import("../constants.js").ResponseFormat;
+    task_id: string;
+    task_type: string;
+}, {
+    task_id: string;
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    task_type?: string | undefined;
+}>;
+/**
+ * Process multicolor input schema
+ * Calls POST /openapi/v1/print/multi-color to create a multicolor print task.
+ */
+export declare const ProcessMulticolorInputSchema: z.ZodObject<{
+    input_task_id: z.ZodString;
+    max_colors: z.ZodDefault<z.ZodNumber>;
+    max_depth: z.ZodDefault<z.ZodNumber>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+}, "strict", z.ZodTypeAny, {
+    response_format: import("../constants.js").ResponseFormat;
+    input_task_id: string;
+    max_colors: number;
+    max_depth: number;
+}, {
+    input_task_id: string;
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    max_colors?: number | undefined;
+    max_depth?: number | undefined;
+}>;

package/dist/schemas/printing.js

@@ -0,0 +1,54 @@
+/**
+ * Zod schemas for 3D printing tools
+ */
+import { z } from "zod";
+import { ResponseFormatSchema, TaskIdSchema, UrlSchema } from "./common.js";
+/**
+ * Send to slicer input schema
+ * Detects installed slicers and returns launch commands.
+ */
+export const SendToSlicerInputSchema = z.object({
+    model_url: UrlSchema
+        .describe("Download URL of the model file to send to slicer"),
+    slicer_type: z.enum(["auto", "bambu", "orcaslicer", "creality_print", "elegoo_slicer", "anycubic_slicer", "prusaslicer", "cura"])
+        .default("auto")
+        .describe("Target slicer. 'auto' (default) detects all installed slicers and recommends the best one. Specify a value to target a particular slicer."),
+    file_name: z.string()
+        .default("meshy_model.3mf")
+        .describe("File name for the model (default: meshy_model.3mf)"),
+    is_multicolor: z.boolean()
+        .default(false)
+        .describe("If true, only recommends multicolor-capable slicers (OrcaSlicer, Bambu Studio, Creality Print, Elegoo Slicer, Anycubic Slicer Next)"),
+    response_format: ResponseFormatSchema
+}).strict();
+/**
+ * Analyze printability input schema
+ */
+export const AnalyzePrintabilityInputSchema = z.object({
+    task_id: TaskIdSchema,
+    task_type: z.string()
+        .default("text-to-3d")
+        .describe("Task type of the model to analyze"),
+    response_format: ResponseFormatSchema
+}).strict();
+/**
+ * Process multicolor input schema
+ * Calls POST /openapi/v1/print/multi-color to create a multicolor print task.
+ */
+export const ProcessMulticolorInputSchema = z.object({
+    input_task_id: TaskIdSchema
+        .describe("Task ID of a completed TEXTURED model. The model must have textures (run meshy_text_to_3d_refine or meshy_retexture first)."),
+    max_colors: z.number()
+        .int()
+        .min(1, "Minimum 1 color")
+        .max(16, "Maximum 16 colors")
+        .default(4)
+        .describe("Maximum number of colors for segmentation (1-16, default: 4)"),
+    max_depth: z.number()
+        .int()
+        .min(3, "Minimum depth 3")
+        .max(6, "Maximum depth 6")
+        .default(4)
+        .describe("Segmentation depth level (3-6, default: 4). Higher values produce finer color separation."),
+    response_format: ResponseFormatSchema
+}).strict();

package/dist/schemas/tasks.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Zod schemas for task management tools
+ */
+import { z } from "zod";
+import { TaskStatus, TaskPhase, TaskType } from "../constants.js";
+/**
+ * Get task status input schema (also supports wait mode)
+ */
+export declare const GetTaskStatusInputSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    task_type: z.ZodDefault<z.ZodNativeEnum<typeof TaskType>>;
+    wait: z.ZodDefault<z.ZodBoolean>;
+    timeout_seconds: z.ZodDefault<z.ZodNumber>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+}, "strict", z.ZodTypeAny, {
+    response_format: import("../constants.js").ResponseFormat;
+    task_id: string;
+    task_type: TaskType;
+    wait: boolean;
+    timeout_seconds: number;
+}, {
+    task_id: string;
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    task_type?: TaskType | undefined;
+    wait?: boolean | undefined;
+    timeout_seconds?: number | undefined;
+}>;
+/**
+ * List tasks input schema
+ */
+export declare const ListTasksInputSchema: z.ZodObject<{
+    task_type: z.ZodOptional<z.ZodNativeEnum<typeof TaskType>>;
+    sort_by: z.ZodDefault<z.ZodEnum<["+created_at", "-created_at"]>>;
+    status: z.ZodOptional<z.ZodNativeEnum<typeof TaskStatus>>;
+    phase: z.ZodOptional<z.ZodNativeEnum<typeof TaskPhase>>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+} & {
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    response_format: import("../constants.js").ResponseFormat;
+    sort_by: "+created_at" | "-created_at";
+    status?: TaskStatus | undefined;
+    task_type?: TaskType | undefined;
+    phase?: TaskPhase | undefined;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    status?: TaskStatus | undefined;
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    task_type?: TaskType | undefined;
+    sort_by?: "+created_at" | "-created_at" | undefined;
+    phase?: TaskPhase | undefined;
+}>;
+/**
+ * Cancel task input schema
+ */
+export declare const CancelTaskInputSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    task_type: z.ZodDefault<z.ZodNativeEnum<typeof TaskType>>;
+}, "strict", z.ZodTypeAny, {
+    task_id: string;
+    task_type: TaskType;
+}, {
+    task_id: string;
+    task_type?: TaskType | undefined;
+}>;
+/**
+ * Download model input schema
+ */
+export declare const DownloadModelInputSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    task_type: z.ZodDefault<z.ZodNativeEnum<typeof TaskType>>;
+    format: z.ZodDefault<z.ZodEnum<["glb", "fbx", "usdz", "stl", "obj", "3mf"]>>;
+    include_textures: z.ZodDefault<z.ZodBoolean>;
+    save_to: z.ZodOptional<z.ZodString>;
+    parent_task_id: z.ZodOptional<z.ZodString>;
+    print_ready: z.ZodOptional<z.ZodBoolean>;
+    print_height_mm: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    task_id: string;
+    task_type: TaskType;
+    format: "glb" | "fbx" | "usdz" | "3mf" | "obj" | "stl";
+    include_textures: boolean;
+    save_to?: string | undefined;
+    parent_task_id?: string | undefined;
+    print_ready?: boolean | undefined;
+    print_height_mm?: number | undefined;
+}, {
+    task_id: string;
+    task_type?: TaskType | undefined;
+    format?: "glb" | "fbx" | "usdz" | "3mf" | "obj" | "stl" | undefined;
+    include_textures?: boolean | undefined;
+    save_to?: string | undefined;
+    parent_task_id?: string | undefined;
+    print_ready?: boolean | undefined;
+    print_height_mm?: number | undefined;
+}>;
+/**
+ * List models input schema
+ */
+export declare const ListModelsInputSchema: z.ZodObject<{
+    workspace_id: z.ZodOptional<z.ZodString>;
+    filter: z.ZodDefault<z.ZodEnum<["all", "published", "private"]>>;
+    response_format: z.ZodDefault<z.ZodNativeEnum<typeof import("../constants.js").ResponseFormat>>;
+} & {
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    filter: "all" | "published" | "private";
+    response_format: import("../constants.js").ResponseFormat;
+    workspace_id?: string | undefined;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    filter?: "all" | "published" | "private" | undefined;
+    response_format?: import("../constants.js").ResponseFormat | undefined;
+    workspace_id?: string | undefined;
+}>;