modelfusion 0.41.3 → 0.43.0

package/model-function/generate-structure/generateStructure.js

@@ -12,11 +12,12 @@ export function generateStructure(model, structureDefinition, prompt, options) {
         options,
         generateResponse: async (options) => {
             const result = await model.doGenerateStructure(structureDefinition, expandedPrompt, options);
-            const structure = result.structure;
+            const structure = result.value;
             const parseResult = structureDefinition.schema.validate(structure);
             if (!parseResult.success) {
                 throw new StructureValidationError({
                     structureName: structureDefinition.name,
+                    valueText: result.valueText,
                     value: structure,
                     cause: parseResult.error,
                 });

package/model-function/generate-structure/generateStructureOrText.cjs

@@ -34,6 +34,7 @@ function generateStructureOrText(model, structureDefinitions, prompt, options) {
                 throw new StructureValidationError_js_1.StructureValidationError({
                     structureName: structure,
                     value,
+                    valueText: result.structureAndText.valueText,
                     cause: parseResult.error,
                 });
             }

package/model-function/generate-structure/generateStructureOrText.js

@@ -31,6 +31,7 @@ export function generateStructureOrText(model, structureDefinitions, prompt, opt
                 throw new StructureValidationError({
                     structureName: structure,
                     value,
+                    valueText: result.structureAndText.valueText,
                     cause: parseResult.error,
                 });
             }

package/model-function/generate-text/TextGenerationModel.d.ts

@@ -1,7 +1,5 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { PromptFormat } from "../../prompt/PromptFormat.js";
-import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
-import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { Delta } from "../Delta.js";
 import { Model, ModelSettings } from "../Model.js";
 import { BasicTokenizer, FullTokenizer } from "../tokenize-text/Tokenizer.js";
@@ -38,9 +36,9 @@ export interface TextGenerationModel<PROMPT, SETTINGS extends TextGenerationMode
             totalTokens: number;
         };
     }>;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): TextGenerationModel<INPUT_PROMPT, SETTINGS>;
 }
 export interface TextStreamingModel<PROMPT, SETTINGS extends TextGenerationModelSettings = TextGenerationModelSettings> extends TextGenerationModel<PROMPT, SETTINGS> {
     doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<string>>>;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextStreamingModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): TextStreamingModel<INPUT_PROMPT, SETTINGS>;
 }

package/model-function/index.cjs

