image_to_image

Instructions

Implementation Reference

• src/tools/ImageToImage.ts:47-87 (handler)

  The main handler function for the image_to_image tool. It validates args using zod, downloads the input image, calls server.api.imageApi.imageToImage(), and transforms the response into a CallToolResult.

  export const imageToImageHandler = async (server: RecraftServer, args: Record<string, unknown>): Promise<CallToolResult> => {
    try {
      const { imageURI, prompt, strength, style, substyle, styleID, model, numberOfImages } = z.object({
        imageURI: z.string(),
        prompt: z.string(),
        strength: z.number(),
        style: z.nativeEnum(ImageStyle).optional(),
        substyle: z.nativeEnum(ImageSubStyle).optional(),
        styleID: z.string().optional(),
        model: z.nativeEnum(TransformModel).optional(),
        numberOfImages: z.number().optional()
      }).parse(args)
  
      const imageData = await downloadImage(imageURI)
  
      const result = await server.api.imageApi.imageToImage({
        image: await imageDataToBlob(imageData),
        prompt: prompt,
        strength: strength,
        style: styleID ? undefined : style,
        substyle: styleID ? undefined : substyle,
        styleId: styleID,
        model: model,
        responseFormat: 'url',
        n: numberOfImages,
        expire: server.isLocalResultsStorage,
      })
  
      return await server.transformGenerateImageResponseToCallToolResult(result)
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error generating image: ${error}`
          }
        ],
        isError: true
      }
    }
  }

• src/tools/ImageToImage.ts:17-45 (schema)

  Input schema definition for the image_to_image tool, defining properties (imageURI, prompt, strength, style, substyle, styleID, model, numberOfImages) and required fields.

    inputSchema: {
      type: "object",
      properties: {
        imageURI: PARAMETERS.imageURI,
        prompt: PARAMETERS.promptSimple,
        strength: {
          type: "number",
          minimum: 0.0,
          maximum: 1.0,
          description: "Strength of the image to image transformation, where 0 means almost similar to reference input image, 1 means almost no reference."
        },
        style: {
          ...PARAMETERS.imageStyle,
          description: PARAMETERS.imageStyle.description + "\n" + STYLE_PRESERVATION_WARNING,
        },
        substyle: {
          ...PARAMETERS.imageSubStyle,
          description: PARAMETERS.imageSubStyle.description + "\n" + STYLE_PRESERVATION_WARNING,
        },
        styleID: {
          ...PARAMETERS.imageStyleID,
          description: PARAMETERS.imageStyleID.description + "\n" + STYLE_PRESERVATION_WARNING,
        },
        model: PARAMETERS.transformModel,
        numberOfImages: PARAMETERS.numberOfImages,
      },
      required: ["imageURI", "prompt", "strength"]
    }
  }

• src/index.ts:108-109 (registration)

  Registration of the image_to_image tool via a switch case in the CallToolRequestSchema handler. Dispatches to imageToImageHandler when tool name matches.

  case imageToImageTool.name:
    return await imageToImageHandler(recraftServer, args ?? {})

• src/index.ts:68-80 (registration)

  The tool is listed in the tools array returned by the ListToolsRequestSchema handler, making it available to clients.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: [
        generateImageTool,
        createStyleTool,
        vectorizeImageTool,
        imageToImageTool,
        removeBackgroundTool,
        replaceBackgroundTool,
        crispUpscaleTool,
        creativeUpscaleTool,
        getUserTool,
      ],

• src/api/apis/ImageApi.ts:884-887 (helper)

  The imageToImage method on ImageApi which posts a multipart/form-data request to /v1/images/imageToImage endpoint with all image generation parameters.

  async imageToImage(requestParameters: ImageToImageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GenerateImageResponse> {
      const response = await this.imageToImageRaw(requestParameters, initOverrides);
      return await response.value();
  }