@henjicc/ai-sdk 0.2.8

package/dist/capabilities/speech-recognition/volcengine/realtime/protocol.js

@@ -0,0 +1,223 @@
+import { gunzipSync, gzipSync, strFromU8, strToU8 } from 'fflate';
+import { AiRuntimeError } from '../../../../runtime/AiRuntimeError.js';
+const PROTOCOL_VERSION = 1;
+const HEADER_WORDS = 1;
+const CLIENT_FULL_REQUEST = 0x1;
+const CLIENT_AUDIO_REQUEST = 0x2;
+const SERVER_FULL_RESPONSE = 0x9;
+const SERVER_ERROR_RESPONSE = 0xf;
+const FLAG_POSITIVE_SEQUENCE = 0x1;
+const FLAG_LAST = 0x2;
+const FLAG_EVENT = 0x4;
+const SERIALIZATION_NONE = 0x0;
+const SERIALIZATION_JSON = 0x1;
+const COMPRESSION_NONE = 0x0;
+const COMPRESSION_GZIP = 0x1;
+function ensureSequence(sequence) {
+    if (!Number.isInteger(sequence) || sequence <= 0 || sequence > 0x7fffffff) {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine realtime sequence must be a positive int32');
+    }
+}
+function int32(value) {
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setInt32(0, value, false);
+    return bytes;
+}
+function uint32(value) {
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setUint32(0, value, false);
+    return bytes;
+}
+function join(parts) {
+    const size = parts.reduce((total, part) => total + part.byteLength, 0);
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const part of parts) {
+        result.set(part, offset);
+        offset += part.byteLength;
+    }
+    return result;
+}
+function requestHeader(messageType, flags) {
+    return new Uint8Array([
+        (PROTOCOL_VERSION << 4) | HEADER_WORDS,
+        (messageType << 4) | flags,
+        // 火山当前官方附件对 JSON 首帧和原始音频帧都使用 JSON+gzip 标志；音频 payload 仍是原始 PCM 字节。
+        (SERIALIZATION_JSON << 4) | COMPRESSION_GZIP,
+        0,
+    ]);
+}
+export function encodeVolcengineFullRequest(payload, sequence = 1) {
+    ensureSequence(sequence);
+    let json;
+    try {
+        json = JSON.stringify(payload);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine realtime full request is not JSON serializable');
+    }
+    if (json === undefined) {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine realtime full request must serialize to JSON');
+    }
+    const compressed = gzipSync(strToU8(json));
+    return join([
+        requestHeader(CLIENT_FULL_REQUEST, FLAG_POSITIVE_SEQUENCE),
+        int32(sequence),
+        uint32(compressed.byteLength),
+        compressed,
+    ]);
+}
+export function encodeVolcengineAudioRequest(audio, sequence, last) {
+    ensureSequence(sequence);
+    if (audio.byteLength === 0) {
+        throw new AiRuntimeError('invalid_audio_chunk', 'Volcengine realtime audio frame cannot be empty');
+    }
+    const compressed = gzipSync(audio);
+    return join([
+        requestHeader(CLIENT_AUDIO_REQUEST, last ? FLAG_POSITIVE_SEQUENCE | FLAG_LAST : FLAG_POSITIVE_SEQUENCE),
+        int32(last ? -sequence : sequence),
+        uint32(compressed.byteLength),
+        compressed,
+    ]);
+}
+function requireBytes(bytes, offset, count, label) {
+    if (offset < 0 || count < 0 || offset + count > bytes.byteLength) {
+        throw new AiRuntimeError('invalid_response', `Volcengine realtime frame is truncated before ${label}`);
+    }
+}
+function readInt32(bytes, offset, label) {
+    requireBytes(bytes, offset, 4, label);
+    return new DataView(bytes.buffer, bytes.byteOffset + offset, 4).getInt32(0, false);
+}
+function readUint32(bytes, offset, label) {
+    requireBytes(bytes, offset, 4, label);
+    return new DataView(bytes.buffer, bytes.byteOffset + offset, 4).getUint32(0, false);
+}
+function decompress(payload, compression) {
+    if (compression === COMPRESSION_NONE)
+        return payload;
+    if (compression !== COMPRESSION_GZIP) {
+        throw new AiRuntimeError('invalid_response', `Volcengine realtime frame uses unsupported compression ${compression}`);
+    }
+    try {
+        return gunzipSync(payload);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_response', 'Volcengine realtime frame contains invalid gzip payload');
+    }
+}
+function deserialize(payload, serialization) {
+    if (serialization === SERIALIZATION_NONE)
+        return payload;
+    if (serialization !== SERIALIZATION_JSON) {
+        throw new AiRuntimeError('invalid_response', `Volcengine realtime frame uses unsupported serialization ${serialization}`);
+    }
+    try {
+        return JSON.parse(strFromU8(payload));
+    }
+    catch {
+        throw new AiRuntimeError('invalid_response', 'Volcengine realtime frame contains invalid JSON payload');
+    }
+}
+function deserializeError(payload, serialization) {
+    if (serialization === SERIALIZATION_NONE)
+        return payload;
+    if (serialization !== SERIALIZATION_JSON) {
+        throw new AiRuntimeError('invalid_response', `Volcengine realtime frame uses unsupported serialization ${serialization}`);
+    }
+    const text = strFromU8(payload);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function errorMessage(payload, raw) {
+    if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+        const root = payload;
+        for (const key of ['message', 'error', 'msg']) {
+            const value = root[key];
+            if (typeof value === 'string' && value.trim())
+                return value.trim();
+        }
+    }
+    if (typeof payload === 'string' && payload.trim())
+        return payload.trim();
+    const text = strFromU8(raw).trim();
+    return text || 'Volcengine realtime server returned an error';
+}
+/** 严格解析火山 v1 服务端帧；长度字段必须与实际 payload 完全一致。 */
+export function parseVolcengineServerFrame(bytes) {
+    requireBytes(bytes, 0, 4, 'header');
+    const version = bytes[0] >> 4;
+    const headerWords = bytes[0] & 0x0f;
+    if (version !== PROTOCOL_VERSION) {
+        throw new AiRuntimeError('invalid_response', `Unsupported Volcengine realtime protocol version ${version}`);
+    }
+    if (headerWords < 1) {
+        throw new AiRuntimeError('invalid_response', 'Volcengine realtime header size must be at least one word');
+    }
+    const headerBytes = headerWords * 4;
+    requireBytes(bytes, 0, headerBytes, 'extended header');
+    const messageType = bytes[1] >> 4;
+    const flags = bytes[1] & 0x0f;
+    if ((flags & ~0x07) !== 0) {
+        throw new AiRuntimeError('invalid_response', `Volcengine realtime frame uses unsupported flags ${flags}`);
+    }
+    const serialization = bytes[2] >> 4;
+    const compression = bytes[2] & 0x0f;
+    if (serialization !== SERIALIZATION_NONE && serialization !== SERIALIZATION_JSON) {
+        throw new AiRuntimeError('invalid_response', `Volcengine realtime frame uses unsupported serialization ${serialization}`);
+    }
+    if (compression !== COMPRESSION_NONE && compression !== COMPRESSION_GZIP) {
+        throw new AiRuntimeError('invalid_response', `Volcengine realtime frame uses unsupported compression ${compression}`);
+    }
+    let offset = headerBytes;
+    let sequence;
+    let event;
+    if ((flags & FLAG_POSITIVE_SEQUENCE) !== 0) {
+        sequence = readInt32(bytes, offset, 'sequence');
+        offset += 4;
+    }
+    if ((flags & FLAG_EVENT) !== 0) {
+        event = readInt32(bytes, offset, 'event');
+        offset += 4;
+    }
+    let code;
+    if (messageType === SERVER_ERROR_RESPONSE) {
+        code = readUint32(bytes, offset, 'error code');
+        offset += 4;
+    }
+    else if (messageType !== SERVER_FULL_RESPONSE) {
+        throw new AiRuntimeError('invalid_response', `Unsupported Volcengine realtime server message type ${messageType}`);
+    }
+    const payloadSize = readUint32(bytes, offset, 'payload size');
+    offset += 4;
+    const actualSize = bytes.byteLength - offset;
+    if (actualSize !== payloadSize) {
+        throw new AiRuntimeError('invalid_response', `Volcengine realtime payload length mismatch: expected ${payloadSize}, got ${actualSize}`);
+    }
+    const compressedPayload = bytes.subarray(offset);
+    const raw = payloadSize ? decompress(compressedPayload, compression) : new Uint8Array();
+    const payload = raw.byteLength
+        ? messageType === SERVER_ERROR_RESPONSE
+            ? deserializeError(raw, serialization)
+            : deserialize(raw, serialization)
+        : undefined;
+    const common = {
+        sequence,
+        event,
+        last: (flags & FLAG_LAST) !== 0,
+    };
+    if (messageType === SERVER_ERROR_RESPONSE) {
+        return {
+            kind: 'error',
+            code: code,
+            ...common,
+            message: errorMessage(payload, raw),
+            payload,
+        };
+    }
+    return { kind: 'response', ...common, payload };
+}