@@ -34,6 +34,7 @@ __exportStar(require("./generate-structure/StructureFromTextGenerationModel.cjs"
 __exportStar(require("./generate-structure/StructureGenerationEvent.cjs"), exports);
 __exportStar(require("./generate-structure/StructureGenerationModel.cjs"), exports);
 __exportStar(require("./generate-structure/StructureOrTextGenerationModel.cjs"), exports);
+__exportStar(require("./generate-structure/StructureParseError.cjs"), exports);
 __exportStar(require("./generate-structure/StructureStreamingEvent.cjs"), exports);
 __exportStar(require("./generate-structure/StructureValidationError.cjs"), exports);
 __exportStar(require("./generate-structure/generateStructure.cjs"), exports);

package/model-function/index.d.ts

@@ -18,6 +18,7 @@ export * from "./generate-structure/StructureFromTextGenerationModel.js";
 export * from "./generate-structure/StructureGenerationEvent.js";
 export * from "./generate-structure/StructureGenerationModel.js";
 export * from "./generate-structure/StructureOrTextGenerationModel.js";
+export * from "./generate-structure/StructureParseError.js";
 export * from "./generate-structure/StructureStreamingEvent.js";
 export * from "./generate-structure/StructureValidationError.js";
 export * from "./generate-structure/generateStructure.js";

package/model-function/index.js

@@ -18,6 +18,7 @@ export * from "./generate-structure/StructureFromTextGenerationModel.js";
 export * from "./generate-structure/StructureGenerationEvent.js";
 export * from "./generate-structure/StructureGenerationModel.js";
 export * from "./generate-structure/StructureOrTextGenerationModel.js";
+export * from "./generate-structure/StructureParseError.js";
 export * from "./generate-structure/StructureStreamingEvent.js";
 export * from "./generate-structure/StructureValidationError.js";
 export * from "./generate-structure/generateStructure.js";

package/model-provider/anthropic/AnthropicApiConfiguration.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicApiConfiguration = void 0;
+const BaseUrlApiConfiguration_js_1 = require("../../core/api/BaseUrlApiConfiguration.cjs");
+const loadApiKey_js_1 = require("../../core/api/loadApiKey.cjs");
+class AnthropicApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration {
+    constructor({ baseUrl = "https://api.anthropic.com/v1", apiKey, retry, throttle, } = {}) {
+        super({
+            baseUrl,
+            headers: {
+                "x-api-key": (0, loadApiKey_js_1.loadApiKey)({
+                    apiKey,
+                    environmentVariableName: "ANTHROPIC_API_KEY",
+                    description: "Anthropic",
+                }),
+                "anthropic-version": "2023-06-01",
+            },
+            retry,
+            throttle,
+        });
+    }
+}
+exports.AnthropicApiConfiguration = AnthropicApiConfiguration;

package/model-provider/anthropic/AnthropicApiConfiguration.d.ts

@@ -0,0 +1,11 @@
+import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
+import { RetryFunction } from "../../core/api/RetryFunction.js";
+import { ThrottleFunction } from "../../core/api/ThrottleFunction.js";
+export declare class AnthropicApiConfiguration extends BaseUrlApiConfiguration {
+    constructor({ baseUrl, apiKey, retry, throttle, }?: {
+        baseUrl?: string;
+        apiKey?: string;
+        retry?: RetryFunction;
+        throttle?: ThrottleFunction;
+    });
+}

package/model-provider/anthropic/AnthropicApiConfiguration.js

@@ -0,0 +1,19 @@
+import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
+import { loadApiKey } from "../../core/api/loadApiKey.js";
+export class AnthropicApiConfiguration extends BaseUrlApiConfiguration {
+    constructor({ baseUrl = "https://api.anthropic.com/v1", apiKey, retry, throttle, } = {}) {
+        super({
+            baseUrl,
+            headers: {
+                "x-api-key": loadApiKey({
+                    apiKey,
+                    environmentVariableName: "ANTHROPIC_API_KEY",
+                    description: "Anthropic",
+                }),
+                "anthropic-version": "2023-06-01",
+            },
+            retry,
+            throttle,
+        });
+    }
+}

package/model-provider/anthropic/AnthropicError.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failedAnthropicCallResponseHandler = exports.AnthropicError = exports.anthropicErrorDataSchema = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const ApiCallError_js_1 = require("../../core/api/ApiCallError.cjs");
+exports.anthropicErrorDataSchema = zod_1.z.object({
+    error: zod_1.z.object({
+        type: zod_1.z.string(),
+        message: zod_1.z.string(),
+    }),
+});
+class AnthropicError extends ApiCallError_js_1.ApiCallError {
+    constructor({ data, statusCode, url, requestBodyValues, message = data.error.message, }) {
+        super({ message, statusCode, requestBodyValues, url });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+}
+exports.AnthropicError = AnthropicError;
+const failedAnthropicCallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const parsedError = exports.anthropicErrorDataSchema.parse(secure_json_parse_1.default.parse(responseBody));
+    return new AnthropicError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};
+exports.failedAnthropicCallResponseHandler = failedAnthropicCallResponseHandler;

package/model-provider/anthropic/AnthropicError.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { ApiCallError } from "../../core/api/ApiCallError.js";
+import { ResponseHandler } from "../../core/api/postToApi.js";
+export declare const anthropicErrorDataSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        type: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: string;
+    }, {
+        message: string;
+        type: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        message: string;
+        type: string;
+    };
+}, {
+    error: {
+        message: string;
+        type: string;
+    };
+}>;
+export type AnthropicErrorData = z.infer<typeof anthropicErrorDataSchema>;
+export declare class AnthropicError extends ApiCallError {
+    readonly data: AnthropicErrorData;
+    constructor({ data, statusCode, url, requestBodyValues, message, }: {
+        message?: string;
+        statusCode: number;
+        url: string;
+        requestBodyValues: unknown;
+        data: AnthropicErrorData;
+    });
+}
+export declare const failedAnthropicCallResponseHandler: ResponseHandler<ApiCallError>;

package/model-provider/anthropic/AnthropicError.js

@@ -0,0 +1,31 @@
+import SecureJSON from "secure-json-parse";
+import { z } from "zod";
+import { ApiCallError } from "../../core/api/ApiCallError.js";
+export const anthropicErrorDataSchema = z.object({
+    error: z.object({
+        type: z.string(),
+        message: z.string(),
+    }),
+});
+export class AnthropicError extends ApiCallError {
+    constructor({ data, statusCode, url, requestBodyValues, message = data.error.message, }) {
+        super({ message, statusCode, requestBodyValues, url });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+}
+export const failedAnthropicCallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const parsedError = anthropicErrorDataSchema.parse(SecureJSON.parse(responseBody));
+    return new AnthropicError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};

