@volcengine/ark-runtime 1.0.0

package/dist/cjs/index.js

@@ -0,0 +1,1717 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    E2eeClient: ()=>E2eeClient,
+    EventStreamDecoder: ()=>EventStreamDecoder,
+    ErrBodyWithoutProjectName: ()=>ErrBodyWithoutProjectName,
+    Breaker: ()=>Breaker,
+    ErrBodyWithoutEndpoint: ()=>ErrBodyWithoutEndpoint,
+    ChatMessageRoleTool: ()=>"tool",
+    ErrorRetryMaxDelayMs: ()=>8000,
+    ObjectTypeFile: ()=>"file",
+    StatusFailed: ()=>"failed",
+    genRequestId: ()=>genRequestId,
+    ErrAKSKNotSupported: ()=>ErrAKSKNotSupported,
+    getCertInfo: ()=>getCertInfo,
+    ErrBodyWithoutBot: ()=>ErrBodyWithoutBot,
+    ErrorRetryBaseDelayMs: ()=>500,
+    ImageGenerationStreamEventPartialSucceeded: ()=>ImageGenerationStreamEventPartialSucceeded,
+    deepCopyRequest: ()=>deepCopyRequest,
+    encryptChatRequest: ()=>encryptChatRequest,
+    aesGcmEncrypt: ()=>aesGcmEncrypt,
+    ErrTooManyEmptyStreamMessages: ()=>ErrTooManyEmptyStreamMessages,
+    checkIsModeAICC: ()=>checkIsModeAICC,
+    retry: ()=>retry,
+    ArkRequestError: ()=>ArkRequestError,
+    ArkRuntimeClient: ()=>ArkRuntimeClient,
+    DefaultStsTimeout: ()=>604800,
+    FileStatusActive: ()=>"active",
+    RetryAfterHeader: ()=>RetryAfterHeader,
+    decryptChatResponse: ()=>decryptChatResponse,
+    ToolChoiceAuto: ()=>"auto",
+    ModelBreakerProvider: ()=>ModelBreakerProvider,
+    ErrChatCompletionStreamNotSupported: ()=>ErrChatCompletionStreamNotSupported,
+    FileStatusFailed: ()=>"failed",
+    ArkAPIError: ()=>ArkAPIError,
+    StatusQueued: ()=>"queued",
+    base64ToEmbeddingResponse: ()=>base64ToEmbeddingResponse,
+    responses: ()=>responses_namespaceObject,
+    DefaultMandatoryRefreshTimeout: ()=>600,
+    ChatMessageRoleAssistant: ()=>ChatMessageRoleAssistant,
+    GenerateImagesResponseFormatBase64: ()=>GenerateImagesResponseFormatBase64,
+    ChatCompletionStreamReader: ()=>ChatCompletionStreamReader,
+    aesGcmEncryptBase64: ()=>aesGcmEncryptBase64,
+    ClientSessionTokenHeader: ()=>ClientSessionTokenHeader,
+    BotChatCompletionStreamReader: ()=>BotChatCompletionStreamReader,
+    ObjectTypeList: ()=>"list",
+    FileStatusProcessing: ()=>FileStatusProcessing,
+    ImageGenerationStreamEventCompleted: ()=>ImageGenerationStreamEventCompleted,
+    OrderDesc: ()=>"desc",
+    ToolChoiceRequired: ()=>ToolChoiceRequired,
+    ImageGenerationStreamReader: ()=>ImageGenerationStreamReader,
+    ChatMessageRoleSystem: ()=>"system",
+    ClientRequestHeader: ()=>ClientRequestHeader,
+    KeyAgreementClient: ()=>KeyAgreementClient,
+    GenerateImagesSizeAdaptive: ()=>GenerateImagesSizeAdaptive,
+    ImageGenerationStreamEventPartialFailed: ()=>ImageGenerationStreamEventPartialFailed,
+    PurposeUserData: ()=>PurposeUserData,
+    aesGcmDecrypt: ()=>aesGcmDecrypt,
+    decodeBase64Embedding: ()=>decodeBase64Embedding,
+    saveToLocalCertificate: ()=>saveToLocalCertificate,
+    DefaultAdvisoryRefreshTimeout: ()=>1800,
+    ClientEncryptInfoHeader: ()=>ClientEncryptInfoHeader,
+    StatusRunning: ()=>StatusRunning,
+    decryptChatStreamResponse: ()=>decryptChatStreamResponse,
+    ToolChoiceNone: ()=>"none",
+    ErrContentFieldsMisused: ()=>ErrContentFieldsMisused,
+    ClientIsEncryptedHeader: ()=>ClientIsEncryptedHeader,
+    loadLocalCertificate: ()=>loadLocalCertificate,
+    OrderAsc: ()=>"asc",
+    GenerateImagesResponseFormatURL: ()=>"url",
+    ChatMessageRoleUser: ()=>"user",
+    ResponsesStreamReader: ()=>ResponsesStreamReader,
+    StatusSucceeded: ()=>StatusSucceeded,
+    aesGcmDecryptBase64: ()=>aesGcmDecryptBase64,
+    MaxRetryDelay: ()=>8,
+    StatusCancelled: ()=>StatusCancelled,
+    InitialRetryDelay: ()=>0.5
+});
+var responses_namespaceObject = {};
+__webpack_require__.r(responses_namespaceObject);
+__webpack_require__.d(responses_namespaceObject, {
+    ContentItemType_input_audio: ()=>ContentItemType_input_audio,
+    ContentItemType_input_file: ()=>ContentItemType_input_file,
+    ContentItemType_input_image: ()=>ContentItemType_input_image,
+    ContentItemType_input_text: ()=>ContentItemType_input_text,
+    ContentItemType_input_video: ()=>ContentItemType_input_video,
+    ContentItemType_output_text: ()=>ContentItemType_output_text,
+    ContentItemType_summary_text: ()=>ContentItemType_summary_text,
+    MessageRole_assistant: ()=>MessageRole_assistant,
+    MessageRole_developer: ()=>MessageRole_developer,
+    MessageRole_system: ()=>"system",
+    MessageRole_user: ()=>"user",
+    getEventType: ()=>getEventType,
+    isDelta: ()=>isDelta,
+    isDeltaDone: ()=>isDeltaDone,
+    isResponseDone: ()=>isResponseDone
+});
+const external_axios_namespaceObject = require("axios");
+var external_axios_default = /*#__PURE__*/ __webpack_require__.n(external_axios_namespaceObject);
+const external_fs_namespaceObject = require("fs");
+const external_https_namespaceObject = require("https");
+const external_crypto_namespaceObject = require("crypto");
+function genRequestId() {
+    const now = new Date();
+    const ts = now.getFullYear().toString() + String(now.getMonth() + 1).padStart(2, "0") + String(now.getDate()).padStart(2, "0") + String(now.getHours()).padStart(2, "0") + String(now.getMinutes()).padStart(2, "0") + String(now.getSeconds()).padStart(2, "0");
+    const hex = (0, external_crypto_namespaceObject.randomBytes)(10).toString("hex");
+    return ts + hex;
+}
+function calculateRetryDelay(attemptNumber, minRetryDelay, maxRetryDelay) {
+    const base = Math.min(minRetryDelay * Math.pow(2, attemptNumber - 1), maxRetryDelay);
+    return Math.floor(Math.min(maxRetryDelay, base + Math.random() * base));
+}
+async function retry(policy, fn, isRetryable, signal) {
+    let lastError;
+    for(let attempt = 0; attempt <= policy.maxAttempts; attempt++)try {
+        return await fn();
+    } catch (err) {
+        lastError = err;
+        if (!isRetryable(err)) throw err;
+        if (attempt === policy.maxAttempts) break;
+        const delayMs = calculateRetryDelay(attempt + 1, policy.initialBackoffMs, policy.maxBackoffMs);
+        await sleep(delayMs, signal);
+    }
+    throw lastError;
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject)=>{
+        if (signal?.aborted) return void reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", ()=>{
+            clearTimeout(timer);
+            reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        }, {
+            once: true
+        });
+    });
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class Breaker {
+    allow(waitIndex) {
+        const elapsed = (Date.now() - this.allowTime) / 1000;
+        if (elapsed <= 0) return false;
+        if (elapsed > 10) return true;
+        return waitIndex < Math.pow(2, elapsed);
+    }
+    getAllowedDelayMs() {
+        const delay = this.allowTime - Date.now();
+        return delay < 1000 ? 1000 : delay;
+    }
+    reset(durationMs) {
+        this.allowTime = Date.now() + durationMs;
+    }
+    async wait() {
+        const id = String(this.nextIndex++);
+        const idx = this.waiters.size;
+        this.waiters.set(id, idx);
+        try {
+            while(!this.allow(idx))await new Promise((r)=>setTimeout(r, this.getAllowedDelayMs()));
+        } finally{
+            this.waiters.delete(id);
+        }
+    }
+    constructor(){
+        _define_property(this, "allowTime", void 0);
+        _define_property(this, "waiters", new Map());
+        _define_property(this, "nextIndex", 0);
+        this.allowTime = Date.now();
+    }
+}
+function breaker_provider_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ModelBreakerProvider {
+    getOrCreate(model) {
+        let breaker = this.breakers.get(model);
+        if (!breaker) {
+            breaker = new Breaker();
+            this.breakers.set(model, breaker);
+        }
+        return breaker;
+    }
+    constructor(){
+        breaker_provider_define_property(this, "breakers", new Map());
+    }
+}
+function sse_decoder_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+var _computedKey;
+_computedKey = Symbol.asyncIterator;
+let _computedKey1 = _computedKey;
+class EventStreamDecoder {
+    async *[_computedKey1]() {
+        const lines = this.readLines();
+        let event = "";
+        let dataLines = [];
+        for await (const line of lines){
+            if ("" === line) {
+                if (dataLines.length > 0) yield {
+                    event,
+                    data: dataLines.join("\n")
+                };
+                event = "";
+                dataLines = [];
+                continue;
+            }
+            if (line.startsWith(":")) continue;
+            const colonIdx = line.indexOf(":");
+            let field;
+            let value;
+            if (-1 === colonIdx) {
+                field = line;
+                value = "";
+            } else {
+                field = line.slice(0, colonIdx);
+                value = line.slice(colonIdx + 1);
+                if (value.startsWith(" ")) value = value.slice(1);
+            }
+            switch(field){
+                case "event":
+                    event = value;
+                    break;
+                case "data":
+                    dataLines.push(value);
+                    break;
+            }
+        }
+        if (dataLines.length > 0) yield {
+            event,
+            data: dataLines.join("\n")
+        };
+    }
+    async *readLines() {
+        const chunks = this.iterateStream();
+        for await (const chunk of chunks){
+            this.buffer += "string" == typeof chunk ? chunk : this.decoder.decode(chunk, {
+                stream: true
+            });
+            const lines = this.buffer.split("\n");
+            this.buffer = lines.pop() ?? "";
+            for (const line of lines)yield line.endsWith("\r") ? line.slice(0, -1) : line;
+        }
+        if (this.buffer.length > 0) {
+            yield this.buffer;
+            this.buffer = "";
+        }
+    }
+    async *iterateStream() {
+        const stream = this.stream;
+        if ("function" == typeof stream.getReader) {
+            this.reader = stream.getReader();
+            try {
+                while(true){
+                    const { done, value } = await this.reader.read();
+                    if (done) break;
+                    if (value) yield value;
+                }
+            } finally{
+                this.reader.releaseLock();
+                this.reader = null;
+            }
+            return;
+        }
+        if (Symbol.asyncIterator in stream) {
+            for await (const chunk of stream)yield chunk;
+            return;
+        }
+        throw new Error("Unsupported stream type");
+    }
+    cancel() {
+        this.reader?.cancel();
+    }
+    constructor(stream){
+        sse_decoder_define_property(this, "stream", void 0);
+        sse_decoder_define_property(this, "reader", void 0);
+        sse_decoder_define_property(this, "decoder", void 0);
+        sse_decoder_define_property(this, "buffer", void 0);
+        this.stream = stream;
+        this.reader = null;
+        this.decoder = new TextDecoder();
+        this.buffer = "";
+    }
+}
+function http_request_error_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class HttpRequestError extends Error {
+    constructor(name = "Exception", message, status, data, originalError){
+        super(message), http_request_error_define_property(this, "status", void 0), http_request_error_define_property(this, "data", void 0), http_request_error_define_property(this, "originalError", void 0), http_request_error_define_property(this, "name", void 0);
+        this.name = name;
+        this.status = status;
+        this.data = data;
+        this.originalError = originalError;
+        if (Error.captureStackTrace) Error.captureStackTrace(this, HttpRequestError);
+    }
+}
+function error_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ArkAPIError extends HttpRequestError {
+    get httpStatusCode() {
+        return this.status ?? 0;
+    }
+    toString() {
+        return `Error code: ${this.httpStatusCode} - ${JSON.stringify({
+            code: this.code,
+            message: this.message,
+            param: this.param,
+            type: this.type,
+            request_id: this.requestId
+        })}`;
+    }
+    constructor(opts){
+        super("ApiException", opts.message, opts.httpStatusCode, void 0, void 0), error_define_property(this, "code", void 0), error_define_property(this, "param", void 0), error_define_property(this, "type", void 0), error_define_property(this, "requestId", void 0);
+        this.name = "ArkAPIError";
+        this.code = opts.code;
+        this.param = opts.param;
+        this.type = opts.type;
+        this.requestId = opts.requestId;
+    }
+}
+class ArkRequestError extends HttpRequestError {
+    get httpStatusCode() {
+        return this.status ?? 0;
+    }
+    toString() {
+        return `RequestError code: ${this.httpStatusCode}, err: ${this.originalError?.message ?? this.message}, request_id: ${this.requestId}`;
+    }
+    constructor(opts){
+        super("NetworkError", opts.message, opts.httpStatusCode, void 0, opts.cause), error_define_property(this, "requestId", void 0);
+        this.name = "ArkRequestError";
+        this.requestId = opts.requestId;
+    }
+}
+const ErrTooManyEmptyStreamMessages = new Error("stream has sent too many empty messages");
+const ErrChatCompletionStreamNotSupported = new Error("streaming is not supported with this method, please use CreateChatCompletionStream");
+const ErrContentFieldsMisused = new Error("can't use both Content and MultiContent properties simultaneously");
+const ErrBodyWithoutEndpoint = new Error("can't fetch endpoint sts token without endpoint");
+const ErrBodyWithoutBot = new Error("can't fetch bot sts token without bot id");
+const ErrAKSKNotSupported = new Error("ak&sk authentication is currently not supported for this method, please use api key instead");
+const ErrBodyWithoutProjectName = new Error("project name is required for preset endpoint");
+const external_path_namespaceObject = require("path");
+const external_os_namespaceObject = require("os");
+function key_agreement_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const AES_KEY_SIZE = 32;
+const AES_NONCE_SIZE = 12;
+const CIPHER_VERSION_AICC_V01 = "AICCv01";
+class KeyAgreementClient {
+    generateECIESKeyPair() {
+        const ecdh = external_crypto_namespaceObject.createECDH("prime256v1");
+        ecdh.generateKeys();
+        const serverPubKeyDer = this.serverPublicKey.export({
+            type: "spki",
+            format: "der"
+        });
+        const serverPubKey = extractRawPublicKeyFromSPKI(serverPubKeyDer);
+        const sharedSecret = ecdh.computeSecret(serverPubKey);
+        const keyMaterial = hkdfExpand(sharedSecret, AES_KEY_SIZE + AES_NONCE_SIZE);
+        const sessionToken = ecdh.getPublicKey("base64");
+        return [
+            keyMaterial,
+            sessionToken
+        ];
+    }
+    constructor(pemCert){
+        key_agreement_define_property(this, "serverPublicKey", void 0);
+        const x509 = new external_crypto_namespaceObject.X509Certificate(pemCert);
+        this.serverPublicKey = x509.publicKey;
+    }
+}
+function extractRawPublicKeyFromSPKI(spkiDer) {
+    const uncompressedKeyLen = 65;
+    if (spkiDer.length >= uncompressedKeyLen) return spkiDer.subarray(spkiDer.length - uncompressedKeyLen);
+    return spkiDer;
+}
+function hkdfExpand(ikm, length) {
+    const derivedKey = external_crypto_namespaceObject.hkdfSync("sha256", ikm, Buffer.alloc(0), Buffer.alloc(0), length);
+    return Buffer.from(derivedKey);
+}
+function aesGcmEncrypt(key, nonce, plaintext) {
+    const cipher = external_crypto_namespaceObject.createCipheriv("aes-256-gcm", key, nonce);
+    const encrypted = Buffer.concat([
+        cipher.update(plaintext),
+        cipher.final()
+    ]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([
+        encrypted,
+        tag
+    ]);
+}
+function aesGcmDecrypt(key, nonce, ciphertext) {
+    const tagLength = 16;
+    const encrypted = ciphertext.subarray(0, ciphertext.length - tagLength);
+    const tag = ciphertext.subarray(ciphertext.length - tagLength);
+    const decipher = external_crypto_namespaceObject.createDecipheriv("aes-256-gcm", key, nonce);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([
+        decipher.update(encrypted),
+        decipher.final()
+    ]);
+}
+function aesGcmEncryptBase64(key, nonce, plaintext) {
+    const encrypted = aesGcmEncrypt(key, nonce, Buffer.from(plaintext, "utf-8"));
+    return encrypted.toString("base64");
+}
+function aesGcmDecryptBase64(key, nonce, ciphertext) {
+    const cipherBuf = Buffer.from(ciphertext, "base64");
+    const decrypted = aesGcmDecrypt(key, nonce, cipherBuf);
+    return decrypted.toString("utf-8");
+}
+function getCertInfo(certPem) {
+    try {
+        const x509 = new external_crypto_namespaceObject.X509Certificate(certPem);
+        const altNames = x509.subjectAltName ?? "";
+        const dnsNames = [];
+        for (const part of altNames.split(",")){
+            const trimmed = part.trim();
+            if (trimmed.startsWith("DNS:")) dnsNames.push(trimmed.substring(4));
+        }
+        const expireTime = Math.floor(new Date(x509.validTo).getTime() / 1000);
+        if (dnsNames.length > 1 && dnsNames[0].startsWith("ring.") && dnsNames[1].startsWith("key.")) return {
+            ringId: dnsNames[0].substring(5),
+            keyId: dnsNames[1].substring(4),
+            expireTime
+        };
+        return {
+            ringId: "",
+            keyId: "",
+            expireTime
+        };
+    } catch  {
+        return {
+            ringId: "",
+            keyId: "",
+            expireTime: 0
+        };
+    }
+}
+function checkIsModeAICC() {
+    return "AICC" === process.env.VOLC_ARK_ENCRYPTION;
+}
+function loadLocalCertificate(model) {
+    if (!model || /[/\\:..]/.test(model)) return null;
+    const dir = external_path_namespaceObject.join(external_os_namespaceObject.homedir(), ".ark", "certificates");
+    const certPath = external_path_namespaceObject.join(dir, `${model}.pem`);
+    try {
+        const stat = external_fs_namespaceObject.statSync(certPath);
+        const age = Date.now() - stat.mtimeMs;
+        if (age > 1209600000) {
+            external_fs_namespaceObject.unlinkSync(certPath);
+            return null;
+        }
+        const certPem = external_fs_namespaceObject.readFileSync(certPath, "utf-8");
+        const { ringId, keyId } = getCertInfo(certPem);
+        const aiccEnabled = checkIsModeAICC();
+        if (("" === ringId || "" === keyId) && !aiccEnabled) return certPem;
+        if ("" !== ringId && "" !== keyId && aiccEnabled) return certPem;
+        external_fs_namespaceObject.unlinkSync(certPath);
+        return null;
+    } catch  {
+        return null;
+    }
+}
+function saveToLocalCertificate(model, certPem) {
+    if (!model || /[/\\:..]/.test(model)) return;
+    const dir = external_path_namespaceObject.join(external_os_namespaceObject.homedir(), ".ark", "certificates");
+    external_fs_namespaceObject.mkdirSync(dir, {
+        recursive: true
+    });
+    const certPath = external_path_namespaceObject.join(dir, `${model}.pem`);
+    external_fs_namespaceObject.writeFileSync(certPath, certPem, "utf-8");
+}
+class E2eeClient {
+    generateECIESKeyPair() {
+        return this.cipher.generateECIESKeyPair();
+    }
+    getEncryptInfo() {
+        return JSON.stringify(this.info);
+    }
+    getExpireTime() {
+        return this.info.expire_time;
+    }
+    constructor(certificate){
+        key_agreement_define_property(this, "certificate", void 0);
+        key_agreement_define_property(this, "cipher", void 0);
+        key_agreement_define_property(this, "info", void 0);
+        key_agreement_define_property(this, "isAICC", void 0);
+        this.certificate = certificate;
+        this.cipher = new KeyAgreementClient(certificate);
+        const { ringId, keyId, expireTime } = getCertInfo(certificate);
+        this.info = {
+            expire_time: expireTime
+        };
+        this.isAICC = false;
+        if (ringId && keyId) {
+            this.info.version = CIPHER_VERSION_AICC_V01;
+            this.info.ring_id = ringId;
+            this.info.key_id = keyId;
+            this.isAICC = true;
+        }
+    }
+}
+const encrypt_chat_AES_KEY_SIZE = 32;
+const encrypt_chat_AES_NONCE_SIZE = 12;
+function encryptURL(urlString, fn) {
+    try {
+        const parsed = new URL(urlString);
+        if ([
+            "https:",
+            "http:",
+            "file:",
+            "ftp:"
+        ].includes(parsed.protocol)) return urlString;
+    } catch  {}
+    if (urlString.startsWith("data:")) return fn(urlString);
+    return urlString;
+}
+function processMessageContent(content, fn) {
+    if (null == content) return content;
+    if ("string" == typeof content) return fn(content);
+    for (const part of content){
+        if ("text" === part.type && part.text) part.text = fn(part.text);
+        if ("image_url" === part.type && part.image_url?.url) part.image_url.url = encryptURL(part.image_url.url, fn);
+    }
+    return content;
+}
+function deepCopyRequest(request) {
+    return JSON.parse(JSON.stringify(request));
+}
+function encryptChatRequest(keyNonce, request) {
+    if (keyNonce.length !== encrypt_chat_AES_KEY_SIZE + encrypt_chat_AES_NONCE_SIZE) throw new Error(`keyNonce must be ${encrypt_chat_AES_KEY_SIZE + encrypt_chat_AES_NONCE_SIZE} bytes, got ${keyNonce.length}`);
+    const key = keyNonce.subarray(0, encrypt_chat_AES_KEY_SIZE);
+    const nonce = keyNonce.subarray(encrypt_chat_AES_KEY_SIZE);
+    const fn = (text)=>aesGcmEncryptBase64(key, nonce, text);
+    for (const msg of request.messages ?? [])if (null != msg.content) msg.content = processMessageContent(msg.content, fn);
+}
+function decryptChatResponse(keyNonce, response) {
+    if (keyNonce.length !== encrypt_chat_AES_KEY_SIZE + encrypt_chat_AES_NONCE_SIZE) throw new Error(`keyNonce must be ${encrypt_chat_AES_KEY_SIZE + encrypt_chat_AES_NONCE_SIZE} bytes, got ${keyNonce.length}`);
+    const key = keyNonce.subarray(0, encrypt_chat_AES_KEY_SIZE);
+    const nonce = keyNonce.subarray(encrypt_chat_AES_KEY_SIZE);
+    const fn = (text)=>aesGcmDecryptBase64(key, nonce, text);
+    for (const choice of response.choices ?? [])if ("content_filter" !== choice.finish_reason) {
+        if (choice.message?.content != null) choice.message.content = processMessageContent(choice.message.content, fn);
+    }
+}
+function decryptChatStreamResponse(keyNonce, response) {
+    if (keyNonce.length !== encrypt_chat_AES_KEY_SIZE + encrypt_chat_AES_NONCE_SIZE) throw new Error(`keyNonce must be ${encrypt_chat_AES_KEY_SIZE + encrypt_chat_AES_NONCE_SIZE} bytes, got ${keyNonce.length}`);
+    const key = keyNonce.subarray(0, encrypt_chat_AES_KEY_SIZE);
+    const nonce = keyNonce.subarray(encrypt_chat_AES_KEY_SIZE);
+    const fn = (text)=>aesGcmDecryptBase64(key, nonce, text);
+    for (const choice of response.choices ?? [])if ("content_filter" !== choice.finish_reason) {
+        if (choice.delta?.content && "string" == typeof choice.delta.content) choice.delta.content = fn(choice.delta.content);
+    }
+}
+function normalizeChatCompletionResponse(resp) {
+    if (resp.choices) for (const choice of resp.choices)normalizeChatCompletionChoice(choice);
+    return resp;
+}
+function normalizeChatCompletionChoice(choice) {
+    if (choice.message && !("name" in choice.message)) choice.message.name = null;
+    if ("logprobs" in choice && (null === choice.logprobs || void 0 === choice.logprobs)) delete choice.logprobs;
+    if (!("finish_reason" in choice)) choice.finish_reason = null;
+}
+function normalizeChatCompletionStreamChunk(chunk) {
+    if (chunk.choices) for (const choice of chunk.choices)normalizeStreamChoice(choice);
+    if ("usage" in chunk && (null === chunk.usage || void 0 === chunk.usage)) delete chunk.usage;
+    return chunk;
+}
+function normalizeStreamChoice(choice) {
+    if (!("finish_reason" in choice)) choice.finish_reason = null;
+    if ("logprobs" in choice && (null === choice.logprobs || void 0 === choice.logprobs)) delete choice.logprobs;
+    if (choice.delta) {
+        if ("content" in choice.delta && "" === choice.delta.content) delete choice.delta.content;
+        if ("role" in choice.delta && "" === choice.delta.role) delete choice.delta.role;
+    }
+}
+function normalizeEmbeddingResponse(resp) {
+    if (resp.usage) normalizeUsage(resp.usage);
+    return resp;
+}
+function normalizeUsage(usage) {
+    if (void 0 === usage.completion_tokens || null === usage.completion_tokens) usage.completion_tokens = 0;
+    if (!usage.prompt_tokens_details) usage.prompt_tokens_details = {
+        cached_tokens: 0
+    };
+    if (!usage.completion_tokens_details) usage.completion_tokens_details = {
+        reasoning_tokens: 0
+    };
+}
+function stream_reader_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+var stream_reader_computedKey, stream_reader_computedKey1, _computedKey2, _computedKey3;
+const ERROR_PREFIX = '{"error":';
+class BaseStreamReader {
+    close() {
+        this.isFinished = true;
+        this.cleanup?.();
+        this.cleanup = void 0;
+    }
+    constructor(stream, emptyMessagesLimit, headers, cleanup){
+        stream_reader_define_property(this, "stream", void 0);
+        stream_reader_define_property(this, "emptyMessagesLimit", void 0);
+        stream_reader_define_property(this, "headers", void 0);
+        stream_reader_define_property(this, "isFinished", void 0);
+        stream_reader_define_property(this, "emptyMessagesCount", void 0);
+        stream_reader_define_property(this, "cleanup", void 0);
+        this.stream = stream;
+        this.emptyMessagesLimit = emptyMessagesLimit;
+        this.headers = headers;
+        this.isFinished = false;
+        this.emptyMessagesCount = 0;
+        this.cleanup = cleanup;
+    }
+}
+stream_reader_computedKey = Symbol.asyncIterator;
+let _computedKey4 = stream_reader_computedKey;
+class DataLineStreamReader extends BaseStreamReader {
+    async *[_computedKey4]() {
+        const chunks = this.iterateChunks();
+        let errBuffer = "";
+        let hasError = false;
+        for await (const rawLine of this.readLines(chunks)){
+            if (this.isFinished) return;
+            const trimmed = rawLine.trim();
+            if ("" === trimmed) continue;
+            let dataContent = null;
+            if (trimmed.startsWith("data:")) dataContent = trimmed.slice(5).trim();
+            if (dataContent && dataContent.startsWith(ERROR_PREFIX)) {
+                hasError = true;
+                errBuffer += dataContent;
+                continue;
+            }
+            if (hasError) {
+                errBuffer += trimmed.startsWith("data:") ? trimmed.slice(5).trim() : trimmed;
+                continue;
+            }
+            if (null === dataContent) {
+                this.emptyMessagesCount++;
+                if (this.emptyMessagesCount > this.emptyMessagesLimit) throw ErrTooManyEmptyStreamMessages;
+                continue;
+            }
+            if ("[DONE]" === dataContent) return void this.close();
+            const parsed = JSON.parse(dataContent);
+            this.emptyMessagesCount = 0;
+            yield parsed;
+        }
+        if (hasError && errBuffer) {
+            const errResp = JSON.parse(errBuffer);
+            if (errResp.error) throw new ArkAPIError({
+                message: errResp.error.message,
+                code: errResp.error.code,
+                param: errResp.error.param,
+                type: errResp.error.type,
+                httpStatusCode: 0,
+                requestId: errResp.error.request_id ?? this.headers?.["x-client-request-id"] ?? ""
+            });
+        }
+    }
+    async *readLines(chunks) {
+        for await (const chunk of chunks){
+            this.buffer += chunk;
+            const lines = this.buffer.split("\n");
+            this.buffer = lines.pop() ?? "";
+            for (const line of lines)yield line;
+        }
+        if (this.buffer) {
+            yield this.buffer;
+            this.buffer = "";
+        }
+    }
+    async *iterateChunks() {
+        const stream = this.stream;
+        if ("function" == typeof stream.getReader) {
+            const reader = stream.getReader();
+            try {
+                while(true){
+                    const { done, value } = await reader.read();
+                    if (done) break;
+                    yield "string" == typeof value ? value : this.decoder.decode(value, {
+                        stream: true
+                    });
+                }
+            } finally{
+                reader.releaseLock();
+            }
+        } else if (Symbol.asyncIterator in stream) for await (const chunk of stream)yield "string" == typeof chunk ? chunk : this.decoder.decode(chunk, {
+            stream: true
+        });
+    }
+    constructor(...args){
+        super(...args), stream_reader_define_property(this, "decoder", new TextDecoder()), stream_reader_define_property(this, "buffer", "");
+    }
+}
+stream_reader_computedKey1 = Symbol.asyncIterator;
+let _computedKey5 = stream_reader_computedKey1;
+class ChatCompletionStreamReader extends DataLineStreamReader {
+    async *[_computedKey5]() {
+        for await (const chunk of this.iterateBase()){
+            if (this.keyNonce.length > 0) decryptChatStreamResponse(this.keyNonce, chunk);
+            yield normalizeChatCompletionStreamChunk(chunk);
+        }
+    }
+    async *iterateBase() {
+        yield* super[Symbol.asyncIterator]();
+    }
+    constructor(stream, emptyMessagesLimit, headers, keyNonce, cleanup){
+        super(stream, emptyMessagesLimit, headers, cleanup), stream_reader_define_property(this, "keyNonce", void 0);
+        this.keyNonce = keyNonce ?? Buffer.alloc(0);
+    }
+}
+_computedKey2 = Symbol.asyncIterator;
+class BotChatCompletionStreamReader extends DataLineStreamReader {
+    async *[_computedKey2]() {
+        for await (const chunk of this.iterateBase())yield normalizeChatCompletionStreamChunk(chunk);
+    }
+    async *iterateBase() {
+        yield* super[Symbol.asyncIterator]();
+    }
+}
+class ImageGenerationStreamReader extends DataLineStreamReader {
+}
+_computedKey3 = Symbol.asyncIterator;
+let _computedKey6 = _computedKey3;
+class ResponsesStreamReader extends BaseStreamReader {
+    async *[_computedKey6]() {
+        for await (const sseEvent of this.decoder){
+            if (this.isFinished) return;
+            const data = sseEvent.data.trim();
+            if (data.startsWith(ERROR_PREFIX)) {
+                const errResp = JSON.parse(data);
+                if (errResp.error) throw new ArkAPIError({
+                    message: errResp.error.message,
+                    code: errResp.error.code,
+                    param: errResp.error.param,
+                    type: errResp.error.type,
+                    httpStatusCode: 0,
+                    requestId: errResp.error.request_id ?? this.headers?.["x-client-request-id"] ?? ""
+                });
+                continue;
+            }
+            if (data.startsWith("[DONE]")) return void this.close();
+            const parsed = JSON.parse(data);
+            yield parsed;
+        }
+    }
+    close() {
+        super.close();
+        this.decoder.cancel();
+    }
+    constructor(stream, emptyMessagesLimit, headers, cleanup){
+        super(stream, emptyMessagesLimit, headers, cleanup), stream_reader_define_property(this, "decoder", void 0);
+        this.decoder = new EventStreamDecoder(stream);
+    }
+}
+const defaultBaseURL = "https://ark.cn-beijing.volces.com/api/v3";
+const defaultRegion = "cn-beijing";
+const defaultEmptyMessagesLimit = 300;
+const defaultRetryTimes = 2;
+const defaultTimeoutMs = 600000;
+const defaultBatchMaxParallel = 3000;
+const resourceTypeEndpoint = "endpoint";
+const resourceTypePresetEndpoint = "presetendpoint";
+function resolveConfig(config) {
+    let baseURL = config.baseURL ?? process.env.ARK_BASE_URL ?? defaultBaseURL;
+    if (baseURL.endsWith("/")) baseURL = baseURL.slice(0, -1);
+    return {
+        apiKey: config.apiKey ?? process.env.ARK_API_KEY ?? "",
+        ak: config.ak ?? "",
+        sk: config.sk ?? "",
+        region: config.region ?? defaultRegion,
+        baseURL,
+        httpClient: config.httpClient,
+        emptyMessagesLimit: config.emptyMessagesLimit ?? defaultEmptyMessagesLimit,
+        retryTimes: config.retryTimes ?? defaultRetryTimes,
+        timeout: config.timeout ?? defaultTimeoutMs,
+        batchMaxParallel: config.batchMaxParallel ?? defaultBatchMaxParallel
+    };
+}
+const ClientRequestHeader = "X-Client-Request-Id";
+const RetryAfterHeader = "Retry-After";
+const ClientSessionTokenHeader = "X-Session-Token";
+const ClientEncryptInfoHeader = "X-Encrypt-Info";
+const ClientIsEncryptedHeader = "x-is-encrypted";
+const PurposeUserData = "user_data";
+const FileStatusProcessing = "processing";
+function client_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const chatCompletionsSuffix = "/chat/completions";
+const botChatCompletionsSuffix = "/bots/chat/completions";
+const embeddingsSuffix = "/embeddings";
+const multimodalEmbeddingsSuffix = "/embeddings/multimodal";
+const generateImagesPath = "/images/generations";
+const tokenizationSuffix = "/tokenization";
+const contextCreateSuffix = "/context/create";
+const contextChatSuffix = "/context/chat/completions";
+const contentGenerationTaskPath = "/contents/generations/tasks";
+const filePrefix = "/files";
+const batchChatCompletionsSuffix = "/batch/chat/completions";
+const batchEmbeddingsSuffix = "/batch/embeddings";
+const batchMultiModalEmbeddingsSuffix = "/batch/embeddings/multimodal";
+const e2eGetCertificatePath = "/e2e/get/certificate";
+const FILE_SCHEME = "file";
+const POLL_INTERVAL_MS = 3000;
+const MAX_WAIT_TIME_MS = 600000;
+class ArkRuntimeClient {
+    static withApiKey(apiKey, config = {}) {
+        return new ArkRuntimeClient({
+            ...config,
+            apiKey
+        });
+    }
+    static withAkSk(ak, sk, config = {}) {
+        return new ArkRuntimeClient({
+            ...config,
+            ak,
+            sk
+        });
+    }
+    fullURL(suffix) {
+        return `${this.config.baseURL}${suffix}`;
+    }
+    isAPIKeyAuth() {
+        return this.config.apiKey.length > 0;
+    }
+    getResourceTypeById(resourceId) {
+        if (resourceId.startsWith("ep-m-")) return resourceTypePresetEndpoint;
+        if (resourceId.startsWith("ep-")) return resourceTypeEndpoint;
+        if (resourceId.startsWith("bot-")) return "bot";
+        return resourceTypePresetEndpoint;
+    }
+    stsKey(resourceType, resourceId) {
+        return `${resourceType}#${resourceId}`;
+    }
+    needRefresh(resourceType, resourceId, delta) {
+        const info = this.resourceStsTokens.get(this.stsKey(resourceType, resourceId));
+        if (!info) return true;
+        return info.expiredTime - Math.floor(Date.now() / 1000) < delta;
+    }
+    async refreshToken(resourceType, resourceId, projectName) {
+        if (!this.needRefresh(resourceType, resourceId, this.advisoryRefreshTimeout)) return;
+        if (this.refreshPromise) {
+            await this.refreshPromise;
+            if (!this.needRefresh(resourceType, resourceId, this.advisoryRefreshTimeout)) return;
+        }
+        this.refreshPromise = this.doRefresh(resourceType, resourceId, projectName);
+        try {
+            await this.refreshPromise;
+        } finally{
+            this.refreshPromise = null;
+        }
+    }
+    async doRefresh(resourceType, resourceId, projectName) {
+        try {
+            const { ARKClient } = await import("@volcengine/ark");
+            const { GetApiKeyCommand } = await import("@volcengine/ark");
+            const arkClient = new ARKClient({
+                accessKeyId: this.config.ak,
+                secretAccessKey: this.config.sk,
+                region: this.config.region
+            });
+            const input = {
+                DurationSeconds: 604800,
+                ResourceIds: [
+                    resourceId
+                ],
+                ResourceType: resourceType,
+                ...projectName ? {
+                    ProjectName: projectName
+                } : {}
+            };
+            const resp = await arkClient.send(new GetApiKeyCommand(input));
+            const result = resp.Result;
+            if (result?.ApiKey && result?.ExpiredTime) this.resourceStsTokens.set(this.stsKey(resourceType, resourceId), {
+                token: result.ApiKey,
+                expiredTime: result.ExpiredTime
+            });
+        } catch (err) {
+            const isMandatory = this.needRefresh(resourceType, resourceId, this.mandatoryRefreshTimeout);
+            if (isMandatory) throw err;
+        }
+    }
+    async getEndpointStsToken(endpointId) {
+        return this.getResourceStsToken(resourceTypeEndpoint, endpointId);
+    }
+    async getResourceStsToken(resourceType, resourceId, projectName) {
+        await this.refreshToken(resourceType, resourceId, projectName ?? "");
+        const info = this.resourceStsTokens.get(this.stsKey(resourceType, resourceId));
+        return info?.token ?? "";
+    }
+    async getAuthHeader(resourceType, resourceId, projectName) {
+        if (this.isAPIKeyAuth()) return {
+            Authorization: `Bearer ${this.config.apiKey}`
+        };
+        resourceType = this.getResourceTypeById(resourceId);
+        await this.refreshToken(resourceType, resourceId, projectName ?? "");
+        const info = this.resourceStsTokens.get(this.stsKey(resourceType, resourceId));
+        return {
+            Authorization: `Bearer ${info?.token ?? ""}`
+        };
+    }
+    retryPolicy() {
+        return {
+            maxAttempts: this.config.retryTimes,
+            initialBackoffMs: 500,
+            maxBackoffMs: 8000
+        };
+    }
+    isRetryable(err) {
+        if (err instanceof ArkAPIError) return err.httpStatusCode >= 500 || 429 === err.httpStatusCode;
+        if (err instanceof ArkRequestError) return err.httpStatusCode >= 500;
+        return false;
+    }
+    async executeRequest(method, url, resourceType, resourceId, opts) {
+        const authHeader = await this.getAuthHeader(resourceType, resourceId, opts?.projectName);
+        const requestId = genRequestId();
+        const headers = {
+            [ClientRequestHeader]: requestId,
+            "Content-Type": "application/json",
+            Accept: opts?.stream ? "text/event-stream" : "application/json",
+            ...authHeader,
+            ...opts?.customHeaders
+        };
+        if (opts?.stream) {
+            headers["Cache-Control"] = "no-cache";
+            headers["Connection"] = "keep-alive";
+        }
+        if (opts?.projectName) headers["X-Project-Name"] = opts.projectName;
+        const axiosConfig = {
+            method: method,
+            url,
+            headers,
+            data: opts?.body,
+            params: opts?.query,
+            signal: opts?.signal,
+            responseType: opts?.stream ? "stream" : "json",
+            validateStatus: ()=>true
+        };
+        const resp = await this.httpClient.request(axiosConfig);
+        if (resp.status < 200 || resp.status >= 400) this.handleErrorResponse(resp, requestId);
+        return resp;
+    }
+    handleErrorResponse(resp, requestId) {
+        let errData;
+        try {
+            errData = "string" == typeof resp.data ? JSON.parse(resp.data) : resp.data;
+        } catch  {
+            throw new ArkRequestError({
+                httpStatusCode: resp.status,
+                message: `Request failed with status ${resp.status}`,
+                requestId
+            });
+        }
+        if (errData?.error) throw new ArkAPIError({
+            message: errData.error.message ?? "Unknown error",
+            code: errData.error.code,
+            param: errData.error.param,
+            type: errData.error.type ?? "unknown",
+            httpStatusCode: resp.status,
+            requestId: errData.error.request_id ?? resp.headers?.[ClientRequestHeader.toLowerCase()] ?? requestId
+        });
+        throw new ArkRequestError({
+            httpStatusCode: resp.status,
+            message: `Request failed with status ${resp.status}`,
+            requestId
+        });
+    }
+    async getE2eeClient(resourceId, authorization) {
+        const cached = this.e2eeManager.get(resourceId);
+        if (cached && cached.isAICC === checkIsModeAICC()) return cached;
+        const existing = this.e2eeFlightMap.get(resourceId);
+        if (existing) return existing;
+        const promise = this.doLoadE2eeClient(resourceId, authorization);
+        this.e2eeFlightMap.set(resourceId, promise);
+        try {
+            const client = await promise;
+            return client;
+        } finally{
+            this.e2eeFlightMap.delete(resourceId);
+        }
+    }
+    async doLoadE2eeClient(resourceId, authorization) {
+        const cached = this.e2eeManager.get(resourceId);
+        if (cached && cached.isAICC === checkIsModeAICC()) return cached;
+        let certPem = loadLocalCertificate(resourceId);
+        if (!certPem) {
+            certPem = await this.loadServerCertificate(resourceId, authorization);
+            saveToLocalCertificate(resourceId, certPem);
+        }
+        const client = new E2eeClient(certPem);
+        this.e2eeManager.set(resourceId, client);
+        return client;
+    }
+    async loadServerCertificate(resourceId, authorization) {
+        const url = this.fullURL(e2eGetCertificatePath);
+        const body = {
+            model: resourceId
+        };
+        if (checkIsModeAICC()) body.type = "AICCv0.1";
+        const resp = await this.httpClient.request({
+            method: "POST",
+            url,
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                Authorization: authorization,
+                [ClientSessionTokenHeader]: e2eGetCertificatePath
+            },
+            data: body,
+            validateStatus: ()=>true
+        });
+        if (resp.status < 200 || resp.status >= 400) throw new Error(`getting Certificate failed: HTTP ${resp.status}`);
+        const cr = resp.data;
+        if (cr.error && Object.keys(cr.error).length > 0) throw new Error(`getting Certificate failed: ${JSON.stringify(cr.error)}`);
+        return cr.Certificate;
+    }
+    async encryptRequestBody(resourceId, requestId, authorization, request) {
+        const e2eeClient = await this.getE2eeClient(resourceId, authorization);
+        const [keyNonce, sessionToken] = e2eeClient.generateECIESKeyPair();
+        const extraHeaders = {
+            [ClientSessionTokenHeader]: sessionToken
+        };
+        if (checkIsModeAICC()) extraHeaders[ClientEncryptInfoHeader] = e2eeClient.getEncryptInfo();
+        this.keyNonceMap.set(requestId, keyNonce);
+        const requestCopy = deepCopyRequest(request);
+        encryptChatRequest(keyNonce, requestCopy);
+        return {
+            body: requestCopy,
+            extraHeaders
+        };
+    }
+    async preprocessResponseInput(input) {
+        if (!input || "string" == typeof input || !Array.isArray(input)) return;
+        await this.preprocessResponseMultiModal(input);
+    }
+    async preprocessResponseMultiModal(inputItems) {
+        const tasks = [];
+        for (const item of inputItems){
+            if (!item || "message" !== item.type && !("role" in item && "content" in item)) continue;
+            const inputMessage = item;
+            if (inputMessage.content && Array.isArray(inputMessage.content)) for (const contentItem of inputMessage.content){
+                const fileUrl = this.getMultiModalFileUrl(contentItem);
+                if (fileUrl) tasks.push(this.preprocessResponseFile(contentItem, fileUrl));
+            }
+        }
+        if (tasks.length > 0) await Promise.all(tasks);
+    }
+    getMultiModalFileUrl(contentItem) {
+        if ("input_video" === contentItem.type) {
+            const video = contentItem;
+            if (video.video_url) return video.video_url;
+        } else if ("input_image" === contentItem.type) {
+            const image = contentItem;
+            if (image.image_url) return image.image_url;
+        } else if ("input_file" === contentItem.type) {
+            const file = contentItem;
+            if (file.file_url) return file.file_url;
+        }
+        return null;
+    }
+    parseFileUrl(rawUrl) {
+        try {
+            const parsed = new URL(rawUrl);
+            if (parsed.protocol !== `${FILE_SCHEME}:`) return null;
+            return parsed.pathname;
+        } catch  {
+            return null;
+        }
+    }
+    async preprocessResponseFile(contentItem, rawUrl) {
+        const localPath = this.parseFileUrl(rawUrl);
+        if (!localPath) return;
+        const fileStream = external_fs_namespaceObject.createReadStream(localPath);
+        try {
+            let fileMeta = await this.uploadFile({
+                file: fileStream,
+                purpose: PurposeUserData
+            });
+            const deadline = Date.now() + MAX_WAIT_TIME_MS;
+            while(fileMeta.status === FileStatusProcessing && Date.now() < deadline){
+                await new Promise((resolve)=>setTimeout(resolve, POLL_INTERVAL_MS));
+                fileMeta = await this.retrieveFile(fileMeta.id);
+            }
+            if ("input_video" === contentItem.type) {
+                const video = contentItem;
+                video.video_url = "";
+                video.file_id = fileMeta.id;
+            } else if ("input_image" === contentItem.type) {
+                const image = contentItem;
+                delete image.image_url;
+                image.file_id = fileMeta.id;
+            } else if ("input_file" === contentItem.type) {
+                const file = contentItem;
+                delete file.file_url;
+                file.file_id = fileMeta.id;
+            }
+        } finally{
+            fileStream.destroy();
+        }
+    }
+    async doRequest(method, url, resourceType, resourceId, opts) {
+        return retry(this.retryPolicy(), async ()=>{
+            const resp = await this.executeRequest(method, url, resourceType, resourceId, opts);
+            return resp.data;
+        }, (err)=>this.isRetryable(err), opts?.signal);
+    }
+    async doStreamRequest(method, url, resourceType, resourceId, opts) {
+        const resp = await retry(this.retryPolicy(), async ()=>this.executeRequest(method, url, resourceType, resourceId, {
+                ...opts,
+                stream: true
+            }), (err)=>this.isRetryable(err), opts?.signal);
+        const headers = {};
+        if (resp.headers) {
+            for (const [k, v] of Object.entries(resp.headers))if ("string" == typeof v) headers[k] = v;
+        }
+        return {
+            stream: resp.data,
+            headers
+        };
+    }
+    async createChatCompletion(request, opts) {
+        if (request.stream) throw ErrChatCompletionStreamNotSupported;
+        const resp = await this.doRequest("POST", this.fullURL(chatCompletionsSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+        return normalizeChatCompletionResponse(resp);
+    }
+    async createChatCompletionStream(request, opts) {
+        let body = {
+            ...request,
+            stream: true
+        };
+        let extraHeaders;
+        const isEncrypted = opts?.customHeaders?.[ClientIsEncryptedHeader] === "true";
+        const requestId = genRequestId();
+        if (isEncrypted) {
+            const authHeader = await this.getAuthHeader(resourceTypeEndpoint, request.model, opts?.projectName);
+            const result = await this.encryptRequestBody(request.model, requestId, authHeader.Authorization, body);
+            body = result.body;
+            extraHeaders = result.extraHeaders;
+        }
+        const mergedOpts = {
+            ...opts,
+            body,
+            customHeaders: {
+                ...opts?.customHeaders,
+                ...extraHeaders
+            }
+        };
+        const { stream, headers } = await this.doStreamRequest("POST", this.fullURL(chatCompletionsSuffix), resourceTypeEndpoint, request.model, mergedOpts);
+        const keyNonce = this.keyNonceMap.get(requestId);
+        const cleanup = keyNonce ? ()=>{
+            this.keyNonceMap.delete(requestId);
+        } : void 0;
+        return new ChatCompletionStreamReader(stream, this.config.emptyMessagesLimit, headers, keyNonce, cleanup);
+    }
+    async createBotChatCompletion(request, opts) {
+        if (request.stream) throw ErrChatCompletionStreamNotSupported;
+        const model = request.bot_id || request.model;
+        const resp = await this.doRequest("POST", this.fullURL(botChatCompletionsSuffix), "bot", model, {
+            ...opts,
+            body: {
+                ...request,
+                model
+            }
+        });
+        return normalizeChatCompletionResponse(resp);
+    }
+    async createBotChatCompletionStream(request, opts) {
+        const model = request.bot_id || request.model;
+        const body = {
+            ...request,
+            model,
+            stream: true
+        };
+        const { stream, headers } = await this.doStreamRequest("POST", this.fullURL(botChatCompletionsSuffix), "bot", model, {
+            ...opts,
+            body
+        });
+        return new BotChatCompletionStreamReader(stream, this.config.emptyMessagesLimit, headers);
+    }
+    async createEmbeddings(request, opts) {
+        const resp = await this.doRequest("POST", this.fullURL(embeddingsSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+        return normalizeEmbeddingResponse(resp);
+    }
+    async createMultiModalEmbeddings(request, opts) {
+        return this.doRequest("POST", this.fullURL(multimodalEmbeddingsSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+    }
+    async generateImages(request, opts) {
+        if (!this.isAPIKeyAuth()) throw ErrAKSKNotSupported;
+        return this.doRequest("POST", this.fullURL(generateImagesPath), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+    }
+    async generateImagesStream(request, opts) {
+        if (!this.isAPIKeyAuth()) throw ErrAKSKNotSupported;
+        const body = {
+            ...request,
+            stream: true
+        };
+        const { stream, headers } = await this.doStreamRequest("POST", this.fullURL(generateImagesPath), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body
+        });
+        return new ImageGenerationStreamReader(stream, this.config.emptyMessagesLimit, headers);
+    }
+    async createTokenization(request, opts) {
+        return this.doRequest("POST", this.fullURL(tokenizationSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+    }
+    async createContext(request, opts) {
+        return this.doRequest("POST", this.fullURL(contextCreateSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+    }
+    async createContextChatCompletion(request, opts) {
+        if (request.stream) throw ErrChatCompletionStreamNotSupported;
+        const resp = await this.doRequest("POST", this.fullURL(contextChatSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+        return normalizeChatCompletionResponse(resp);
+    }
+    async createContextChatCompletionStream(request, opts) {
+        const body = {
+            ...request,
+            stream: true
+        };
+        const { stream, headers } = await this.doStreamRequest("POST", this.fullURL(contextChatSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body
+        });
+        return new ChatCompletionStreamReader(stream, this.config.emptyMessagesLimit, headers);
+    }
+    async createContentGenerationTask(request, opts) {
+        if (!this.isAPIKeyAuth()) throw ErrAKSKNotSupported;
+        return this.doRequest("POST", this.fullURL(contentGenerationTaskPath), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+    }
+    async getContentGenerationTask(taskId, opts) {
+        if (!this.isAPIKeyAuth()) throw ErrAKSKNotSupported;
+        return this.doRequest("GET", `${this.fullURL(contentGenerationTaskPath)}/${taskId}`, resourceTypeEndpoint, "", opts);
+    }
+    async deleteContentGenerationTask(taskId, opts) {
+        if (!this.isAPIKeyAuth()) throw ErrAKSKNotSupported;
+        await this.doRequest("DELETE", `${this.fullURL(contentGenerationTaskPath)}/${taskId}`, resourceTypeEndpoint, "", opts);
+    }
+    async listContentGenerationTasks(request, opts) {
+        if (!this.isAPIKeyAuth()) throw ErrAKSKNotSupported;
+        const query = {};
+        if (null != request.page_num) query.page_num = String(request.page_num);
+        if (null != request.page_size) query.page_size = String(request.page_size);
+        if (request.filter) {
+            if (request.filter.status) query["filter.status"] = request.filter.status;
+            if (request.filter.model) query["filter.model"] = request.filter.model;
+            if (request.filter.service_tier) query["filter.service_tier"] = request.filter.service_tier;
+            if (request.filter.task_ids?.length) query["filter.task_ids"] = request.filter.task_ids;
+        }
+        return this.doRequest("GET", this.fullURL(contentGenerationTaskPath), resourceTypeEndpoint, "", {
+            ...opts,
+            query: query
+        });
+    }
+    async createResponses(body, opts) {
+        await this.preprocessResponseInput(body.input);
+        return this.doRequest("POST", this.fullURL("/responses"), resourceTypeEndpoint, body.model, {
+            ...opts,
+            body
+        });
+    }
+    async createResponsesStream(body, opts) {
+        await this.preprocessResponseInput(body.input);
+        const streamBody = {
+            ...body,
+            stream: true
+        };
+        const { stream, headers } = await this.doStreamRequest("POST", this.fullURL("/responses"), resourceTypeEndpoint, body.model, {
+            ...opts,
+            body: streamBody
+        });
+        return new ResponsesStreamReader(stream, this.config.emptyMessagesLimit, headers);
+    }
+    async getResponses(responseId, query, opts) {
+        if (!responseId) throw new Error("missing required response_id parameter");
+        return this.doRequest("GET", this.fullURL(`/responses/${responseId}`), "", "", {
+            ...opts,
+            query: query
+        });
+    }
+    async deleteResponse(responseId, opts) {
+        if (!responseId) throw new Error("missing required response_id parameter");
+        await this.doRequest("DELETE", this.fullURL(`/responses/${responseId}`), "", "", opts);
+    }
+    async listResponseInputItems(responseId, query, opts) {
+        if (!responseId) throw new Error("missing required response_id parameter");
+        return this.doRequest("GET", this.fullURL(`/responses/${responseId}/input_items`), "", "", {
+            ...opts,
+            query: query
+        });
+    }
+    async uploadFile(request, opts) {
+        const formData = new FormData();
+        formData.append("file", request.file);
+        formData.append("purpose", request.purpose);
+        if (request.preprocess_configs) formData.append("preprocess_configs", JSON.stringify(request.preprocess_configs));
+        if (null != request.expire_at) formData.append("expire_at", String(request.expire_at));
+        const authHeader = await this.getAuthHeader("", "");
+        const requestId = genRequestId();
+        const resp = await this.httpClient.request({
+            method: "POST",
+            url: this.fullURL(filePrefix),
+            headers: {
+                [ClientRequestHeader]: requestId,
+                ...authHeader,
+                ...opts?.customHeaders
+            },
+            data: formData,
+            signal: opts?.signal,
+            validateStatus: ()=>true
+        });
+        if (resp.status < 200 || resp.status >= 400) this.handleErrorResponse(resp, requestId);
+        return resp.data;
+    }
+    async retrieveFile(fileId, opts) {
+        if (!fileId) throw new Error("missing required file_id parameter");
+        return this.doRequest("GET", this.fullURL(`${filePrefix}/${fileId}`), "", "", opts);
+    }
+    async listFiles(request, opts) {
+        const query = {};
+        if (request?.purpose) query.purpose = request.purpose;
+        if (request?.after) query.after = request.after;
+        if (request?.limit != null) query.limit = String(request.limit);
+        if (request?.order) query.order = request.order;
+        return this.doRequest("GET", this.fullURL(filePrefix), "", "", {
+            ...opts,
+            query
+        });
+    }
+    async deleteFile(fileId, opts) {
+        if (!fileId) throw new Error("missing required file_id parameter");
+        return this.doRequest("DELETE", this.fullURL(`${filePrefix}/${fileId}`), "", "", opts);
+    }
+    async createBatchChatCompletion(request, opts) {
+        if (request.stream) throw ErrChatCompletionStreamNotSupported;
+        const breaker = this.modelBreakerProvider.getOrCreate(request.model);
+        await breaker.wait();
+        const resp = await this.doRequest("POST", this.fullURL(batchChatCompletionsSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+        return normalizeChatCompletionResponse(resp);
+    }
+    async createBatchEmbeddings(request, opts) {
+        const breaker = this.modelBreakerProvider.getOrCreate(request.model);
+        await breaker.wait();
+        const resp = await this.doRequest("POST", this.fullURL(batchEmbeddingsSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+        return normalizeEmbeddingResponse(resp);
+    }
+    async createBatchMultiModalEmbeddings(request, opts) {
+        const breaker = this.modelBreakerProvider.getOrCreate(request.model);
+        await breaker.wait();
+        return this.doRequest("POST", this.fullURL(batchMultiModalEmbeddingsSuffix), resourceTypeEndpoint, request.model, {
+            ...opts,
+            body: request
+        });
+    }
+    constructor(config){
+        client_define_property(this, "config", void 0);
+        client_define_property(this, "httpClient", void 0);
+        client_define_property(this, "batchHttpClient", void 0);
+        client_define_property(this, "resourceStsTokens", new Map());
+        client_define_property(this, "refreshPromise", null);
+        client_define_property(this, "advisoryRefreshTimeout", 1800);
+        client_define_property(this, "mandatoryRefreshTimeout", 600);
+        client_define_property(this, "modelBreakerProvider", new ModelBreakerProvider());
+        client_define_property(this, "e2eeManager", new Map());
+        client_define_property(this, "keyNonceMap", new Map());
+        client_define_property(this, "e2eeFlightMap", new Map());
+        this.config = resolveConfig(config);
+        this.httpClient = this.config.httpClient ?? external_axios_default().create({
+            timeout: this.config.timeout,
+            httpsAgent: new external_https_namespaceObject.Agent({
+                keepAlive: true
+            }),
+            paramsSerializer: (params)=>{
+                const parts = [];
+                for (const [key, value] of Object.entries(params))if (Array.isArray(value)) for (const v of value)parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(v)}`);
+                else if (null != value) parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+                return parts.join("&");
+            }
+        });
+        this.batchHttpClient = external_axios_default().create({
+            timeout: this.config.timeout,
+            httpsAgent: new external_https_namespaceObject.Agent({
+                keepAlive: true
+            })
+        });
+    }
+}
+const ChatMessageRoleAssistant = "assistant";
+const ToolChoiceRequired = "required";
+function decodeBase64Embedding(b64) {
+    const buf = Buffer.from(b64, "base64");
+    const floats = [];
+    for(let i = 0; i < buf.length; i += 4)floats.push(buf.readFloatLE(i));
+    return floats;
+}
+function base64ToEmbeddingResponse(resp) {
+    return {
+        id: "",
+        created: 0,
+        object: resp.object,
+        model: resp.model,
+        usage: resp.usage,
+        data: resp.data.map((item)=>({
+                object: item.object,
+                embedding: decodeBase64Embedding(item.embedding),
+                index: item.index
+            }))
+    };
+}
+const GenerateImagesResponseFormatBase64 = "b64_json";
+const GenerateImagesSizeAdaptive = "adaptive";
+const ImageGenerationStreamEventPartialSucceeded = "image_generation.partial_succeeded";
+const ImageGenerationStreamEventPartialFailed = "image_generation.partial_failed";
+const ImageGenerationStreamEventCompleted = "image_generation.completed";
+const StatusSucceeded = "succeeded";
+const StatusCancelled = "cancelled";
+const StatusRunning = "running";
+const MessageRole_developer = "developer";
+const MessageRole_assistant = "assistant";
+const ContentItemType_input_text = "input_text";
+const ContentItemType_input_image = "input_image";
+const ContentItemType_input_video = "input_video";
+const ContentItemType_input_audio = "input_audio";
+const ContentItemType_input_file = "input_file";
+const ContentItemType_output_text = "output_text";
+const ContentItemType_summary_text = "summary_text";
+function getEventType(event) {
+    if (!event) return "";
+    return event.type ?? "";
+}
+function isDelta(event) {
+    const t = event.type;
+    return "response.output_text.delta" === t || "response.reasoning_summary_text.delta" === t || "response.function_call_arguments.delta" === t || "response.transcription_text.delta" === t || "response.output_text.annotation.added" === t || "response.web_search_call.in_progress" === t || "response.web_search_call.searching" === t || "response.web_search_call.completed" === t || "response.image_process_call.in_progress" === t || "response.image_process_call.completed" === t || "response.mcp_list_tools.completed" === t || "response.mcp_call.in_progress" === t || "response.mcp_call.arguments_delta" === t || "response.mcp_call.arguments_done" === t || "response.mcp_call.completed" === t || "response.mcp_call.failed" === t || "response.knowledge_search_call.in_progress" === t || "response.knowledge_search_call.searching" === t || "response.knowledge_search_call.completed" === t || "response.knowledge_search_call.failed" === t;
+}
+function isDeltaDone(event) {
+    const t = event.type;
+    return "response.output_text.done" === t || "response.reasoning_summary_text.done" === t || "response.function_call_arguments.done" === t || "response.transcription_text.done" === t;
+}
+function isResponseDone(event) {
+    const t = event.type;
+    return "response.completed" === t || "response.failed" === t || "response.incomplete" === t;
+}
+exports.ArkAPIError = __webpack_exports__.ArkAPIError;
+exports.ArkRequestError = __webpack_exports__.ArkRequestError;
+exports.ArkRuntimeClient = __webpack_exports__.ArkRuntimeClient;
+exports.BotChatCompletionStreamReader = __webpack_exports__.BotChatCompletionStreamReader;
+exports.Breaker = __webpack_exports__.Breaker;
+exports.ChatCompletionStreamReader = __webpack_exports__.ChatCompletionStreamReader;
+exports.ChatMessageRoleAssistant = __webpack_exports__.ChatMessageRoleAssistant;
+exports.ChatMessageRoleSystem = __webpack_exports__.ChatMessageRoleSystem;
+exports.ChatMessageRoleTool = __webpack_exports__.ChatMessageRoleTool;
+exports.ChatMessageRoleUser = __webpack_exports__.ChatMessageRoleUser;
+exports.ClientEncryptInfoHeader = __webpack_exports__.ClientEncryptInfoHeader;
+exports.ClientIsEncryptedHeader = __webpack_exports__.ClientIsEncryptedHeader;
+exports.ClientRequestHeader = __webpack_exports__.ClientRequestHeader;
+exports.ClientSessionTokenHeader = __webpack_exports__.ClientSessionTokenHeader;
+exports.DefaultAdvisoryRefreshTimeout = __webpack_exports__.DefaultAdvisoryRefreshTimeout;
+exports.DefaultMandatoryRefreshTimeout = __webpack_exports__.DefaultMandatoryRefreshTimeout;
+exports.DefaultStsTimeout = __webpack_exports__.DefaultStsTimeout;
+exports.E2eeClient = __webpack_exports__.E2eeClient;
+exports.ErrAKSKNotSupported = __webpack_exports__.ErrAKSKNotSupported;
+exports.ErrBodyWithoutBot = __webpack_exports__.ErrBodyWithoutBot;
+exports.ErrBodyWithoutEndpoint = __webpack_exports__.ErrBodyWithoutEndpoint;
+exports.ErrBodyWithoutProjectName = __webpack_exports__.ErrBodyWithoutProjectName;
+exports.ErrChatCompletionStreamNotSupported = __webpack_exports__.ErrChatCompletionStreamNotSupported;
+exports.ErrContentFieldsMisused = __webpack_exports__.ErrContentFieldsMisused;
+exports.ErrTooManyEmptyStreamMessages = __webpack_exports__.ErrTooManyEmptyStreamMessages;
+exports.ErrorRetryBaseDelayMs = __webpack_exports__.ErrorRetryBaseDelayMs;
+exports.ErrorRetryMaxDelayMs = __webpack_exports__.ErrorRetryMaxDelayMs;
+exports.EventStreamDecoder = __webpack_exports__.EventStreamDecoder;
+exports.FileStatusActive = __webpack_exports__.FileStatusActive;
+exports.FileStatusFailed = __webpack_exports__.FileStatusFailed;
+exports.FileStatusProcessing = __webpack_exports__.FileStatusProcessing;
+exports.GenerateImagesResponseFormatBase64 = __webpack_exports__.GenerateImagesResponseFormatBase64;
+exports.GenerateImagesResponseFormatURL = __webpack_exports__.GenerateImagesResponseFormatURL;
+exports.GenerateImagesSizeAdaptive = __webpack_exports__.GenerateImagesSizeAdaptive;
+exports.ImageGenerationStreamEventCompleted = __webpack_exports__.ImageGenerationStreamEventCompleted;
+exports.ImageGenerationStreamEventPartialFailed = __webpack_exports__.ImageGenerationStreamEventPartialFailed;
+exports.ImageGenerationStreamEventPartialSucceeded = __webpack_exports__.ImageGenerationStreamEventPartialSucceeded;
+exports.ImageGenerationStreamReader = __webpack_exports__.ImageGenerationStreamReader;
+exports.InitialRetryDelay = __webpack_exports__.InitialRetryDelay;
+exports.KeyAgreementClient = __webpack_exports__.KeyAgreementClient;
+exports.MaxRetryDelay = __webpack_exports__.MaxRetryDelay;
+exports.ModelBreakerProvider = __webpack_exports__.ModelBreakerProvider;
+exports.ObjectTypeFile = __webpack_exports__.ObjectTypeFile;
+exports.ObjectTypeList = __webpack_exports__.ObjectTypeList;
+exports.OrderAsc = __webpack_exports__.OrderAsc;
+exports.OrderDesc = __webpack_exports__.OrderDesc;
+exports.PurposeUserData = __webpack_exports__.PurposeUserData;
+exports.ResponsesStreamReader = __webpack_exports__.ResponsesStreamReader;
+exports.RetryAfterHeader = __webpack_exports__.RetryAfterHeader;
+exports.StatusCancelled = __webpack_exports__.StatusCancelled;
+exports.StatusFailed = __webpack_exports__.StatusFailed;
+exports.StatusQueued = __webpack_exports__.StatusQueued;
+exports.StatusRunning = __webpack_exports__.StatusRunning;
+exports.StatusSucceeded = __webpack_exports__.StatusSucceeded;
+exports.ToolChoiceAuto = __webpack_exports__.ToolChoiceAuto;
+exports.ToolChoiceNone = __webpack_exports__.ToolChoiceNone;
+exports.ToolChoiceRequired = __webpack_exports__.ToolChoiceRequired;
+exports.aesGcmDecrypt = __webpack_exports__.aesGcmDecrypt;
+exports.aesGcmDecryptBase64 = __webpack_exports__.aesGcmDecryptBase64;
+exports.aesGcmEncrypt = __webpack_exports__.aesGcmEncrypt;
+exports.aesGcmEncryptBase64 = __webpack_exports__.aesGcmEncryptBase64;
+exports.base64ToEmbeddingResponse = __webpack_exports__.base64ToEmbeddingResponse;
+exports.checkIsModeAICC = __webpack_exports__.checkIsModeAICC;
+exports.decodeBase64Embedding = __webpack_exports__.decodeBase64Embedding;
+exports.decryptChatResponse = __webpack_exports__.decryptChatResponse;
+exports.decryptChatStreamResponse = __webpack_exports__.decryptChatStreamResponse;
+exports.deepCopyRequest = __webpack_exports__.deepCopyRequest;
+exports.encryptChatRequest = __webpack_exports__.encryptChatRequest;
+exports.genRequestId = __webpack_exports__.genRequestId;
+exports.getCertInfo = __webpack_exports__.getCertInfo;
+exports.loadLocalCertificate = __webpack_exports__.loadLocalCertificate;
+exports.responses = __webpack_exports__.responses;
+exports.retry = __webpack_exports__.retry;
+exports.saveToLocalCertificate = __webpack_exports__.saveToLocalCertificate;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ArkAPIError",
+    "ArkRequestError",
+    "ArkRuntimeClient",
+    "BotChatCompletionStreamReader",
+    "Breaker",
+    "ChatCompletionStreamReader",
+    "ChatMessageRoleAssistant",
+    "ChatMessageRoleSystem",
+    "ChatMessageRoleTool",
+    "ChatMessageRoleUser",
+    "ClientEncryptInfoHeader",
+    "ClientIsEncryptedHeader",
+    "ClientRequestHeader",
+    "ClientSessionTokenHeader",
+    "DefaultAdvisoryRefreshTimeout",
+    "DefaultMandatoryRefreshTimeout",
+    "DefaultStsTimeout",
+    "E2eeClient",
+    "ErrAKSKNotSupported",
+    "ErrBodyWithoutBot",
+    "ErrBodyWithoutEndpoint",
+    "ErrBodyWithoutProjectName",
+    "ErrChatCompletionStreamNotSupported",
+    "ErrContentFieldsMisused",
+    "ErrTooManyEmptyStreamMessages",
+    "ErrorRetryBaseDelayMs",
+    "ErrorRetryMaxDelayMs",
+    "EventStreamDecoder",
+    "FileStatusActive",
+    "FileStatusFailed",
+    "FileStatusProcessing",
+    "GenerateImagesResponseFormatBase64",
+    "GenerateImagesResponseFormatURL",
+    "GenerateImagesSizeAdaptive",
+    "ImageGenerationStreamEventCompleted",
+    "ImageGenerationStreamEventPartialFailed",
+    "ImageGenerationStreamEventPartialSucceeded",
+    "ImageGenerationStreamReader",
+    "InitialRetryDelay",
+    "KeyAgreementClient",
+    "MaxRetryDelay",
+    "ModelBreakerProvider",
+    "ObjectTypeFile",
+    "ObjectTypeList",
+    "OrderAsc",
+    "OrderDesc",
+    "PurposeUserData",
+    "ResponsesStreamReader",
+    "RetryAfterHeader",
+    "StatusCancelled",
+    "StatusFailed",
+    "StatusQueued",
+    "StatusRunning",
+    "StatusSucceeded",
+    "ToolChoiceAuto",
+    "ToolChoiceNone",
+    "ToolChoiceRequired",
+    "aesGcmDecrypt",
+    "aesGcmDecryptBase64",
+    "aesGcmEncrypt",
+    "aesGcmEncryptBase64",
+    "base64ToEmbeddingResponse",
+    "checkIsModeAICC",
+    "decodeBase64Embedding",
+    "decryptChatResponse",
+    "decryptChatStreamResponse",
+    "deepCopyRequest",
+    "encryptChatRequest",
+    "genRequestId",
+    "getCertInfo",
+    "loadLocalCertificate",
+    "responses",
+    "retry",
+    "saveToLocalCertificate"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});