batch_render

Instructions

Implementation Reference

• src/tools/batch-render.ts:5-66 (handler)

  The registerBatchRenderTool function registers the 'batch_render' tool on the MCP server. The handler (line 28-64) validates input with Zod, maps snake_case params to camelCase, calls client.batchRender(), and formats the response as a text block listing generated image URLs and any errors.

  export function registerBatchRenderTool(
    server: McpServer,
    client: RendrKitClient,
  ): void {
    server.registerTool(
      "batch_render",
      {
        description:
          "Generate multiple images from the same template with different data. Perfect for e-commerce catalogs, certificates, social media series. Up to 20 items per batch.",
        inputSchema: {
          template_id: z
            .string()
            .describe("Template ID to use for all items"),
          items: z
            .array(
              z.object({
                slots: z.record(z.string(), z.string()).describe("Slot values for this item"),
                image_url: z.string().optional().describe("Photo URL for this item"),
              }),
            )
            .describe("Array of items to render (max 20)"),
        },
      },
      async ({ template_id, items }) => {
        try {
          const result = await client.batchRender({
            templateId: template_id,
            items: items.map((item) => ({
              slots: item.slots,
              imageUrl: item.image_url,
            })),
          });
  
          const lines = result.images.map(
            (img, i) => `${i + 1}. ${img.url}`,
          );
          const errorLines = result.errors?.map(
            (e) => `Error at index ${e.index}: ${e.message}`,
          ) ?? [];
  
          return {
            content: [
              {
                type: "text" as const,
                text: [
                  `Batch complete: ${result.images.length} images generated`,
                  ``,
                  ...lines,
                  ...(errorLines.length > 0 ? [``, `Errors:`, ...errorLines] : []),
                ].join("\n"),
              },
            ],
          };
        } catch (error) {
          return {
            content: [{ type: "text" as const, text: `Batch render failed: ${error instanceof Error ? error.message : String(error)}` }],
            isError: true,
          };
        }
      },
    );
  }

• src/types.ts:63-76 (schema)

  BatchRenderParams interface defines the input shape (templateId + items array with slots and optional imageUrl). BatchRenderResponse defines the output shape (images array of GeneratedImage + optional errors array).

  /** Parameters for batch render */
  export interface BatchRenderParams {
    templateId: string;
    items: Array<{
      slots: Record<string, string>;
      imageUrl?: string;
    }>;
  }
  
  /** Response from batch render */
  export interface BatchRenderResponse {
    images: GeneratedImage[];
    errors?: Array<{ index: number; code: string; message: string }>;
  }

• src/server.ts:9-28 (registration)

  The tool is imported from './tools/batch-render.js' and registered at line 24 via registerBatchRenderTool(server, client).

  import { registerBatchRenderTool } from "./tools/batch-render.js";
  import { registerCloneTemplateTool } from "./tools/clone-template.js";
  
  export function createServer(client: RendrKitClient): McpServer {
    const server = new McpServer({
      name: "rendrkit",
      version: "0.3.0",
    });
  
    registerGenerateImageTool(server, client);
    registerGetImageTool(server, client);
    registerListBrandKitsTool(server, client);
    registerGetUsageTool(server, client);
    registerListTemplatesTool(server, client);
    registerUploadImageTool(server, client);
    registerBatchRenderTool(server, client);
    registerCloneTemplateTool(server, client);
  
    return server;
  }

• src/api-client.ts:109-111 (helper)

  The batchRender method on RendrKitClient sends a POST request to '/api/v1/generate/batch-render' with BatchRenderParams, returning a Promise<BatchRenderResponse>.

  async batchRender(params: BatchRenderParams): Promise<BatchRenderResponse> {
    return this.request<BatchRenderResponse>("POST", "/api/v1/generate/batch-render", params);
  }

• src/tools/batch-render.ts:14-26 (schema)

  Zod input schema for the tool: template_id (string) and items (array of objects with 'slots' record and optional 'image_url').

  inputSchema: {
    template_id: z
      .string()
      .describe("Template ID to use for all items"),
    items: z
      .array(
        z.object({
          slots: z.record(z.string(), z.string()).describe("Slot values for this item"),
          image_url: z.string().optional().describe("Photo URL for this item"),
        }),
      )
      .describe("Array of items to render (max 20)"),
  },