package/model-provider/anthropic/AnthropicPromptFormat.cjs

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapChatPromptToAnthropicFormat = exports.mapInstructionPromptToAnthropicFormat = void 0;
+const validateChatPrompt_js_1 = require("../../prompt/chat/validateChatPrompt.cjs");
+/**
+ * Formats an instruction prompt as an Anthropic prompt.
+ */
+function mapInstructionPromptToAnthropicFormat() {
+    return {
+        format: (instruction) => {
+            let text = "";
+            if (instruction.system != null) {
+                text += `${instruction.system}`;
+            }
+            text += "\n\nHuman:";
+            text += instruction.instruction;
+            if (instruction.input != null) {
+                // use tags per Anthropic instruction:
+                // https://docs.anthropic.com/claude/docs/constructing-a-prompt
+                text += `\n\n<data>${instruction.input}</data>`;
+            }
+            text += "\n\nAssistant:";
+            return text;
+        },
+        stopSequences: [],
+    };
+}
+exports.mapInstructionPromptToAnthropicFormat = mapInstructionPromptToAnthropicFormat;
+/**
+ * Formats a chat prompt as an Anthropic prompt.
+ */
+function mapChatPromptToAnthropicFormat() {
+    return {
+        format: (chatPrompt) => {
+            (0, validateChatPrompt_js_1.validateChatPrompt)(chatPrompt);
+            let text = "";
+            for (let i = 0; i < chatPrompt.length; i++) {
+                const message = chatPrompt[i];
+                // system message:
+                if (i === 0 &&
+                    "system" in message &&
+                    typeof message.system === "string") {
+                    text += `${message.system}\n\n`;
+                    continue;
+                }
+                // user message
+                if ("user" in message) {
+                    text += `\n\nHuman:${message.user}`;
+                    continue;
+                }
+                // ai message:
+                if ("ai" in message) {
+                    text += `\n\nAssistant:${message.ai}`;
+                    continue;
+                }
+                // unsupported message:
+                throw new Error(`Unsupported message: ${JSON.stringify(message)}`);
+            }
+            // AI message prefix:
+            text += `\n\nAssistant:`;
+            return text;
+        },
+        stopSequences: [],
+    };
+}
+exports.mapChatPromptToAnthropicFormat = mapChatPromptToAnthropicFormat;

package/model-provider/anthropic/AnthropicPromptFormat.d.ts

@@ -0,0 +1,11 @@
+import { ChatPrompt } from "../../prompt/chat/ChatPrompt.js";
+import { InstructionPrompt } from "../../prompt/InstructionPrompt.js";
+import { PromptFormat } from "../../prompt/PromptFormat.js";
+/**
+ * Formats an instruction prompt as an Anthropic prompt.
+ */
+export declare function mapInstructionPromptToAnthropicFormat(): PromptFormat<InstructionPrompt, string>;
+/**
+ * Formats a chat prompt as an Anthropic prompt.
+ */
+export declare function mapChatPromptToAnthropicFormat(): PromptFormat<ChatPrompt, string>;

package/model-provider/anthropic/AnthropicPromptFormat.js

@@ -0,0 +1,61 @@
+import { validateChatPrompt } from "../../prompt/chat/validateChatPrompt.js";
+/**
+ * Formats an instruction prompt as an Anthropic prompt.
+ */
+export function mapInstructionPromptToAnthropicFormat() {
+    return {
+        format: (instruction) => {
+            let text = "";
+            if (instruction.system != null) {
+                text += `${instruction.system}`;
+            }
+            text += "\n\nHuman:";
+            text += instruction.instruction;
+            if (instruction.input != null) {
+                // use tags per Anthropic instruction:
+                // https://docs.anthropic.com/claude/docs/constructing-a-prompt
+                text += `\n\n<data>${instruction.input}</data>`;
+            }
+            text += "\n\nAssistant:";
+            return text;
+        },
+        stopSequences: [],
+    };
+}
+/**
+ * Formats a chat prompt as an Anthropic prompt.
+ */
+export function mapChatPromptToAnthropicFormat() {
+    return {
+        format: (chatPrompt) => {
+            validateChatPrompt(chatPrompt);
+            let text = "";
+            for (let i = 0; i < chatPrompt.length; i++) {
+                const message = chatPrompt[i];
+                // system message:
+                if (i === 0 &&
+                    "system" in message &&
+                    typeof message.system === "string") {
+                    text += `${message.system}\n\n`;
+                    continue;
+                }
+                // user message
+                if ("user" in message) {
+                    text += `\n\nHuman:${message.user}`;
+                    continue;
+                }
+                // ai message:
+                if ("ai" in message) {
+                    text += `\n\nAssistant:${message.ai}`;
+                    continue;
+                }
+                // unsupported message:
+                throw new Error(`Unsupported message: ${JSON.stringify(message)}`);
+            }
+            // AI message prefix:
+            text += `\n\nAssistant:`;
+            return text;
+        },
+        stopSequences: [],
+    };
+}

