@acedatacloud/sdk 2026.817.0 → 2026.905.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/sdk",
-  "version": "2026.817.0",
+  "version": "2026.905.0",
   "description": "Official TypeScript SDK for AceDataCloud — AI-powered data services",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/resources/providers/fish.ts

@@ -22,15 +22,15 @@ export interface FishGenerateOptions {
   /** Top-p nucleus sampling parameter, controls output diversity. */
   topP?: number;
   /** Output audio format, default is `mp3`. */
-  format?: "mp3" | "wav" | "pcm" | "opus";
+  format?: "mp3" | "wav" | "pcm";
   /** Delay mode. The upstream rejects null values, and defaults to `normal` when omitted. */
   latency?: "normal" | "balanced";
   /** Rhythm coverage parameters, forwarded as is to upstream (such as speech rate, volume, etc.). */
   prosody?: Record<string, unknown>;
   /** Is the input text subjected to text normalization processing by the upstream? */
   normalize?: boolean;
-  /** Inline reference audio samples will be forwarded upstream as is, for zero-shot voice cloning. */
-  references?: Array<Record<string, unknown>>;
+  /** One-shot voice clone reference; cannot be combined with reference_id. */
+  references?: Array<{ audio: string; text: string }>;
   /** MP3 bitrate when `format=mp3`. */
   mp3Bitrate?: number;
   /** Output the audio sampling rate (e.g., 16000, 22050, 44100). */
@@ -41,14 +41,15 @@ export interface FishGenerateOptions {
   chunkLength?: number;
   /** Opus bitrate when `format=opus`. */
   opusBitrate?: number;
-  /** Voice model ID (single speaker). A string array can also be passed in multi-speaker scenarios. */
-  referenceId?: string;
+  /** Saved/public voice ID; cannot be combined with references. */
+  referenceId?: string | string[];
   /** Maximum number of new tokens generated. */
   maxNewTokens?: number;
   /** Minimum block length. */
   minChunkLength?: number;
   /** The repetition penalty coefficient applied during the generation process. */
   repetitionPenalty?: number;
+  model?: "s1" | "s2-pro" | "s2.1-pro";
   /** Submit asynchronously and poll. Defaults to true. */
   async?: boolean;
   /** Wait for completion before returning the handle. */
@@ -108,13 +109,13 @@ export class Fish {
     if (options.minChunkLength !== undefined) body["min_chunk_length"] = options.minChunkLength;
     if (options.repetitionPenalty !== undefined) body["repetition_penalty"] = options.repetitionPenalty;
     for (const [key, value] of Object.entries(options)) {
-      if (!["async", "callbackUrl", "chunkLength", "format", "latency", "maxNewTokens", "maxWait", "minChunkLength", "mp3Bitrate", "normalize", "opusBitrate", "pollInterval", "prosody", "referenceId", "references", "repetitionPenalty", "sampleRate", "temperature", "text", "topP", "wait"].includes(key) && value !== undefined) {
+      if (!["async", "callbackUrl", "chunkLength", "format", "latency", "maxNewTokens", "maxWait", "minChunkLength", "model", "mp3Bitrate", "normalize", "opusBitrate", "pollInterval", "prosody", "referenceId", "references", "repetitionPenalty", "sampleRate", "temperature", "text", "topP", "wait"].includes(key) && value !== undefined) {
         body[key] = value;
       }
     }
     if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
     body.async = options.async ?? true;
-    const result = (await this.transport.request('POST', "/fish/tts", { json: body })) as Record<string, unknown>;
+    const result = (await this.transport.request('POST', "/fish/tts", { json: body, headers: options.model !== undefined ? {"model": options.model} : {} })) as Record<string, unknown>;
     const handle = new TaskHandle(taskId(result), "/fish/tasks", this.transport, result);
     if (options.wait) {
       await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });

package/src/resources/providers/index.ts

@@ -12,6 +12,7 @@ export { Maestro } from './maestro';
 export { Minimax } from './minimax';
 export { NanoBanana } from './nano-banana';
 export { Producer } from './producer';
+export { QwenImage } from './qwen-image';
 export { Seedance } from './seedance';
 export { Seedream } from './seedream';
 export { Suno } from './suno';
@@ -30,6 +31,7 @@ import { Maestro } from './maestro';
 import { Minimax } from './minimax';
 import { NanoBanana } from './nano-banana';
 import { Producer } from './producer';
+import { QwenImage } from './qwen-image';
 import { Seedance } from './seedance';
 import { Seedream } from './seedream';
 import { Suno } from './suno';
@@ -49,6 +51,7 @@ export function attachProviders(client: Record<string, unknown>, transport: Tran
   client.minimax = new Minimax(transport);
   client.nanobanana = new NanoBanana(transport);
   client.producer = new Producer(transport);
+  client.qwenimage = new QwenImage(transport);
   client.seedance = new Seedance(transport);
   client.seedream = new Seedream(transport);
   client.suno = new Suno(transport);

package/src/resources/providers/qwen-image.ts

@@ -0,0 +1,86 @@
+/**
+ * QwenImage (qwen-image) — generated from the platform OpenAPI spec.
+ *
+ * Do not edit by hand: run `python scripts/generate_providers.py`. Parameter
+ * names, types, enums and required-ness all come from the live spec.
+ */
+
+import { Transport } from '../../runtime/transport';
+import { TaskHandle } from '../../runtime/tasks';
+
+
+function taskId(result: Record<string, unknown>): string {
+  if (typeof result?.task_id === 'string') return result.task_id;
+  const data = result?.data as Record<string, unknown> | undefined;
+  if (data && typeof data.task_id === 'string') return data.task_id;
+  return typeof result?.id === 'string' ? result.id : '';
+}
+
+export interface QwenImageGenerateOptions {
+  /** $t(qwen_image_images_model) */
+  model: "qwen-image-3.0" | "qwen-image-3.0-pro";
+  /** $t(qwen_image_images_prompt) */
+  prompt: string;
+  /** $t(qwen_image_images_image_urls) */
+  imageUrls?: string[];
+  /** $t(qwen_image_images_n) */
+  n?: number;
+  /** $t(qwen_image_images_size) */
+  size?: string;
+  /** $t(qwen_image_images_prompt_extend) */
+  promptExtend?: boolean;
+  /** $t(qwen_image_images_prompt_extend_mode) */
+  promptExtendMode?: "direct" | "agent";
+  /** $t(qwen_image_images_enable_thinking) */
+  enableThinking?: boolean;
+  /** $t(qwen_image_images_negative_prompt) */
+  negativePrompt?: string;
+  /** $t(qwen_image_images_seed) */
+  seed?: number;
+  /** $t(qwen_image_images_watermark) */
+  watermark?: boolean;
+  /** Submit asynchronously and poll. Defaults to true. */
+  async?: boolean;
+  /** Wait for completion before returning the handle. */
+  wait?: boolean;
+  pollInterval?: number;
+  maxWait?: number;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+/** qwen-image client. */
+export class QwenImage {
+  constructor(private transport: Transport) {}
+
+  /** Call /qwen-image/images. */
+  async generate(options: QwenImageGenerateOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["model"] = options.model;
+    body["prompt"] = options.prompt;
+    if (options.imageUrls !== undefined) body["image_urls"] = options.imageUrls;
+    body["n"] = options.n ?? 1;
+    if (options.size !== undefined) body["size"] = options.size;
+    body["prompt_extend"] = options.promptExtend ?? true;
+    body["prompt_extend_mode"] = options.promptExtendMode ?? "direct";
+    body["enable_thinking"] = options.enableThinking ?? true;
+    if (options.negativePrompt !== undefined) body["negative_prompt"] = options.negativePrompt;
+    if (options.seed !== undefined) body["seed"] = options.seed;
+    body["watermark"] = options.watermark ?? false;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "callbackUrl", "enableThinking", "imageUrls", "maxWait", "model", "n", "negativePrompt", "pollInterval", "prompt", "promptExtend", "promptExtendMode", "seed", "size", "wait", "watermark"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    body.async = options.async ?? true;
+    const result = (await this.transport.request('POST', "/qwen-image/images", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/qwen-image/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}

package/src/resources/providers/seedream.ts

@@ -17,34 +17,34 @@ function taskId(result: Record<string, unknown>): string {
 }
 
 export interface SeedreamGenerateOptions {
-  /** Models used for generating images. If not specified, the default is `doubao-seedream-5.0-lite`. `doubao-seedream-5.0-pro` is the latest flagship single image model (only generates single images, does not support group images, streaming, or online search). */
-  model: "doubao-seedream-5-0-pro-260628" | "doubao-seedream-5-0-260128" | "doubao-seedream-4-0-250828" | "doubao-seedream-4-5-251128" | "doubao-seedream-3-0-t2i-250415" | "doubao-seededit-3-0-i2i-250628";
-  /** Prompts for generating images. */
-  prompt: string;
-  /** Generate a random seed for image generation. The supported range is [-1, 2147483647], with a default value of `-1`. **Only `doubao-seedream-3.0-t2i` supports this parameter** (according to the official Volcengine documentation), other models do not accept this parameter. */
-  seed?: number;
-  /** Generate image dimensions or aspect ratios. Supports preset options (`1K`/`2K`/`3K`/`4K`), or explicit `<width>x<height>` format (e.g., `1024x1024`). **Different models support different preset options**: `doubao-seedream-5.0-pro` supports `1K`/`2K`; `doubao-seedream-5.0-lite` supports `2K`/`3K`/`4K`; `doubao-seedream-4.5` only supports `2K`/`4K`; `doubao-seedream-4.0` supports `1K`/`2K`/`4K`; `doubao-seedream-3.0-t2i` and `doubao-seedream-3.0-i2i` **do not support** any preset options and must receive explicit `<width>x<height>` values. */
-  size?: "1K" | "2K" | "3K" | "4K";
-  /** Reference image links for image editing are required, supporting accessible http/https URLs, or base64 encoded image strings in the format `data:image/png;base64,iVBORw0KG...`. Each image must not exceed 10MB in size. This parameter is mandatory when using image-to-image models (such as `doubao-seededit-3.0-i2i`). */
-  image?: string[];
-  /** List of tools that can be called by the model. Currently, only `web_search` is supported. Applicable only to `doubao-seedream-5.0-lite`. */
-  tools?: Array<Record<string, unknown>>;
-  /** Whether to return all images in a streaming manner, default is `false`. Only supports `doubao-seedream-5.0-lite`, `doubao-seedream-4.5`, and `doubao-seedream-4.0`. */
+  /** Full model ID. Seedream 5.0 Pro supports single-image generation, precise editing, transparent backgrounds, and layer decomposition; Seedream 5.0 Lite supports single or sequential images, streaming, and web search. */
+  model: "doubao-seedream-5-0-pro-260628" | "doubao-seedream-5-0-260128" | "doubao-seedream-5-0-lite-260128" | "doubao-seedream-4-0-250828" | "doubao-seedream-4-5-251128";
+  /** Generation or editing prompt. Optional only for Seedream 5.0 Pro layer decomposition, where omission automatically decomposes the main elements. */
+  prompt?: string;
+  /** One reference image URL/base64 string or an array. Pro accepts up to 10 images in regular mode and exactly one for decomposition; Lite/4.x accept up to 14. Each image must be at most 30 MB. */
+  image?: string | string[];
+  /** Output size. Pro supports 1K/1.5K/2K or valid dimensions; decomposition also supports auto. Lite supports 2K/3K/4K or valid dimensions. */
+  size?: "1K" | "1.5K" | "2K" | "3K" | "4K" | "auto" | `${number}x${number}`;
+  /** Sequential image mode. auto lets supported Lite/4.x models generate a related set; disabled returns one image. Not supported by Pro. */
+  sequentialImageGeneration?: "auto" | "disabled";
+  /** Sequential image options. max_images is 1-15 and input images plus outputs must not exceed 15. */
+  sequentialImageGenerationOptions?: Record<string, unknown>;
+  /** Stream normalized image events. Supported by Lite/4.x only and cannot be combined with async or callback_url. */
   stream?: boolean;
-  /** Whether to add AI-generated watermark, default is `true`. */
+  /** Image response format: url or b64_json. */
+  responseFormat?: "url" | "b64_json";
+  /** Whether to add the AI-generated watermark. */
   watermark?: boolean;
-  /** The output image file format is `jpeg` by default. Only `doubao-seedream-5.0-pro` and `doubao-seedream-5.0-lite` are supported. */
+  /** Output image format, jpeg or png. Supported by Seedream 5.0 Pro and Lite. */
   outputFormat?: "jpeg" | "png";
-  /** Prompt word weight, the larger the value, the more relevant the generated result is to the prompt word. Only supports `doubao-seedream-3.0-t2i` (default value 2.5) and `doubao-seededit-3.0-i2i` (default value 5.5), both ranges are [1, 10]. */
-  guidanceScale?: unknown;
-  /** The response format defaults to `url`, and also supports `b64_json`. */
-  responseFormat?: string;
-  /** Optional prompt word optimization configuration. Only supports `doubao-seedream-5.0-lite`, `doubao-seedream-4.5` (only in `standard` mode), and `doubao-seedream-4.0`. */
+  /** Model tools. Seedream 5.0 Lite supports web_search. */
+  tools?: Array<Record<string, unknown>>;
+  /** Prompt optimization. Pro supports standard/fast; Lite and 4.5 support standard; 4.0 supports standard/fast. */
   optimizePromptOptions?: Record<string, unknown>;
-  /** The default value is `disabled`. Setting it to `auto` allows the model to generate a set of stylistically coherent related images (multi-image consistency, sharing characters, styles, and details across frames). Only `doubao-seedream-5.0-lite`, `doubao-seedream-4.5`, and `doubao-seedream-4.0` are supported. */
-  sequentialImageGeneration?: "auto" | "disabled";
-  /** Adjustable parameters for batch image generation. Effective only when `sequential_image_generation=auto`. Only supports `doubao-seedream-5.0-lite`, `doubao-seedream-4.5`, and `doubao-seedream-4.0`. */
-  sequentialImageGenerationOptions?: Record<string, unknown>;
+  /** Seedream 5.0 Pro layer decomposition. Requires exactly one PNG/JPEG and returns one base image plus up to 16 transparent PNG layers. */
+  layerDecomposition?: boolean;
+  /** Seedream 5.0 Pro background mode. transparent requires one transparent PNG input and PNG output; opaque produces a regular background. */
+  background?: "transparent" | "opaque";
   /** Submit asynchronously and poll. Defaults to true. */
   async?: boolean;
   /** Wait for completion before returning the handle. */
@@ -60,25 +60,25 @@ export interface SeedreamGenerateOptions {
 export class Seedream {
   constructor(private transport: Transport) {}
 
-  /** ByteDance Seedream high-quality image generation and editing API. Supports text-to-image models doubao-seedream-3-0-t2i-250415, doubao-seedream-4-0-250828, doubao-seedream-4-5-251128, doubao-seedream- */
+  /** Call /seedream/images. */
   async generate(options: SeedreamGenerateOptions): Promise<TaskHandle> {
     const body: Record<string, unknown> = {};
     body["model"] = options.model;
-    body["prompt"] = options.prompt;
-    if (options.seed !== undefined) body["seed"] = options.seed;
-    if (options.size !== undefined) body["size"] = options.size;
+    if (options.prompt !== undefined) body["prompt"] = options.prompt;
     if (options.image !== undefined) body["image"] = options.image;
-    if (options.tools !== undefined) body["tools"] = options.tools;
+    if (options.size !== undefined) body["size"] = options.size;
+    if (options.sequentialImageGeneration !== undefined) body["sequential_image_generation"] = options.sequentialImageGeneration;
+    if (options.sequentialImageGenerationOptions !== undefined) body["sequential_image_generation_options"] = options.sequentialImageGenerationOptions;
     if (options.stream !== undefined) body["stream"] = options.stream;
+    if (options.responseFormat !== undefined) body["response_format"] = options.responseFormat;
     if (options.watermark !== undefined) body["watermark"] = options.watermark;
     if (options.outputFormat !== undefined) body["output_format"] = options.outputFormat;
-    if (options.guidanceScale !== undefined) body["guidance_scale"] = options.guidanceScale;
-    if (options.responseFormat !== undefined) body["response_format"] = options.responseFormat;
+    if (options.tools !== undefined) body["tools"] = options.tools;
     if (options.optimizePromptOptions !== undefined) body["optimize_prompt_options"] = options.optimizePromptOptions;
-    if (options.sequentialImageGeneration !== undefined) body["sequential_image_generation"] = options.sequentialImageGeneration;
-    if (options.sequentialImageGenerationOptions !== undefined) body["sequential_image_generation_options"] = options.sequentialImageGenerationOptions;
+    if (options.layerDecomposition !== undefined) body["layer_decomposition"] = options.layerDecomposition;
+    if (options.background !== undefined) body["background"] = options.background;
     for (const [key, value] of Object.entries(options)) {
-      if (!["async", "callbackUrl", "guidanceScale", "image", "maxWait", "model", "optimizePromptOptions", "outputFormat", "pollInterval", "prompt", "responseFormat", "seed", "sequentialImageGeneration", "sequentialImageGenerationOptions", "size", "stream", "tools", "wait", "watermark"].includes(key) && value !== undefined) {
+      if (!["async", "background", "callbackUrl", "image", "layerDecomposition", "maxWait", "model", "optimizePromptOptions", "outputFormat", "pollInterval", "prompt", "responseFormat", "sequentialImageGeneration", "sequentialImageGenerationOptions", "size", "stream", "tools", "wait", "watermark"].includes(key) && value !== undefined) {
         body[key] = value;
       }
     }

package/src/resources/providers/wan.ts

@@ -17,32 +17,40 @@ function taskId(result: Record<string, unknown>): string {
 }
 
 export interface WanGenerateOptions {
-  /** Models for generating videos include optional values such as `wan2.6-t2v` (text-to-video), `wan2.6-i2v` (image-to-video), `wan2.6-i2v-flash` (fast version of image-to-video), and `wan2.6-r2v` (reference video generation). */
-  model: "wan2.6-i2v" | "wan2.6-r2v" | "wan2.6-i2v-flash" | "wan2.6-t2v";
-  /** Operation types. `text2video` indicates text-to-video, and `image2video` indicates image-to-video. */
-  action: "text2video" | "image2video";
-  /** Prompts for generating videos. */
-  prompt: string;
-  /** Video size specifications. */
-  size?: string;
-  /** Specify whether the generated video contains sound. */
+  /** $t(wan_videos_model) */
+  model: "wan2.6-i2v" | "wan2.6-r2v" | "wan2.6-i2v-flash" | "wan2.6-t2v" | "wan3.0-video";
+  /** $t(wan_videos_audio) */
   audio?: boolean;
-  /** Specify the duration of the video to be generated (in seconds), with optional values of `5`, `10`, or `15`. */
-  duration?: number;
-  /** The URL of the audio file, the model will generate the corresponding video based on that audio. */
-  audioUrl?: string;
-  /** The URL of the starting frame image, which will serve as the first frame of the generated video. */
-  imageUrl?: string;
-  /** Specify the type of shots for the video, that is, whether the video consists of a single continuous shot (`single`) or multiple switching shots (`multi`). */
-  shotType?: "single" | "multi";
-  /** Specify the resolution level for generating the video, used to adjust the video clarity (total pixel count). The model will automatically scale to a similar total pixel count based on the selected resolution level, and the aspect ratio of the generated video will strive to remain consistent with the aspect ratio of the input image `image_url`. */
-  resolution?: "480P" | "720P" | "1080P";
-  /** Whether to enable intelligent rewriting of prompts. Once enabled, a large model will be used to intelligently expand the input prompts, which can significantly improve the generation effect of shorter prompts, but will increase processing time. */
+  /** $t(wan_videos_prompt_extend) */
   promptExtend?: boolean;
-  /** Reverse prompt words, used to describe content that is not desired to appear in the video footage, can be used to limit the video visuals. Supports both Chinese and English, with a length not exceeding 500 characters; any excess will be automatically truncated. */
+  /** $t(wan_videos_action) */
+  action?: "text2video" | "image2video";
+  /** $t(wan_videos_resolution) */
+  resolution?: "480P" | "720P" | "1080P";
+  /** $t(wan_videos_shot_type) */
+  shotType?: "single" | "multi";
+  /** $t(wan_videos_duration) */
+  duration?: number;
+  /** $t(wan_videos_prompt) */
+  prompt?: string;
+  /** $t(wan_videos_negative_prompt) */
   negativePrompt?: string;
-  /** An array of URLs for reference video files, used to extract the character images (and vocal tones, if any) from the reference videos to generate videos that match the reference features. */
+  /** $t(wan_videos_size) */
+  size?: string;
+  /** $t(wan_videos_audio_url) */
+  audioUrl?: string;
+  /** $t(wan_videos_reference_video_urls) */
   referenceVideoUrls?: string[];
+  /** $t(wan_videos_image_url) */
+  imageUrl?: string;
+  /** $t(wan_videos_media) */
+  media?: Array<Record<string, unknown>>;
+  /** $t(wan_videos_ratio) */
+  ratio?: "adaptive" | "16:9" | "4:3" | "1:1" | "3:4" | "9:16";
+  /** $t(wan_videos_seed) */
+  seed?: number;
+  /** $t(wan_videos_watermark) */
+  watermark?: boolean;
   /** Submit asynchronously and poll. Defaults to true. */
   async?: boolean;
   /** Wait for completion before returning the handle. */
@@ -62,20 +70,24 @@ export class Wan {
   async generate(options: WanGenerateOptions): Promise<TaskHandle> {
     const body: Record<string, unknown> = {};
     body["model"] = options.model;
-    body["action"] = options.action;
-    body["prompt"] = options.prompt;
-    if (options.size !== undefined) body["size"] = options.size;
     body["audio"] = options.audio ?? false;
-    if (options.duration !== undefined) body["duration"] = options.duration;
-    if (options.audioUrl !== undefined) body["audio_url"] = options.audioUrl;
-    if (options.imageUrl !== undefined) body["image_url"] = options.imageUrl;
-    if (options.shotType !== undefined) body["shot_type"] = options.shotType;
-    if (options.resolution !== undefined) body["resolution"] = options.resolution;
     body["prompt_extend"] = options.promptExtend ?? false;
+    body["action"] = options.action ?? "text2video";
+    if (options.resolution !== undefined) body["resolution"] = options.resolution;
+    if (options.shotType !== undefined) body["shot_type"] = options.shotType;
+    if (options.duration !== undefined) body["duration"] = options.duration;
+    if (options.prompt !== undefined) body["prompt"] = options.prompt;
     if (options.negativePrompt !== undefined) body["negative_prompt"] = options.negativePrompt;
+    if (options.size !== undefined) body["size"] = options.size;
+    if (options.audioUrl !== undefined) body["audio_url"] = options.audioUrl;
     if (options.referenceVideoUrls !== undefined) body["reference_video_urls"] = options.referenceVideoUrls;
+    if (options.imageUrl !== undefined) body["image_url"] = options.imageUrl;
+    if (options.media !== undefined) body["media"] = options.media;
+    if (options.ratio !== undefined) body["ratio"] = options.ratio;
+    if (options.seed !== undefined) body["seed"] = options.seed;
+    body["watermark"] = options.watermark ?? false;
     for (const [key, value] of Object.entries(options)) {
-      if (!["action", "async", "audio", "audioUrl", "callbackUrl", "duration", "imageUrl", "maxWait", "model", "negativePrompt", "pollInterval", "prompt", "promptExtend", "referenceVideoUrls", "resolution", "shotType", "size", "wait"].includes(key) && value !== undefined) {
+      if (!["action", "async", "audio", "audioUrl", "callbackUrl", "duration", "imageUrl", "maxWait", "media", "model", "negativePrompt", "pollInterval", "prompt", "promptExtend", "ratio", "referenceVideoUrls", "resolution", "seed", "shotType", "size", "wait", "watermark"].includes(key) && value !== undefined) {
         body[key] = value;
       }
     }