clone_template

Instructions

Implementation Reference

• src/tools/clone-template.ts:5-55 (handler)

  Registers the 'clone_template' tool on the MCP server. Accepts template_id, name, and optional default_slots. Calls client.cloneTemplate() and returns the cloned template info including the custom ut_ID.

  export function registerCloneTemplateTool(
    server: McpServer,
    client: RendrKitClient,
  ): void {
    server.registerTool(
      "clone_template",
      {
        description:
          "Clone a template with custom default values. Creates a reusable preset (e.g., your brand's product card template). Use the returned ut_ID for future generations.",
        inputSchema: {
          template_id: z.string().describe("Base template ID to clone"),
          name: z.string().describe("Name for your custom template"),
          default_slots: z
            .record(z.string(), z.string())
            .optional()
            .describe("Default slot values (e.g., brand name, colors)"),
        },
      },
      async ({ template_id, name, default_slots }) => {
        try {
          const result = await client.cloneTemplate({
            templateId: template_id,
            name,
            defaultSlots: default_slots,
          });
  
          return {
            content: [
              {
                type: "text" as const,
                text: [
                  `Template cloned!`,
                  ``,
                  `Custom ID: ut_${result.id}`,
                  `Name: ${result.name}`,
                  `Base: ${result.baseTemplateId}`,
                  ``,
                  `Use "ut_${result.id}" as template_id in generate_image to use your preset.`,
                ].join("\n"),
              },
            ],
          };
        } catch (error) {
          return {
            content: [{ type: "text" as const, text: `Clone failed: ${error instanceof Error ? error.message : String(error)}` }],
            isError: true,
          };
        }
      },
    );
  }

• src/types.ts:79-83 (schema)

  Type definition for the cloneTemplate API parameters: templateId, name, and optional defaultSlots.

  export interface CloneTemplateParams {
    templateId: string;
    name: string;
    defaultSlots?: Record<string, string>;
  }

• src/types.ts:86-92 (schema)

  Type definition for the UserTemplate response returned by cloneTemplate.

  export interface UserTemplate {
    id: string;
    baseTemplateId: string;
    name: string;
    defaultSlots: Record<string, string>;
    createdAt: string;
  }

• src/api-client.ts:113-119 (helper)

  API client method that posts to /api/v1/templates/clone with templateId, name, and defaultSlots to create a cloned template.

  async cloneTemplate(params: CloneTemplateParams): Promise<UserTemplate> {
    return this.request<UserTemplate>("POST", "/api/v1/templates/clone", {
      templateId: params.templateId,
      name: params.name,
      defaultSlots: params.defaultSlots,
    });
  }

• src/server.ts:25-25 (registration)

  Registration of the clone_template tool in the MCP server setup.

  registerCloneTemplateTool(server, client);