package/model-provider/anthropic/AnthropicTextGenerationModel.cjs

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicTextGenerationResponseFormat = exports.AnthropicTextGenerationModel = exports.ANTHROPIC_TEXT_GENERATION_MODELS = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const PromptFormatTextStreamingModel_js_1 = require("../../prompt/PromptFormatTextStreamingModel.cjs");
+const AnthropicApiConfiguration_js_1 = require("./AnthropicApiConfiguration.cjs");
+const AnthropicError_js_1 = require("./AnthropicError.cjs");
+exports.ANTHROPIC_TEXT_GENERATION_MODELS = {
+    "claude-instant-1": {
+        contextWindowSize: 100000,
+    },
+    "claude-instant-1.2": {
+        contextWindowSize: 100000,
+    },
+    "claude-2": {
+        contextWindowSize: 100000,
+    },
+    "claude-2.0": {
+        contextWindowSize: 100000,
+    },
+};
+/**
+ * Create a text generation model that calls the Anthropic API.
+ *
+ * @see https://docs.anthropic.com/claude/reference/complete_post
+ */
+class AnthropicTextGenerationModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "anthropic"
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        this.contextWindowSize =
+            exports.ANTHROPIC_TEXT_GENERATION_MODELS[this.settings.model].contextWindowSize;
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    async callAPI(prompt, options) {
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callAnthropicTextGenerationAPI({
+                ...this.settings,
+                stopSequences: this.settings.stopSequences,
+                maxTokens: this.settings.maxCompletionTokens,
+                abortSignal: options.run?.abortSignal,
+                responseFormat: options.responseFormat,
+                prompt,
+            }),
+        });
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "maxCompletionTokens",
+            "stopSequences",
+            "temperature",
+            "topK",
+            "topP",
+            "userId",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.AnthropicTextGenerationResponseFormat.json,
+        });
+        return {
+            response,
+            text: response.completion,
+        };
+    }
+    doStreamText(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.AnthropicTextGenerationResponseFormat.deltaIterable,
+        });
+    }
+    withPromptFormat(promptFormat) {
+        return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
+            }),
+            promptFormat,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new AnthropicTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.AnthropicTextGenerationModel = AnthropicTextGenerationModel;
+const anthropicTextGenerationResponseSchema = zod_1.z.object({
+    completion: zod_1.z.string(),
+    stop_reason: zod_1.z.string(),
+    model: zod_1.z.string(),
+});
+async function callAnthropicTextGenerationAPI({ api = new AnthropicApiConfiguration_js_1.AnthropicApiConfiguration(), abortSignal, responseFormat, model, prompt, maxTokens, stopSequences, temperature, topK, topP, userId, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: api.assembleUrl(`/complete`),
+        headers: api.headers,
+        body: {
+            model,
+            prompt,
+            stream: responseFormat.stream,
+            max_tokens_to_sample: maxTokens,
+            temperature,
+            top_k: topK,
+            top_p: topP,
+            stop_sequences: stopSequences,
+            metadata: userId != null ? { user_id: userId } : undefined,
+        },
+        failedResponseHandler: AnthropicError_js_1.failedAnthropicCallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+const anthropicTextStreamingResponseSchema = zod_1.z.object({
+    completion: zod_1.z.string(),
+    stop_reason: zod_1.z.string().nullable(),
+    model: zod_1.z.string(),
+});
+async function createAnthropicFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue_js_1.AsyncQueue();
+    let content = "";
+    // process the stream asynchonously (no 'await' on purpose):
+    (0, parseEventSourceStream_js_1.parseEventSourceStream)({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                if (event.event === "error") {
+                    queue.push({ type: "error", error: event.data });
+                    queue.close();
+                    return;
+                }
+                if (event.event !== "completion") {
+                    continue;
+                }
+                const data = event.data;
+                const json = secure_json_parse_1.default.parse(data);
+                const parseResult = anthropicTextStreamingResponseSchema.safeParse(json);
+                if (!parseResult.success) {
+                    queue.push({
+                        type: "error",
+                        error: parseResult.error,
+                    });
+                    queue.close();
+                    return;
+                }
+                const eventData = parseResult.data;
+                content += eventData.completion;
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content,
+                        isComplete: eventData.stop_reason != null,
+                        delta: eventData.completion,
+                    },
+                    valueDelta: eventData.completion,
+                });
+                if (eventData.stop_reason != null) {
+                    queue.close();
+                }
+            }
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+    });
+    return queue;
+}
+exports.AnthropicTextGenerationResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: (0, postToApi_js_1.createJsonResponseHandler)(anthropicTextGenerationResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true,
+        handler: async ({ response }) => createAnthropicFullDeltaIterableQueue(response.body),
+    },
+};