package/dist/capabilities/speech-recognition/volcengine/realtime/types.d.ts

@@ -0,0 +1,13 @@
+export interface VolcengineRealtimeAsrOptions {
+    enableItn?: boolean;
+    enableDdc?: boolean;
+    showUtterances?: boolean;
+}
+export interface VolcengineRealtimeModuleOptions {
+    /** 默认使用 SeedASR 2.0 双向流式优化端点。 */
+    webSocketUrl?: string;
+    /** 等待 full request 服务端响应的上限，默认 15 秒。 */
+    openTimeoutMs?: number;
+    /** `X-Api-Request-Id` 必须为 UUID；测试或强随机宿主可以注入生成器。 */
+    requestIdFactory?(requestId: string): string;
+}

package/dist/capabilities/speech-recognition/volcengine/realtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/capabilities/speech-recognition/volcengine/request-id.d.ts

@@ -0,0 +1 @@
+export declare function volcengineRequestId(requestId: string, factory: ((requestId: string) => string) | undefined): string;

package/dist/capabilities/speech-recognition/volcengine/request-id.js

@@ -0,0 +1,27 @@
+import { AiRuntimeError } from '../../../runtime/AiRuntimeError.js';
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+let sequence = 0;
+function uuidFromSeed(seed) {
+    let state = 0x811c9dc5;
+    const bytes = new Uint8Array(16);
+    for (let index = 0; index < bytes.length; index += 1) {
+        for (const character of seed) {
+            state ^= character.charCodeAt(0) + index;
+            state = Math.imul(state, 0x01000193);
+        }
+        bytes[index] = state >>> ((index % 4) * 8);
+    }
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((value) => value.toString(16).padStart(2, '0')).join('');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+export function volcengineRequestId(requestId, factory) {
+    const value = factory
+        ? factory(requestId).trim()
+        : uuidFromSeed(`${requestId}:${Date.now()}:${sequence++}`);
+    if (!UUID_PATTERN.test(value)) {
+        throw new AiRuntimeError('invalid_task_id', 'Volcengine ASR request id must be a UUID');
+    }
+    return value;
+}

package/dist/capabilities/speech-recognition/volcengine/types.d.ts

@@ -0,0 +1,15 @@
+export interface VolcengineAsrOptions {
+    /** 火山请求 `audio.format`；无法从 URL、文件名或 MIME 推断时必须显式提供。 */
+    format?: string;
+    enableItn?: boolean;
+    enableDdc?: boolean;
+    showUtterances?: boolean;
+}
+export interface VolcengineAsrModuleOptions {
+    /** 默认 `https://openspeech.bytedance.com/api/v3/auc/bigmodel`。 */
+    apiBaseUrl?: string;
+    pollIntervalMs?: number;
+    maxPollingMs?: number;
+    /** 火山任务 ID 必须为 UUID；测试或强随机宿主可以注入生成器。 */
+    requestIdFactory?(requestId: string): string;
+}

package/dist/capabilities/speech-recognition/volcengine/types.js

@@ -0,0 +1 @@
+export {};

package/dist/capabilities/translation/bailian/index.d.ts

@@ -0,0 +1,4 @@
+/** 百炼 Qwen-MT 按需模块；不会由 translation 通用入口或包根隐式导入。 */
+export * from './types.js';
+export * from './languages.js';
+export * from './module.js';

package/dist/capabilities/translation/bailian/index.js

@@ -0,0 +1,4 @@
+/** 百炼 Qwen-MT 按需模块；不会由 translation 通用入口或包根隐式导入。 */
+export * from './types.js';
+export * from './languages.js';
+export * from './module.js';

package/dist/capabilities/translation/bailian/languages.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Say-It 现有设置保存语言代码，百炼 Qwen-MT API 契约使用英文语言名。
+ * 这里只转换 Say-It 当前公开的常用子集；未知值原样保留，避免关闭未来语言扩展。
+ */
+export declare const BAILIAN_QWEN_MT_LANGUAGE_ALIASES: Readonly<Record<string, string>>;
+export declare function normalizeBailianQwenMtLanguage(value: string): string;

package/dist/capabilities/translation/bailian/languages.js

@@ -0,0 +1,47 @@
+/**
+ * Say-It 现有设置保存语言代码，百炼 Qwen-MT API 契约使用英文语言名。
+ * 这里只转换 Say-It 当前公开的常用子集；未知值原样保留，避免关闭未来语言扩展。
+ */
+export const BAILIAN_QWEN_MT_LANGUAGE_ALIASES = {
+    en: 'English',
+    zh: 'Chinese',
+    zh_tw: 'Traditional Chinese',
+    ja: 'Japanese',
+    ko: 'Korean',
+    yue: 'Cantonese',
+    ru: 'Russian',
+    es: 'Spanish',
+    fr: 'French',
+    de: 'German',
+    it: 'Italian',
+    pt: 'Portuguese',
+    nl: 'Dutch',
+    pl: 'Polish',
+    tr: 'Turkish',
+    vi: 'Vietnamese',
+    th: 'Thai',
+    id: 'Indonesian',
+    ms: 'Malay',
+    ar: 'Arabic',
+    hi: 'Hindi',
+    bn: 'Bengali',
+    ur: 'Urdu',
+    he: 'Hebrew',
+    el: 'Greek',
+    sv: 'Swedish',
+    da: 'Danish',
+    fi: 'Finnish',
+    cs: 'Czech',
+    ro: 'Romanian',
+    uk: 'Ukrainian',
+    hu: 'Hungarian',
+    km: 'Khmer',
+    lo: 'Lao',
+};
+export function normalizeBailianQwenMtLanguage(value) {
+    const trimmed = value.trim();
+    const normalized = trimmed.toLowerCase();
+    if (normalized === 'auto')
+        return 'auto';
+    return BAILIAN_QWEN_MT_LANGUAGE_ALIASES[normalized] ?? trimmed;
+}

package/dist/capabilities/translation/bailian/module.d.ts

@@ -0,0 +1,6 @@
+import { type TranslationModule } from '../index.js';
+import { type BailianQwenMtModelId, type BailianQwenMtModuleConfig } from './types.js';
+export declare function createBailianQwenMtTranslationModule(modelId: BailianQwenMtModelId, config?: BailianQwenMtModuleConfig): TranslationModule;
+export declare function createQwenMtFlashTranslationModule(config?: BailianQwenMtModuleConfig): TranslationModule;
+export declare function createQwenMtPlusTranslationModule(config?: BailianQwenMtModuleConfig): TranslationModule;
+export declare function createQwenMtLiteTranslationModule(config?: BailianQwenMtModuleConfig): TranslationModule;

package/dist/capabilities/translation/bailian/module.js

@@ -0,0 +1,310 @@
+import { fetchProvider } from '../../../providers/provider-fetch.js';
+import { AiRuntimeError } from '../../../runtime/AiRuntimeError.js';
+import { defineTranslationDescriptor, } from '../index.js';
+import { readQwenMtSse } from './sse.js';
+import { BAILIAN_QWEN_MT_PRESETS, DEFAULT_BAILIAN_QWEN_MT_ENDPOINT, } from './types.js';
+import { normalizeBailianQwenMtLanguage } from './languages.js';
+const ALLOWED_OPTION_KEYS = new Set(['stream', 'translationMemory']);
+export function createBailianQwenMtTranslationModule(modelId, config = {}) {
+    const preset = findPreset(modelId);
+    const endpoint = normalizeEndpoint(config.endpoint);
+    const defaultStream = config.defaultStream ?? true;
+    return {
+        descriptor: {
+            ...defineTranslationDescriptor({
+                id: preset.moduleId,
+                source: { kind: 'builtin', namespace: '@henjicc/ai-sdk' },
+                version: '1',
+                providerIds: ['bailian'],
+                modelId: preset.modelId,
+                streaming: true,
+                features: ['terminology', 'translation-memory', 'domain-hint', 'usage'],
+                tags: ['bailian', 'qwen-mt'],
+            }),
+            executionModes: ['request-response', 'event-stream'],
+        },
+        execute: async (input, context) => {
+            const source = normalizeSource(input);
+            const options = normalizeOptions(input.options, defaultStream);
+            const targetLanguage = normalizeBailianQwenMtLanguage(requireText(input.targetLanguage, 'targetLanguage'));
+            const sourceLanguage = normalizeBailianQwenMtLanguage(input.sourceLanguage?.trim() || 'auto');
+            const apiKey = await context.runtime.credentials.get('translation', 'bailian');
+            if (!apiKey?.trim()) {
+                throw new AiRuntimeError('api_key_missing', 'Bailian translation API key is not configured');
+            }
+            await context.emit({ type: 'started' });
+            const translations = [];
+            const metadata = [];
+            let usage;
+            for (let index = 0; index < source.length; index += 1) {
+                const entry = source[index];
+                const result = entry.text.length === 0
+                    ? { item: { text: '', sourceText: entry.text, id: entry.id }, metadata: {} }
+                    : await executeItem({
+                        apiKey: apiKey.trim(), endpoint, preset, input, options,
+                        sourceLanguage, targetLanguage, entry, index, context,
+                    });
+                translations.push(result.item);
+                metadata.push(result.metadata);
+                usage = addUsage(usage, result.usage);
+                await context.emit({ type: 'item', index, item: result.item });
+            }
+            const output = {
+                translations,
+                usage,
+                providerMetadata: { providerId: 'bailian', modelId: preset.modelId, items: metadata },
+            };
+            await context.emit({ type: 'completed', output });
+            return output;
+        },
+    };
+}
+export function createQwenMtFlashTranslationModule(config) {
+    return createBailianQwenMtTranslationModule('qwen-mt-flash', config);
+}
+export function createQwenMtPlusTranslationModule(config) {
+    return createBailianQwenMtTranslationModule('qwen-mt-plus', config);
+}
+export function createQwenMtLiteTranslationModule(config) {
+    return createBailianQwenMtTranslationModule('qwen-mt-lite', config);
+}
+async function executeItem(input) {
+    const { context, preset, index, entry } = input;
+    const span = context.runtime.tracer.startSpan('bailian.translation.request', {
+        requestId: context.requestId,
+        providerId: 'bailian',
+        modelId: preset.modelId,
+        itemIndex: index,
+    });
+    context.runtime.logger.info('百炼翻译请求开始', {
+        event: 'bailian.translation.request.start', requestId: context.requestId,
+        providerId: 'bailian', modelId: preset.modelId, context: { itemIndex: index },
+    });
+    try {
+        const response = await fetchProvider('Bailian Qwen-MT', input.endpoint, {
+            method: 'POST',
+            headers: {
+                Accept: input.options.stream ? 'text/event-stream' : 'application/json',
+                Authorization: `Bearer ${input.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(buildRequestBody(input)),
+            signal: context.signal,
+        }, { transport: context.runtime.transport, retryPreconnectOnce: true });
+        if (!response.ok)
+            throw await createHttpError(response);
+        const result = input.options.stream
+            ? await parseStreamingResponse(response, input)
+            : await parseCompleteResponse(response, entry);
+        context.runtime.logger.info('百炼翻译请求完成', {
+            event: 'bailian.translation.request.completed', requestId: context.requestId,
+            providerId: 'bailian', modelId: preset.modelId,
+            context: { itemIndex: index, inputTokens: result.usage?.inputTokens, outputTokens: result.usage?.outputTokens },
+        });
+        span.end();
+        return result;
+    }
+    catch (error) {
+        context.runtime.logger.error('百炼翻译请求失败', {
+            event: 'bailian.translation.request.failed', requestId: context.requestId,
+            providerId: 'bailian', modelId: preset.modelId, context: { itemIndex: index }, error,
+        });
+        span.end(error);
+        throw error;
+    }
+}
+function buildRequestBody(input) {
+    const terms = Object.entries(input.input.terminology ?? {}).map(([source, target], index) => ({
+        source: requireText(source, `terminology[${index}].source`),
+        target: requireText(target, `terminology[${index}].target`),
+    }));
+    const translationOptions = {
+        source_lang: input.sourceLanguage,
+        target_lang: input.targetLanguage,
+    };
+    if (terms.length > 0)
+        translationOptions.terms = terms;
+    if (input.options.translationMemory?.length)
+        translationOptions.tm_list = input.options.translationMemory;
+    if (input.input.context?.trim())
+        translationOptions.domains = input.input.context.trim();
+    return {
+        model: input.preset.modelId,
+        messages: [{ role: 'user', content: input.entry.text }],
+        translation_options: translationOptions,
+        stream: input.options.stream,
+        ...(input.options.stream ? { stream_options: { include_usage: true } } : {}),
+    };
+}
+async function parseStreamingResponse(response, input) {
+    if (!response.body) {
+        throw new AiRuntimeError('provider_response_invalid', 'Bailian Qwen-MT streaming response body is empty');
+    }
+    const result = await readQwenMtSse(response.body, input.preset.streamingContent, input.context.signal, {
+        onDelta: async (delta) => await input.context.emit({
+            type: 'delta', index: input.index, id: input.entry.id, ...delta,
+        }),
+        onUsage: async (usage) => await input.context.emit({
+            type: 'usage', index: input.index, id: input.entry.id, usage,
+        }),
+    });
+    return {
+        item: { text: result.text, sourceText: input.entry.text, id: input.entry.id },
+        usage: result.usage,
+        metadata: {
+            requestId: result.requestId,
+            responseModel: result.responseModel,
+            finishReason: result.finishReason,
+        },
+    };
+}
+async function parseCompleteResponse(response, entry) {
+    const payload = await readJson(response);
+    throwPayloadError(payload);
+    const choice = Array.isArray(payload.choices) && isRecord(payload.choices[0])
+        ? payload.choices[0]
+        : undefined;
+    const message = isRecord(choice?.message) ? choice.message : undefined;
+    const text = typeof message?.content === 'string' ? message.content : undefined;
+    if (text === undefined) {
+        throw new AiRuntimeError('empty_result', 'Bailian Qwen-MT response has no translated text');
+    }
+    return {
+        item: { text, sourceText: entry.text, id: entry.id },
+        usage: readUsage(payload.usage),
+        metadata: {
+            requestId: readNonEmptyString(payload.id),
+            responseModel: readNonEmptyString(payload.model),
+            finishReason: readNonEmptyString(choice?.finish_reason),
+        },
+    };
+}
+async function createHttpError(response) {
+    const payload = await readJson(response, true);
+    const error = isRecord(payload.error) ? payload.error : undefined;
+    const providerCode = readNonEmptyString(error?.code) ?? readNonEmptyString(payload.code);
+    const message = readNonEmptyString(error?.message) ?? readNonEmptyString(payload.message)
+        ?? `HTTP ${response.status}`;
+    const code = response.status === 401 || response.status === 403
+        ? 'provider_auth_error'
+        : response.status === 429
+            ? 'provider_rate_limited'
+            : response.status >= 500
+                ? 'provider_http_error'
+                : 'provider_request_failed';
+    return new AiRuntimeError(code, `Bailian Qwen-MT ${providerCode ? `${providerCode}: ` : ''}${message}`);
+}
+async function readJson(response, allowInvalid = false) {
+    try {
+        const value = await response.json();
+        if (isRecord(value))
+            return value;
+    }
+    catch {
+        if (allowInvalid)
+            return {};
+    }
+    if (allowInvalid)
+        return {};
+    throw new AiRuntimeError('provider_response_invalid', 'Bailian Qwen-MT response is not valid JSON');
+}
+function throwPayloadError(payload) {
+    const error = isRecord(payload.error) ? payload.error : undefined;
+    const code = readNonEmptyString(error?.code) ?? readNonEmptyString(payload.code);
+    if (!code)
+        return;
+    const message = readNonEmptyString(error?.message) ?? readNonEmptyString(payload.message) ?? code;
+    throw new AiRuntimeError('provider_task_failed', `Bailian Qwen-MT ${code}: ${message}`);
+}
+function normalizeSource(input) {
+    if (typeof input.source === 'string')
+        return [{ text: input.source }];
+    return input.source.map((item) => ({ text: item.text, id: item.id }));
+}
+function normalizeOptions(value, defaultStream) {
+    if (!value)
+        return { stream: defaultStream };
+    const unknownKeys = Object.keys(value).filter((key) => !ALLOWED_OPTION_KEYS.has(key));
+    if (unknownKeys.length > 0) {
+        throw new AiRuntimeError('invalid_translation_option', `Unsupported Bailian translation options: ${unknownKeys.join(', ')}; supported: stream, translationMemory`);
+    }
+    if (value.stream !== undefined && typeof value.stream !== 'boolean') {
+        throw new AiRuntimeError('invalid_translation_option', 'Bailian translation option stream must be boolean');
+    }
+    const options = value;
+    const translationMemory = normalizeTranslationMemory(options.translationMemory);
+    return { stream: options.stream ?? defaultStream, translationMemory };
+}
+function normalizeTranslationMemory(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        throw new AiRuntimeError('invalid_translation_option', 'translationMemory must be an array');
+    }
+    return value.map((item, index) => {
+        if (!isRecord(item)) {
+            throw new AiRuntimeError('invalid_translation_option', `translationMemory[${index}] must be an object`);
+        }
+        return {
+            source: requireText(item.source, `translationMemory[${index}].source`),
+            target: requireText(item.target, `translationMemory[${index}].target`),
+        };
+    });
+}
+function addUsage(current, next) {
+    if (!next)
+        return current;
+    return {
+        inputTokens: addOptional(current?.inputTokens, next.inputTokens),
+        outputTokens: addOptional(current?.outputTokens, next.outputTokens),
+        totalTokens: addOptional(current?.totalTokens, next.totalTokens),
+    };
+}
+function addOptional(a, b) {
+    return a === undefined && b === undefined ? undefined : (a ?? 0) + (b ?? 0);
+}
+function readUsage(value) {
+    if (!isRecord(value))
+        return undefined;
+    const inputTokens = readTokenCount(value.prompt_tokens ?? value.input_tokens);
+    const outputTokens = readTokenCount(value.completion_tokens ?? value.output_tokens);
+    const totalTokens = readTokenCount(value.total_tokens);
+    return inputTokens === undefined && outputTokens === undefined && totalTokens === undefined
+        ? undefined
+        : { inputTokens, outputTokens, totalTokens };
+}
+function readTokenCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function findPreset(modelId) {
+    const preset = Object.values(BAILIAN_QWEN_MT_PRESETS).find((item) => item.modelId === modelId);
+    if (!preset)
+        throw new AiRuntimeError('unsupported_model', `Unsupported Bailian Qwen-MT model: ${modelId}`);
+    return preset;
+}
+function normalizeEndpoint(value) {
+    const endpoint = value?.trim() || DEFAULT_BAILIAN_QWEN_MT_ENDPOINT;
+    let parsed;
+    try {
+        parsed = new URL(endpoint);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_endpoint', `Bailian Qwen-MT endpoint is invalid: ${endpoint}`);
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new AiRuntimeError('invalid_endpoint', 'Bailian Qwen-MT endpoint must use HTTP(S)');
+    }
+    return endpoint;
+}
+function requireText(value, field) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new AiRuntimeError('invalid_translation_input', `${field} must be a non-empty string`);
+    }
+    return value.trim();
+}
+function readNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}