sa2kit 3.4.0 → 3.7.0

package/dist/chunk-XPY45Y75.js

@@ -0,0 +1,1143 @@
+'use strict';
+
+// src/common/aiApi/types.ts
+var CORE_LLM_COMPLETION_TASK_ID = "core.llmCompletion";
+var CORE_STRUCTURED_MULTIMODAL_TASK_ID = "core.structuredMultimodal";
+var CORE_CONNECTIVITY_TEST_TASK_ID = "core.connectivityTest";
+
+// src/common/aiApi/resolveConfig.ts
+var DEFAULT_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_TEXT_MODEL = "gpt-4o-mini";
+var DEFAULT_VISION_MODEL = "gpt-4o-mini";
+var DEFAULT_AUDIO_MODEL = "whisper-1";
+var DEFAULT_AUDIO_STRATEGY = "auto";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_AUDIO_BYTES = 25 * 1024 * 1024;
+function readEnv(name) {
+  if (typeof process === "undefined" || !process.env) {
+    return "";
+  }
+  return process.env[name]?.trim() ?? "";
+}
+function resolveAiConnectionConfig(...sources) {
+  const merged = {};
+  for (const source of sources) {
+    if (!source) continue;
+    Object.assign(merged, source);
+  }
+  const envApiKey = readEnv("AI_API_KEY") || readEnv("OPENAI_API_KEY");
+  const apiKey = merged.apiKey?.trim() || envApiKey;
+  if (!apiKey) {
+    return null;
+  }
+  const baseUrl = merged.baseUrl?.trim() || readEnv("AI_BASE_URL") || DEFAULT_BASE_URL;
+  const visionModel = merged.visionModel?.trim() || readEnv("AI_VISION_MODEL") || merged.model?.trim() || DEFAULT_VISION_MODEL;
+  const textModel = merged.textModel?.trim() || readEnv("AI_TEXT_MODEL") || merged.model?.trim() || visionModel || DEFAULT_TEXT_MODEL;
+  const audioModel = merged.audioModel?.trim() || readEnv("AI_AUDIO_MODEL") || DEFAULT_AUDIO_MODEL;
+  const envAudioStrategy = readEnv("AI_AUDIO_STRATEGY");
+  const audioStrategy = merged.audioStrategy ?? (envAudioStrategy || DEFAULT_AUDIO_STRATEGY);
+  return {
+    apiKey,
+    baseUrl,
+    model: merged.model?.trim() || textModel,
+    textModel,
+    visionModel,
+    audioModel,
+    audioStrategy,
+    timeoutMs: merged.timeoutMs ?? Number(readEnv("AI_TIMEOUT_MS") || DEFAULT_TIMEOUT_MS),
+    maxImageBytes: merged.maxImageBytes ?? Number(readEnv("AI_MAX_IMAGE_BYTES") || DEFAULT_MAX_IMAGE_BYTES),
+    maxAudioBytes: merged.maxAudioBytes ?? Number(readEnv("AI_MAX_AUDIO_BYTES") || DEFAULT_MAX_AUDIO_BYTES)
+  };
+}
+function requireAiConnectionConfig(...sources) {
+  const config = resolveAiConnectionConfig(...sources);
+  if (!config) {
+    throw new Error("\u672A\u914D\u7F6E AI API Key\uFF0C\u8BF7\u4F20\u5165 connection / clientSettings \u6216\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF AI_API_KEY");
+  }
+  return config;
+}
+
+// src/common/aiApi/requestJson.ts
+async function requestJson(options) {
+  const { url, method = "POST", headers = {}, body, timeoutMs, requestAdapter } = options;
+  if (requestAdapter) {
+    return requestAdapter.request({
+      url,
+      method,
+      headers,
+      body
+    });
+  }
+  const controller = timeoutMs ? new AbortController() : void 0;
+  const timeoutId = timeoutMs ? setTimeout(() => {
+    controller?.abort();
+  }, timeoutMs) : void 0;
+  try {
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: controller?.signal
+    });
+    const text = await response.text();
+    let data = null;
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = text;
+      }
+    }
+    if (!response.ok) {
+      const record = data;
+      const errorMessage = (typeof record?.error === "object" ? record.error?.message : record?.error) || record?.message || `Request failed with status ${response.status}`;
+      const error = new Error(String(errorMessage));
+      error.status = response.status;
+      error.data = data;
+      throw error;
+    }
+    return data;
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+// src/common/aiApi/callChat.ts
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_TEXT_MODEL2 = "gpt-4o-mini";
+function joinUrl(base, path) {
+  return `${base.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function resolveMessages(input) {
+  if (input.messages?.length) {
+    return input.messages;
+  }
+  const messages = [];
+  if (input.systemPrompt?.trim()) {
+    messages.push({ role: "system", content: input.systemPrompt.trim() });
+  }
+  if (input.userPrompt?.trim()) {
+    messages.push({ role: "user", content: input.userPrompt.trim() });
+  }
+  return messages;
+}
+async function callChat(options) {
+  const {
+    baseUrl,
+    apiKey,
+    model,
+    systemPrompt,
+    userPrompt,
+    messages,
+    temperature,
+    maxTokens,
+    topP,
+    stop,
+    timeoutMs = 6e4,
+    requestAdapter
+  } = options;
+  if (!baseUrl?.trim()) {
+    throw new Error("baseUrl \u4E3A\u5FC5\u586B");
+  }
+  if (!apiKey?.trim()) {
+    throw new Error("apiKey \u4E3A\u5FC5\u586B");
+  }
+  const resolvedMessages = resolveMessages({ systemPrompt, userPrompt, messages });
+  if (!resolvedMessages.length) {
+    throw new Error("userPrompt \u6216 messages \u81F3\u5C11\u63D0\u4F9B\u4E00\u9879");
+  }
+  const resolvedModel = model?.trim() || DEFAULT_TEXT_MODEL2;
+  const payload = {
+    model: resolvedModel,
+    messages: resolvedMessages
+  };
+  if (temperature !== void 0) payload.temperature = temperature;
+  if (maxTokens !== void 0) payload.max_tokens = maxTokens;
+  if (topP !== void 0) payload.top_p = topP;
+  if (stop !== void 0) payload.stop = stop;
+  const raw = await requestJson({
+    url: joinUrl(baseUrl.trim(), "chat/completions"),
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey.trim()}`
+    },
+    body: payload,
+    timeoutMs,
+    requestAdapter
+  });
+  const content = raw.choices?.[0]?.message?.content ?? "";
+  const usage = raw.usage ? {
+    promptTokens: raw.usage.prompt_tokens,
+    completionTokens: raw.usage.completion_tokens,
+    totalTokens: raw.usage.total_tokens
+  } : void 0;
+  return {
+    content,
+    model: raw.model ?? resolvedModel,
+    usage,
+    raw
+  };
+}
+
+// src/common/aiApi/callCompletion.ts
+async function callCompletion(params, clientSettings) {
+  const config = requireAiConnectionConfig(params.connection, clientSettings);
+  const model = params.model || config.textModel;
+  const result = await callChat({
+    baseUrl: config.baseUrl,
+    apiKey: config.apiKey,
+    model,
+    systemPrompt: params.systemPrompt,
+    userPrompt: params.userPrompt,
+    temperature: params.temperature,
+    maxTokens: params.maxTokens,
+    timeoutMs: config.timeoutMs
+  });
+  return {
+    content: result.content,
+    model: result.model || model,
+    raw: result.raw
+  };
+}
+
+// src/common/aiApi/modelHeuristics.ts
+var NON_CHAT_PATTERNS = [
+  /embed/i,
+  /whisper/i,
+  /tts/i,
+  /dall-e/i,
+  /moderation/i,
+  /realtime/i,
+  /audio/i,
+  /transcrib/i,
+  /sora/i
+];
+var VISION_HINT_PATTERNS = [
+  /^gpt-4o/i,
+  /^gpt-4-turbo/i,
+  /^gpt-4-vision/i,
+  /^gpt-4\.1/i,
+  /claude-3/i,
+  /gemini.*(pro|flash|vision)/i,
+  /qwen.*vl/i,
+  /vision/i,
+  /-vl/i,
+  /llava/i,
+  /doubao.*vision/i,
+  /glm-4v/i,
+  /internvl/i,
+  /pixtral/i,
+  /deepseek-vl/i
+];
+var PREFERRED_VISION_MODELS = [
+  "gpt-4o-mini",
+  "gpt-4o",
+  "gpt-4-turbo",
+  "gpt-4-vision-preview",
+  "gpt-4.1-mini",
+  "gpt-4.1",
+  "claude-3-5-sonnet-latest",
+  "claude-3-5-haiku-latest",
+  "gemini-2.0-flash",
+  "gemini-1.5-flash",
+  "gemini-1.5-pro",
+  "qwen-vl-max",
+  "qwen2-vl-72b-instruct"
+];
+function isChatModel(id) {
+  return !NON_CHAT_PATTERNS.some((pattern) => pattern.test(id));
+}
+var NATIVE_AUDIO_CHAT_PATTERNS = [
+  /^gpt-4o/i,
+  /^gpt-4-turbo/i,
+  /^gpt-4\.1/i,
+  /gemini-2\.0/i,
+  /gemini-1\.5/i
+];
+var STT_MODEL_PATTERNS = [/whisper/i, /transcrib/i, /sensevoice/i, /paraformer/i];
+function isLikelyNativeAudioChatModel(id) {
+  const trimmed = id.trim();
+  if (!trimmed) return false;
+  if (STT_MODEL_PATTERNS.some((pattern) => pattern.test(trimmed))) return false;
+  return NATIVE_AUDIO_CHAT_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+function isLikelySttModel(id) {
+  return STT_MODEL_PATTERNS.some((pattern) => pattern.test(id.trim()));
+}
+function filterSttModels(modelIds) {
+  return modelIds.filter(isLikelySttModel).sort((a, b) => a.localeCompare(b));
+}
+var PREFERRED_STT_MODELS = ["whisper-1", "whisper-large-v3", "whisper-large-v3-turbo"];
+function pickDefaultSttModel(modelIds, current) {
+  const sttModels = filterSttModels(modelIds);
+  if (sttModels.length === 0) return void 0;
+  const trimmedCurrent = current?.trim();
+  if (trimmedCurrent && sttModels.includes(trimmedCurrent)) {
+    return trimmedCurrent;
+  }
+  for (const preferred of PREFERRED_STT_MODELS) {
+    const match = sttModels.find((id) => id === preferred || id.startsWith(`${preferred}-`));
+    if (match) return match;
+  }
+  return sttModels[0];
+}
+function isLikelyVisionModel(id) {
+  return VISION_HINT_PATTERNS.some((pattern) => pattern.test(id));
+}
+var TEXT_ONLY_MODEL_PATTERNS = [
+  /^deepseek-chat/i,
+  /^deepseek-reasoner/i,
+  /^deepseek-r1/i,
+  /^deepseek-v[34](?!.*vl)/i,
+  /^gpt-3\.5/i,
+  /^o1-mini/i,
+  /^o3-mini/i
+];
+function isKnownTextOnlyModel(id) {
+  const trimmed = id.trim();
+  if (!trimmed) return false;
+  return TEXT_ONLY_MODEL_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+function filterChatModels(modelIds) {
+  return modelIds.filter(isChatModel).sort((a, b) => a.localeCompare(b));
+}
+function filterVisionModels(modelIds) {
+  return filterChatModels(modelIds).filter((id) => isLikelyVisionModel(id) && !isKnownTextOnlyModel(id)).sort((a, b) => a.localeCompare(b));
+}
+function matchesPreferred(modelId, preferred) {
+  return modelId === preferred || modelId.startsWith(`${preferred}-`);
+}
+function pickDefaultVisionModel(modelIds, current) {
+  const visionModels = filterVisionModels(modelIds);
+  if (visionModels.length === 0) return void 0;
+  const trimmedCurrent = current?.trim();
+  if (trimmedCurrent && visionModels.includes(trimmedCurrent)) {
+    return trimmedCurrent;
+  }
+  for (const preferred of PREFERRED_VISION_MODELS) {
+    const match = visionModels.find((id) => matchesPreferred(id, preferred));
+    if (match) return match;
+  }
+  return visionModels[0];
+}
+
+// src/common/aiApi/visionMessageFormats.ts
+function detectVisionMessageFormat(baseUrl) {
+  const normalized = baseUrl.toLowerCase();
+  if (normalized.includes("ollama") || normalized.includes(":11434") || normalized.includes("11434/")) {
+    return "ollama";
+  }
+  return "openai";
+}
+function assertVisionCapableModel(modelId, options) {
+  if (!options?.hasImages) return;
+  const model = modelId.trim();
+  if (!model) {
+    throw new Error("\u8BC6\u56FE\u9700\u8981\u9009\u62E9\u89C6\u89C9\u6A21\u578B\uFF0C\u8BF7\u5728 AI \u8BBE\u7F6E\u4E2D\u914D\u7F6E");
+  }
+  const format = options.baseUrl ? detectVisionMessageFormat(options.baseUrl) : "openai";
+  if (format === "ollama") return;
+  if (isKnownTextOnlyModel(model)) {
+    throw new Error(
+      `\u5F53\u524D\u6A21\u578B\u300C${model}\u300D\u4E0D\u652F\u6301\u56FE\u7247\u8F93\u5165\u3002\u8BF7\u6539\u7528\u89C6\u89C9\u6A21\u578B\uFF0C\u4F8B\u5982 gpt-4o-mini\u3001qwen-vl-max\u3001gemini-1.5-flash\u3001deepseek-vl \u7B49\uFF08DeepSeek \u6587\u672C\u6A21\u578B\u65E0\u6CD5\u8BC6\u56FE\uFF09\u3002`
+    );
+  }
+  if (!isLikelyVisionModel(model)) {
+    throw new Error(
+      `\u6A21\u578B\u300C${model}\u300D\u53EF\u80FD\u4E0D\u652F\u6301\u56FE\u7247\u8BC6\u56FE\u3002\u8BF7\u5728 AI \u8BBE\u7F6E\u4E2D\u9009\u62E9\u540D\u79F0\u542B vl\u3001vision\u3001gpt-4o\u3001gemini \u7B49\u6807\u8BC6\u7684\u89C6\u89C9\u6A21\u578B\u3002`
+    );
+  }
+}
+function isImageUrlVariantError(message) {
+  return /unknown variant [`']?image_url[`']?/i.test(message) || /expected [`']?text[`']?/i.test(message) || /does not support.*image/i.test(message);
+}
+function toVisionApiErrorMessage(rawMessage, modelId) {
+  if (isImageUrlVariantError(rawMessage)) {
+    return `\u5F53\u524D\u6A21\u578B\u300C${modelId}\u300D\u4E0D\u63A5\u53D7\u56FE\u7247\u8BF7\u6C42\uFF08${rawMessage}\uFF09\u3002\u8BF7\u66F4\u6362\u4E3A\u652F\u6301\u8BC6\u56FE\u7684\u89C6\u89C9\u6A21\u578B\u3002`;
+  }
+  return rawMessage;
+}
+
+// src/common/aiApi/audioStrategy.ts
+function resolveAudioHandling(options) {
+  if (!options.hasAudio) {
+    return "none";
+  }
+  if (options.strategy === "stt") {
+    return "stt";
+  }
+  if (options.strategy === "native") {
+    return "native";
+  }
+  if (detectVisionMessageFormat(options.baseUrl) === "ollama") {
+    return "stt";
+  }
+  if (isLikelyNativeAudioChatModel(options.model)) {
+    return "native";
+  }
+  return "stt";
+}
+function isAudioInputError(message) {
+  return /input_audio/i.test(message) || /unknown variant [`']?input_audio[`']?/i.test(message) || /does not support.*audio/i.test(message) || /audio input/i.test(message) || /invalid audio/i.test(message);
+}
+function appendTranscriptionsToPrompt(userPrompt, transcriptions) {
+  if (transcriptions.length === 0) {
+    return userPrompt;
+  }
+  const blocks = transcriptions.map((text, index) => {
+    const label = transcriptions.length === 1 ? "[\u8BED\u97F3\u8F6C\u5199]" : `[\u8BED\u97F3\u8F6C\u5199 ${index + 1}]`;
+    return `${label}
+${text.trim()}`;
+  });
+  const joined = blocks.join("\n\n");
+  const trimmedPrompt = userPrompt.trim();
+  return trimmedPrompt ? `${trimmedPrompt}
+
+${joined}` : joined;
+}
+
+// src/common/aiApi/audioUtils.ts
+var ALLOWED_MIME = /* @__PURE__ */ new Set([
+  "audio/wav",
+  "audio/x-wav",
+  "audio/mpeg",
+  "audio/mp3",
+  "audio/mp4",
+  "audio/webm",
+  "audio/ogg",
+  "audio/flac"
+]);
+var MIME_TO_FORMAT = {
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/mpeg": "mp3",
+  "audio/mp3": "mp3",
+  "audio/mp4": "mp4",
+  "audio/webm": "webm",
+  "audio/ogg": "ogg",
+  "audio/flac": "flac"
+};
+function mimeToAudioFormat(mimeType) {
+  return MIME_TO_FORMAT[mimeType] ?? mimeType.split("/").pop() ?? "wav";
+}
+function assertValidAudioInput(audio, maxAudioBytes = 25 * 1024 * 1024) {
+  if (!audio.base64?.trim()) {
+    throw new Error("\u97F3\u9891\u6570\u636E\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (!ALLOWED_MIME.has(audio.mimeType)) {
+    throw new Error(`\u4E0D\u652F\u6301\u7684\u97F3\u9891\u683C\u5F0F: ${audio.mimeType}`);
+  }
+  const byteLength = estimateBase64ByteLength(audio.base64);
+  if (byteLength > maxAudioBytes) {
+    throw new Error(`\u97F3\u9891\u8FC7\u5927\uFF0C\u6700\u5927 ${Math.round(maxAudioBytes / 1024 / 1024)}MB`);
+  }
+}
+function estimateBase64ByteLength(base64) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.byteLength(base64, "base64");
+  }
+  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  return Math.floor(base64.length * 3 / 4) - padding;
+}
+async function fileToAiAudioInput(file) {
+  const buffer = await file.arrayBuffer();
+  if (typeof Buffer !== "undefined") {
+    return {
+      base64: Buffer.from(buffer).toString("base64"),
+      mimeType: file.type || "audio/wav"
+    };
+  }
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 1) {
+    binary += String.fromCharCode(bytes[index]);
+  }
+  return { base64: btoa(binary), mimeType: file.type || "audio/wav" };
+}
+function base64ToBlob(base64, mimeType) {
+  if (typeof Buffer !== "undefined") {
+    const bytes2 = Buffer.from(base64, "base64");
+    return new Blob([bytes2], { type: mimeType });
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return new Blob([bytes], { type: mimeType });
+}
+
+// src/common/aiApi/multimodalMessageFormats.ts
+function buildMultimodalMessages(options) {
+  const { systemPrompt, userPrompt, images, nativeAudios, format } = options;
+  const hasImages = images.length > 0;
+  const hasNativeAudio = nativeAudios.length > 0;
+  if (format === "ollama" && hasImages) {
+    return [
+      { role: "system", content: systemPrompt },
+      {
+        role: "user",
+        content: userPrompt,
+        images: images.map((image) => image.base64)
+      }
+    ];
+  }
+  const userContent = [{ type: "text", text: userPrompt }];
+  for (const image of images) {
+    userContent.push({
+      type: "image_url",
+      image_url: {
+        url: `data:${image.mimeType};base64,${image.base64}`
+      }
+    });
+  }
+  for (const audio of nativeAudios) {
+    userContent.push({
+      type: "input_audio",
+      input_audio: {
+        data: audio.base64,
+        format: mimeToAudioFormat(audio.mimeType)
+      }
+    });
+  }
+  const useStructuredContent = hasImages || hasNativeAudio;
+  return [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: useStructuredContent ? userContent : userPrompt }
+  ];
+}
+function assertMultimodalCapableModel(modelId, options) {
+  assertVisionCapableModel(modelId, {
+    baseUrl: options.baseUrl,
+    hasImages: options.hasImages
+  });
+  if (!options.hasNativeAudio) return;
+  const format = options.baseUrl ? detectVisionMessageFormat(options.baseUrl) : "openai";
+  if (format === "ollama") {
+    throw new Error('\u5F53\u524D Ollama \u8FDE\u63A5\u4E0D\u652F\u6301 chat \u5185\u5D4C\u97F3\u9891\uFF0C\u8BF7\u6539\u7528 audioStrategy: "stt" \u6216 "auto"');
+  }
+}
+
+// src/common/aiApi/imageUtils.ts
+var ALLOWED_MIME2 = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/webp", "image/gif"]);
+function assertValidImageInput(image, maxImageBytes = 5 * 1024 * 1024) {
+  if (!image.base64?.trim()) {
+    throw new Error("\u56FE\u7247\u6570\u636E\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (!ALLOWED_MIME2.has(image.mimeType)) {
+    throw new Error(`\u4E0D\u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F: ${image.mimeType}`);
+  }
+  const byteLength = estimateBase64ByteLength2(image.base64);
+  if (byteLength > maxImageBytes) {
+    throw new Error(`\u56FE\u7247\u8FC7\u5927\uFF0C\u6700\u5927 ${Math.round(maxImageBytes / 1024 / 1024)}MB`);
+  }
+}
+function estimateBase64ByteLength2(base64) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.byteLength(base64, "base64");
+  }
+  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  return Math.floor(base64.length * 3 / 4) - padding;
+}
+async function fileToAiImageInput(file) {
+  const buffer = await file.arrayBuffer();
+  if (typeof Buffer !== "undefined") {
+    return {
+      base64: Buffer.from(buffer).toString("base64"),
+      mimeType: file.type || "image/jpeg"
+    };
+  }
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 1) {
+    binary += String.fromCharCode(bytes[index]);
+  }
+  const base64 = btoa(binary);
+  return { base64, mimeType: file.type || "image/jpeg" };
+}
+
+// src/common/aiApi/mediaUtils.ts
+function splitMediaByKind(media) {
+  const images = [];
+  const audios = [];
+  for (const item of media) {
+    if (item.kind === "image") {
+      images.push(item);
+    } else {
+      audios.push(item);
+    }
+  }
+  return { images, audios };
+}
+function assertValidMultimodalMedia(media, limits) {
+  const items = media ?? [];
+  const { images, audios } = splitMediaByKind(items);
+  const maxImages = limits.maxImages ?? 8;
+  const maxAudios = limits.maxAudios ?? 4;
+  if (images.length > maxImages) {
+    throw new Error(`\u56FE\u7247\u6570\u91CF\u8FC7\u591A\uFF0C\u6700\u591A ${maxImages} \u5F20`);
+  }
+  if (audios.length > maxAudios) {
+    throw new Error(`\u97F3\u9891\u6570\u91CF\u8FC7\u591A\uFF0C\u6700\u591A ${maxAudios} \u6BB5`);
+  }
+  for (const image of images) {
+    assertValidImageInput(
+      { base64: image.base64, mimeType: image.mimeType },
+      limits.maxImageBytes
+    );
+  }
+  for (const audio of audios) {
+    assertValidAudioInput(
+      { base64: audio.base64, mimeType: audio.mimeType },
+      limits.maxAudioBytes
+    );
+  }
+  return items;
+}
+
+// src/common/aiApi/transcribeAudio.ts
+function joinUrl2(baseUrl, path) {
+  return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+async function transcribeAudio(options) {
+  const { audio, config, model, language } = options;
+  const sttModel = model?.trim() || config.audioModel;
+  const blob = base64ToBlob(audio.base64, audio.mimeType);
+  const extension = mimeToAudioFormat(audio.mimeType);
+  const form = new FormData();
+  form.append("file", blob, `audio.${extension}`);
+  form.append("model", sttModel);
+  if (language?.trim()) {
+    form.append("language", language.trim());
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.timeoutMs);
+  try {
+    const response = await fetch(joinUrl2(config.baseUrl, "audio/transcriptions"), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`
+      },
+      body: form,
+      signal: controller.signal
+    });
+    const text = await response.text();
+    let data = null;
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = text;
+      }
+    }
+    if (!response.ok) {
+      const record = data;
+      const errorMessage = (typeof record?.error === "object" ? record.error?.message : record?.error) || record?.message || `STT \u8BF7\u6C42\u5931\u8D25 (${response.status})`;
+      throw new Error(String(errorMessage));
+    }
+    if (typeof data === "string") {
+      return data.trim();
+    }
+    const parsed = data;
+    return (parsed.text ?? "").trim();
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function transcribeAudios(audios, config, model) {
+  const results = [];
+  for (const audio of audios) {
+    results.push(await transcribeAudio({ audio, config, model }));
+  }
+  return results;
+}
+
+// src/common/aiApi/callMultimodalChat.ts
+function joinUrl3(baseUrl, path) {
+  return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+async function requestMultimodalChat(options) {
+  const payload = {
+    model: options.model,
+    messages: options.messages,
+    temperature: options.temperature ?? 0.2
+  };
+  if (options.maxTokens !== void 0) {
+    payload.max_tokens = options.maxTokens;
+  }
+  if (options.jsonMode) {
+    payload.response_format = { type: "json_object" };
+  }
+  const raw = await requestJson({
+    url: joinUrl3(options.config.baseUrl, "chat/completions"),
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${options.config.apiKey}`
+    },
+    body: payload,
+    timeoutMs: options.config.timeoutMs
+  });
+  return {
+    content: raw.choices?.[0]?.message?.content ?? "",
+    model: raw.model ?? options.model,
+    raw
+  };
+}
+function toAudioInputs(audios) {
+  return audios.map((audio) => ({ base64: audio.base64, mimeType: audio.mimeType }));
+}
+async function callMultimodalChat(params, clientSettings) {
+  const config = requireAiConnectionConfig(params.connection, clientSettings);
+  const media = assertValidMultimodalMedia(params.media, {
+    maxImageBytes: config.maxImageBytes,
+    maxAudioBytes: config.maxAudioBytes
+  });
+  const { images, audios } = splitMediaByKind(media);
+  const hasImages = images.length > 0;
+  const hasAudio = audios.length > 0;
+  const model = params.model || (hasImages ? config.visionModel : hasAudio ? config.visionModel : config.textModel);
+  const strategy = params.audioStrategy ?? config.audioStrategy;
+  const format = detectVisionMessageFormat(config.baseUrl);
+  let audioHandling = resolveAudioHandling({
+    hasAudio,
+    strategy,
+    model,
+    baseUrl: config.baseUrl
+  });
+  let userPrompt = params.userPrompt;
+  let transcriptions;
+  let nativeAudios = [];
+  if (audioHandling === "stt" && hasAudio) {
+    transcriptions = await transcribeAudios(toAudioInputs(audios), config);
+    userPrompt = appendTranscriptionsToPrompt(userPrompt, transcriptions);
+  } else if (audioHandling === "native" && hasAudio) {
+    nativeAudios = audios;
+  }
+  assertMultimodalCapableModel(model, {
+    baseUrl: config.baseUrl,
+    hasImages,
+    hasNativeAudio: nativeAudios.length > 0
+  });
+  const messages = buildMultimodalMessages({
+    systemPrompt: params.systemPrompt,
+    userPrompt,
+    images,
+    nativeAudios,
+    format
+  });
+  try {
+    const result = await requestMultimodalChat({
+      config,
+      model,
+      messages,
+      temperature: params.temperature,
+      maxTokens: params.maxTokens,
+      jsonMode: params.jsonMode
+    });
+    return {
+      ...result,
+      audioHandling,
+      transcriptions
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "AI \u8BF7\u6C42\u5931\u8D25";
+    if (audioHandling === "native" && hasAudio && strategy === "auto" && isAudioInputError(message)) {
+      transcriptions = await transcribeAudios(toAudioInputs(audios), config);
+      userPrompt = appendTranscriptionsToPrompt(params.userPrompt, transcriptions);
+      audioHandling = "stt";
+      const fallbackMessages = buildMultimodalMessages({
+        systemPrompt: params.systemPrompt,
+        userPrompt,
+        images,
+        nativeAudios: [],
+        format
+      });
+      const result = await requestMultimodalChat({
+        config,
+        model,
+        messages: fallbackMessages,
+        temperature: params.temperature,
+        maxTokens: params.maxTokens,
+        jsonMode: params.jsonMode
+      });
+      return {
+        ...result,
+        audioHandling,
+        transcriptions
+      };
+    }
+    throw new Error(toVisionApiErrorMessage(message, model));
+  }
+}
+
+// src/common/aiApi/jsonUtils.ts
+function extractJsonObject(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    throw new Error("\u6A21\u578B\u8FD4\u56DE\u4E3A\u7A7A");
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]) {
+    const parsed = JSON.parse(fenced[1].trim());
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  }
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    const parsed = JSON.parse(trimmed.slice(start, end + 1));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  }
+  throw new Error("\u65E0\u6CD5\u89E3\u6790\u6A21\u578B JSON \u8F93\u51FA");
+}
+
+// src/common/aiApi/listModels.ts
+function joinUrl4(baseUrl, path) {
+  return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function parseModelIds(raw) {
+  if (Array.isArray(raw.data)) {
+    return raw.data.map((item) => item.id).filter((id) => Boolean(id));
+  }
+  if (Array.isArray(raw.models)) {
+    return raw.models.map((item) => typeof item === "string" ? item : item.id).filter((id) => Boolean(id));
+  }
+  return [];
+}
+async function listOpenAiCompatibleModels(clientSettings, currentVisionModel) {
+  const config = resolveAiConnectionConfig(clientSettings);
+  if (!config) {
+    throw new Error("\u672A\u914D\u7F6E AI API Key\uFF0C\u8BF7\u5728\u8BBE\u7F6E\u4E2D\u586B\u5199\u6216\u914D\u7F6E\u670D\u52A1\u7AEF\u73AF\u5883\u53D8\u91CF");
+  }
+  const raw = await requestJson({
+    url: joinUrl4(config.baseUrl, "models"),
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`
+    },
+    timeoutMs: config.timeoutMs
+  });
+  const modelIds = parseModelIds(raw);
+  if (modelIds.length === 0) {
+    throw new Error("\u63A5\u53E3\u672A\u8FD4\u56DE\u53EF\u7528\u6A21\u578B");
+  }
+  const models = filterChatModels(modelIds);
+  const visionModels = filterVisionModels(modelIds);
+  const suggestedVisionModel = pickDefaultVisionModel(modelIds, currentVisionModel);
+  return { models, visionModels, suggestedVisionModel };
+}
+
+// src/common/aiApi/taskRegistry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerAiTask(task) {
+  if (registry.has(task.id)) {
+    console.warn(`[aiApi] task "${task.id}" already registered, skipping duplicate`);
+    return;
+  }
+  registry.set(task.id, task);
+}
+function getAiTask(taskId) {
+  return registry.get(taskId);
+}
+function listAiTasks() {
+  return Array.from(registry.keys());
+}
+function clearAiTasksForTest() {
+  registry.clear();
+}
+
+// src/common/aiApi/runTask.ts
+function extractInputConnection(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const connection = input.connection;
+  return connection && typeof connection === "object" ? connection : void 0;
+}
+async function runAiTask(taskId, input, ctx = {}) {
+  const started = Date.now();
+  if (!resolveAiConnectionConfig(extractInputConnection(input), ctx.clientSettings)) {
+    return {
+      success: false,
+      taskId,
+      error: {
+        code: "AI_CONFIG_MISSING",
+        message: "\u672A\u914D\u7F6E AI API Key\uFF0C\u8BF7\u4F20\u5165 clientSettings.connection \u6216\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF AI_API_KEY"
+      }
+    };
+  }
+  const task = getAiTask(taskId);
+  if (!task) {
+    return {
+      success: false,
+      taskId,
+      error: {
+        code: "TASK_NOT_FOUND",
+        message: `\u672A\u6CE8\u518C\u7684\u4EFB\u52A1: ${taskId}`
+      }
+    };
+  }
+  try {
+    const validated = task.validateInput(input);
+    const result = await task.execute(validated, ctx);
+    return {
+      success: true,
+      taskId,
+      data: result.data,
+      meta: {
+        model: result.meta?.model ?? "unknown",
+        latencyMs: Date.now() - started,
+        provider: result.meta?.provider ?? "openai-compatible",
+        confidence: result.meta?.confidence,
+        rawSummary: result.meta?.rawSummary
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "AI \u4EFB\u52A1\u6267\u884C\u5931\u8D25";
+    const code = classifyError(message);
+    return {
+      success: false,
+      taskId,
+      error: { code, message },
+      meta: {
+        model: "unknown",
+        latencyMs: Date.now() - started
+      }
+    };
+  }
+}
+function classifyError(message) {
+  if (message.includes("\u672A\u914D\u7F6E") || message.includes("AI_API_KEY") || message.includes("apiKey")) {
+    return "AI_CONFIG_MISSING";
+  }
+  if (message.includes("\u56FE\u7247") || message.includes("\u683C\u5F0F")) {
+    return message.includes("\u8FC7\u5927") ? "PAYLOAD_TOO_LARGE" : "UNSUPPORTED_MEDIA";
+  }
+  if (message.includes("\u89E3\u6790") || message.includes("JSON")) {
+    return "AI_PARSE_FAILED";
+  }
+  if (message.includes("\u5FC5\u586B") || message.includes("\u65E0\u6548")) {
+    return "INVALID_INPUT";
+  }
+  return "AI_REQUEST_FAILED";
+}
+
+// src/common/aiApi/tasks/coreLlmCompletion.ts
+function isTextCompletionInput(input) {
+  if (!input || typeof input !== "object") return false;
+  const value = input;
+  return typeof value.userPrompt === "string" && value.userPrompt.trim().length > 0;
+}
+var coreLlmCompletionTask = {
+  id: CORE_LLM_COMPLETION_TASK_ID,
+  description: "\u901A\u7528\u6587\u672C\u8865\u5168\uFF1Asystem/user \u63D0\u793A\u8BCD \u2192 \u6A21\u578B\u6587\u672C",
+  validateInput(input) {
+    if (!isTextCompletionInput(input)) {
+      throw new Error("userPrompt \u4E3A\u5FC5\u586B");
+    }
+    return input;
+  },
+  async execute(input, ctx) {
+    const result = await callCompletion(
+      {
+        systemPrompt: input.systemPrompt,
+        userPrompt: input.userPrompt,
+        model: input.model,
+        temperature: input.temperature,
+        maxTokens: input.maxTokens,
+        connection: input.connection
+      },
+      ctx.clientSettings
+    );
+    return {
+      data: {
+        content: result.content,
+        rawText: result.content
+      },
+      meta: {
+        model: result.model,
+        provider: "openai-compatible"
+      }
+    };
+  }
+};
+
+// src/common/aiApi/tasks/coreStructuredMultimodal.ts
+function isStructuredMultimodalInput(input) {
+  if (!input || typeof input !== "object") return false;
+  const value = input;
+  return typeof value.systemPrompt === "string" && typeof value.userPrompt === "string";
+}
+var coreStructuredMultimodalTask = {
+  id: CORE_STRUCTURED_MULTIMODAL_TASK_ID,
+  description: "\u901A\u7528\u7ED3\u6784\u5316\u591A\u6A21\u6001\u4EFB\u52A1\uFF1A\u6587\u672C + \u53EF\u9009\u56FE\u7247/\u8BED\u97F3 \u2192 JSON",
+  validateInput(input) {
+    if (!isStructuredMultimodalInput(input)) {
+      throw new Error("systemPrompt \u4E0E userPrompt \u4E3A\u5FC5\u586B");
+    }
+    const config = resolveAiConnectionConfig(input.connection);
+    assertValidMultimodalMedia(input.media, {
+      maxImageBytes: config?.maxImageBytes ?? 5 * 1024 * 1024,
+      maxAudioBytes: config?.maxAudioBytes ?? 25 * 1024 * 1024
+    });
+    return input;
+  },
+  async execute(input, ctx) {
+    const schemaHint = input.jsonSchemaHint ? `
+
+\u8BF7\u4E25\u683C\u8F93\u51FA JSON \u5BF9\u8C61\uFF0C\u7ED3\u6784\u53C2\u8003\uFF1A
+${input.jsonSchemaHint}` : "\n\n\u8BF7\u4E25\u683C\u8F93\u51FA JSON \u5BF9\u8C61\uFF0C\u4E0D\u8981\u5305\u542B Markdown \u4EE3\u7801\u5757\u3002";
+    const result = await callMultimodalChat(
+      {
+        systemPrompt: input.systemPrompt,
+        userPrompt: `${input.userPrompt}${schemaHint}`,
+        media: input.media,
+        model: input.model,
+        temperature: input.temperature ?? 0.2,
+        maxTokens: input.maxTokens,
+        jsonMode: true,
+        audioStrategy: input.audioStrategy,
+        connection: input.connection
+      },
+      ctx.clientSettings
+    );
+    const json = extractJsonObject(result.content);
+    return {
+      data: {
+        json,
+        rawText: result.content
+      },
+      meta: {
+        model: result.model,
+        provider: "openai-compatible",
+        rawSummary: result.audioHandling ? `audio=${result.audioHandling}` : void 0
+      }
+    };
+  }
+};
+
+// src/common/aiApi/tasks/coreConnectivityTest.ts
+var coreConnectivityTestTask = {
+  id: CORE_CONNECTIVITY_TEST_TASK_ID,
+  description: "\u6D4B\u8BD5 AI API \u8FDE\u901A\u6027\uFF08\u8F7B\u91CF\u6587\u672C\u8BF7\u6C42\uFF09",
+  validateInput() {
+    return {};
+  },
+  async execute(_input, ctx) {
+    const config = resolveAiConnectionConfig(ctx.clientSettings);
+    if (!config) {
+      throw new Error("\u672A\u914D\u7F6E AI API Key");
+    }
+    const result = await callChat({
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      model: config.textModel,
+      systemPrompt: "You are a connectivity probe. Reply with JSON only.",
+      userPrompt: 'Return JSON: {"ok":true,"reply":"OK"}',
+      temperature: 0,
+      maxTokens: 32,
+      timeoutMs: config.timeoutMs
+    });
+    let ok = false;
+    let reply = result.content.trim();
+    try {
+      const json = extractJsonObject(result.content);
+      ok = json.ok === true || json.ok === "true";
+      reply = String(json.reply ?? result.content).trim();
+    } catch {
+      ok = /ok/i.test(result.content);
+    }
+    if (!ok && !reply) {
+      throw new Error("\u6A21\u578B\u672A\u8FD4\u56DE\u6709\u6548\u54CD\u5E94");
+    }
+    return {
+      data: { ok: true, reply: reply || "OK" },
+      meta: {
+        model: result.model,
+        provider: "openai-compatible"
+      }
+    };
+  }
+};
+
+// src/common/aiApi/registerCoreTasks.ts
+var registered = false;
+function registerCoreAiTasks() {
+  if (registered) return;
+  registerAiTask(coreLlmCompletionTask);
+  registerAiTask(coreStructuredMultimodalTask);
+  registerAiTask(coreConnectivityTestTask);
+  registered = true;
+}
+var ensureCoreAiTasksRegistered = registerCoreAiTasks;
+function resetCoreAiTasksForTest() {
+  registered = false;
+}
+
+exports.CORE_CONNECTIVITY_TEST_TASK_ID = CORE_CONNECTIVITY_TEST_TASK_ID;
+exports.CORE_LLM_COMPLETION_TASK_ID = CORE_LLM_COMPLETION_TASK_ID;
+exports.CORE_STRUCTURED_MULTIMODAL_TASK_ID = CORE_STRUCTURED_MULTIMODAL_TASK_ID;
+exports.DEFAULT_OPENAI_BASE_URL = DEFAULT_OPENAI_BASE_URL;
+exports.DEFAULT_TEXT_MODEL = DEFAULT_TEXT_MODEL2;
+exports.appendTranscriptionsToPrompt = appendTranscriptionsToPrompt;
+exports.assertMultimodalCapableModel = assertMultimodalCapableModel;
+exports.assertValidAudioInput = assertValidAudioInput;
+exports.assertValidImageInput = assertValidImageInput;
+exports.assertValidMultimodalMedia = assertValidMultimodalMedia;
+exports.assertVisionCapableModel = assertVisionCapableModel;
+exports.base64ToBlob = base64ToBlob;
+exports.buildMultimodalMessages = buildMultimodalMessages;
+exports.callChat = callChat;
+exports.callCompletion = callCompletion;
+exports.callMultimodalChat = callMultimodalChat;
+exports.clearAiTasksForTest = clearAiTasksForTest;
+exports.coreConnectivityTestTask = coreConnectivityTestTask;
+exports.coreLlmCompletionTask = coreLlmCompletionTask;
+exports.coreStructuredMultimodalTask = coreStructuredMultimodalTask;
+exports.detectVisionMessageFormat = detectVisionMessageFormat;
+exports.ensureCoreAiTasksRegistered = ensureCoreAiTasksRegistered;
+exports.extractJsonObject = extractJsonObject;
+exports.fileToAiAudioInput = fileToAiAudioInput;
+exports.fileToAiImageInput = fileToAiImageInput;
+exports.filterChatModels = filterChatModels;
+exports.filterSttModels = filterSttModels;
+exports.filterVisionModels = filterVisionModels;
+exports.getAiTask = getAiTask;
+exports.isAudioInputError = isAudioInputError;
+exports.isImageUrlVariantError = isImageUrlVariantError;
+exports.isKnownTextOnlyModel = isKnownTextOnlyModel;
+exports.isLikelyNativeAudioChatModel = isLikelyNativeAudioChatModel;
+exports.isLikelySttModel = isLikelySttModel;
+exports.isLikelyVisionModel = isLikelyVisionModel;
+exports.listAiTasks = listAiTasks;
+exports.listOpenAiCompatibleModels = listOpenAiCompatibleModels;
+exports.mimeToAudioFormat = mimeToAudioFormat;
+exports.pickDefaultSttModel = pickDefaultSttModel;
+exports.pickDefaultVisionModel = pickDefaultVisionModel;
+exports.registerAiTask = registerAiTask;
+exports.registerCoreAiTasks = registerCoreAiTasks;
+exports.requestJson = requestJson;
+exports.requireAiConnectionConfig = requireAiConnectionConfig;
+exports.resetCoreAiTasksForTest = resetCoreAiTasksForTest;
+exports.resolveAiConnectionConfig = resolveAiConnectionConfig;
+exports.resolveAudioHandling = resolveAudioHandling;
+exports.runAiTask = runAiTask;
+exports.splitMediaByKind = splitMediaByKind;
+exports.toVisionApiErrorMessage = toVisionApiErrorMessage;
+exports.transcribeAudio = transcribeAudio;
+exports.transcribeAudios = transcribeAudios;
+//# sourceMappingURL=chunk-XPY45Y75.js.map
+//# sourceMappingURL=chunk-XPY45Y75.js.map