sa2kit 3.3.0 → 3.6.0

package/dist/index.js

@@ -37541,8 +37541,66 @@ AI\u56DE\u5E94\uFF1A"`;
   ))));
 };
 
-// src/common/ai/llm/client/request.ts
-var requestJson = async (options) => {
+// 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({
@@ -37560,7 +37618,7 @@ var requestJson = async (options) => {
     const response = await fetch(url, {
       method,
       headers,
-      body: body ? JSON.stringify(body) : void 0,
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
       signal: controller?.signal
     });
     const text3 = await response.text();
@@ -37573,8 +37631,9 @@ var requestJson = async (options) => {
       }
     }
     if (!response.ok) {
-      const errorMessage2 = data?.error?.message || data?.error || data?.message || `Request failed with status ${response.status}`;
-      const error = new Error(errorMessage2);
+      const record = data;
+      const errorMessage2 = (typeof record?.error === "object" ? record.error?.message : record?.error) || record?.message || `Request failed with status ${response.status}`;
+      const error = new Error(String(errorMessage2));
       error.status = response.status;
       error.data = data;
       throw error;
@@ -37585,404 +37644,990 @@ var requestJson = async (options) => {
       clearTimeout(timeoutId);
     }
   }
-};
+}
 
-// src/common/ai/llm/providers/openai-compatible.ts
+// src/common/aiApi/callChat.ts
 var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
-var DEFAULT_OPENAI_MODEL = "gpt-3.5-turbo";
-var joinUrl = (base, path) => {
-  const trimmedBase = base.replace(/\/+$/, "");
-  const trimmedPath = path.replace(/^\/+/, "");
-  return `${trimmedBase}/${trimmedPath}`;
-};
-var normalizeToolCalls = (toolCalls) => {
-  if (!toolCalls || !toolCalls.length) {
-    return void 0;
+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;
   }
-  return toolCalls.map((call, index2) => ({
-    id: call?.id ?? String(index2),
-    type: "function",
-    function: {
-      name: call?.function?.name ?? "",
-      arguments: call?.function?.arguments ?? ""
-    }
-  }));
-};
-var normalizeUsage = (usage) => {
-  if (!usage) {
-    return void 0;
+  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 {
-    promptTokens: usage.prompt_tokens,
-    completionTokens: usage.completion_tokens,
-    totalTokens: usage.total_tokens
-  };
-};
-var mapMessage = (message) => {
-  const mapped = {
-    role: message.role,
-    content: message.content
-  };
-  if (message.name) {
-    mapped.name = message.name;
+    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;
   }
-  if (message.toolCallId) {
-    mapped.tool_call_id = message.toolCallId;
+  for (const preferred of PREFERRED_VISION_MODELS) {
+    const match = visionModels.find((id) => matchesPreferred(id, preferred));
+    if (match) return match;
   }
-  if (message.toolCalls?.length) {
-    mapped.tool_calls = message.toolCalls.map((call) => ({
-      id: call.id,
-      type: call.type,
-      function: {
-        name: call.function.name,
-        arguments: call.function.arguments
-      }
-    }));
+  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 mapped;
-};
-var createOpenAICompatibleProvider = () => {
-  return {
-    id: "openai-compatible",
-    sendChat: async (request, config) => {
-      if (request.stream) {
-        throw new Error("Streaming is not supported in sendChat. Use streamChat when available.");
-      }
-      const model = request.model ?? config.model ?? DEFAULT_OPENAI_MODEL;
-      if (!model) {
-        throw new Error("Model is required for chat completion requests.");
-      }
-      const payload = {
-        model,
-        messages: request.messages.map(mapMessage)
-      };
-      if (request.temperature !== void 0) {
-        payload.temperature = request.temperature;
-      }
-      if (request.maxTokens !== void 0) {
-        payload.max_tokens = request.maxTokens;
-      }
-      if (request.topP !== void 0) {
-        payload.top_p = request.topP;
-      }
-      if (request.stop !== void 0) {
-        payload.stop = request.stop;
+  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((text3, index2) => {
+    const label = transcriptions.length === 1 ? "[\u8BED\u97F3\u8F6C\u5199]" : `[\u8BED\u97F3\u8F6C\u5199 ${index2 + 1}]`;
+    return `${label}
+${text3.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 index2 = 0; index2 < bytes.length; index2 += 1) {
+    binary += String.fromCharCode(bytes[index2]);
+  }
+  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 index2 = 0; index2 < binary.length; index2 += 1) {
+    bytes[index2] = binary.charCodeAt(index2);
+  }
+  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)
       }
-      if (request.tools) {
-        payload.tools = request.tools;
+    ];
+  }
+  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}`
       }
-      if (request.toolChoice) {
-        payload.tool_choice = request.toolChoice;
+    });
+  }
+  for (const audio of nativeAudios) {
+    userContent.push({
+      type: "input_audio",
+      input_audio: {
+        data: audio.base64,
+        format: mimeToAudioFormat(audio.mimeType)
       }
-      const url = joinUrl(config.baseUrl || DEFAULT_OPENAI_BASE_URL, "chat/completions");
-      const response = await requestJson({
-        url,
-        method: "POST",
-        headers: config.headers,
-        body: payload,
-        timeoutMs: config.timeoutMs,
-        requestAdapter: config.requestAdapter
-      });
-      const firstMessage = response.choices?.[0]?.message;
-      const toolCalls = normalizeToolCalls(firstMessage?.tool_calls);
-      const content = firstMessage?.content ?? "";
-      const assistantMessage = {
-        role: "assistant",
-        content,
-        toolCalls
-      };
-      return {
-        id: response.id ?? "",
-        content,
-        message: assistantMessage,
-        usage: normalizeUsage(response.usage),
-        toolCalls,
-        raw: response
-      };
-    }
-  };
-};
+    });
+  }
+  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/ai/llm/client/createAiClient.ts
-var DEFAULT_TIMEOUT_MS = 6e4;
-var resolveApiKey = async (config) => {
-  if (config.apiKey) {
-    return config.apiKey;
+// 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 (config.getApiKey) {
-    return await config.getApiKey();
+  if (!ALLOWED_MIME2.has(image.mimeType)) {
+    throw new Error(`\u4E0D\u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F: ${image.mimeType}`);
   }
-  return void 0;
-};
-var hasAuthorizationHeader = (headers) => {
-  return Object.keys(headers).some((key) => key.toLowerCase() === "authorization");
-};
-var resolveHeaders = async (config) => {
-  const headers = {
-    "Content-Type": "application/json",
-    ...config.headers ?? {}
-  };
-  if (!hasAuthorizationHeader(headers)) {
-    const apiKey = await resolveApiKey(config);
-    if (apiKey) {
-      headers.Authorization = `Bearer ${apiKey}`;
+  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 index2 = 0; index2 < bytes.length; index2 += 1) {
+    binary += String.fromCharCode(bytes[index2]);
+  }
+  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 headers;
-};
-var resolveClientConfig = async (config) => {
-  const headers = await resolveHeaders(config);
-  return {
-    ...config,
-    baseUrl: config.baseUrl ?? "https://api.openai.com/v1",
-    headers,
-    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
-  };
-};
-var resolveProvider = (provider) => {
-  return provider ?? createOpenAICompatibleProvider();
-};
-var createAiClient = (config) => {
-  const provider = resolveProvider(config.provider);
-  const sendChat = async (request) => {
-    const resolvedConfig = await resolveClientConfig(config);
-    config.logger?.debug?.("ai.sendChat", {
-      model: request.model ?? resolvedConfig.model,
-      messageCount: request.messages.length
+  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
     });
-    try {
-      return await provider.sendChat(request, resolvedConfig);
-    } catch (error) {
-      config.logger?.error?.("ai.sendChat.error", error);
-      throw error;
+    const text3 = await response.text();
+    let data = null;
+    if (text3) {
+      try {
+        data = JSON.parse(text3);
+      } catch {
+        data = text3;
+      }
     }
-  };
-  const sendMessage = async (content, options) => {
-    const resolvedOptions = options ?? {};
-    const { systemPrompt, ...requestOptions } = resolvedOptions;
-    const messages = [];
-    if (systemPrompt) {
-      messages.push({ role: "system", content: systemPrompt });
+    if (!response.ok) {
+      const record = data;
+      const errorMessage2 = (typeof record?.error === "object" ? record.error?.message : record?.error) || record?.message || `STT \u8BF7\u6C42\u5931\u8D25 (${response.status})`;
+      throw new Error(String(errorMessage2));
     }
-    messages.push({ role: "user", content });
-    return sendChat({
-      messages,
-      ...requestOptions
-    });
+    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 {
-    sendChat,
-    sendMessage
+    content: raw.choices?.[0]?.message?.content ?? "",
+    model: raw.model ?? options.model,
+    raw
   };
-};
-
-// src/common/ai/llm/prompt/variables.ts
-var normalizePromptVariables = (variables = {}) => {
-  const normalized = {};
-  Object.entries(variables).forEach(([key, value]) => {
-    if (value === null || value === void 0) {
-      normalized[key] = "";
-    } else {
-      normalized[key] = String(value);
-    }
+}
+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
   });
-  return normalized;
-};
+  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/ai/llm/prompt/template.ts
-var applyPromptTemplate = (template, variables = {}, options = {}) => {
-  if (!template) {
-    return "";
+// src/common/aiApi/jsonUtils.ts
+function extractJsonObject(text3) {
+  const trimmed = text3.trim();
+  if (!trimmed) {
+    throw new Error("\u6A21\u578B\u8FD4\u56DE\u4E3A\u7A7A");
   }
-  const resolved = normalizePromptVariables(variables);
-  const missingValue = options.missingValue ?? "";
-  return template.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_match, key) => {
-    if (Object.prototype.hasOwnProperty.call(resolved, key)) {
-      return resolved[key] ?? "";
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
     }
-    return options.preserveUnknown ? `{{${key}}}` : missingValue;
-  });
-};
-
-// src/common/ai/llm/client/createChatSession.ts
-var buildBaseMessages = (systemPrompt, initialMessages) => {
-  const baseMessages = [];
-  if (systemPrompt) {
-    baseMessages.push({ role: "system", content: systemPrompt });
+  } catch {
   }
-  if (initialMessages?.length) {
-    baseMessages.push(...initialMessages);
+  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;
+    }
   }
-  return baseMessages;
-};
-var createChatSession = (options) => {
-  let systemPrompt = options.systemPrompt;
-  let messages = buildBaseMessages(systemPrompt, options.initialMessages);
-  const reset = () => {
-    messages = buildBaseMessages(systemPrompt, options.initialMessages);
-  };
-  const setSystemPrompt = (prompt2) => {
-    systemPrompt = prompt2;
-    reset();
-  };
-  const sendMessage = async (input, requestOptions = {}) => {
-    const { template, variables, ...chatOptions } = requestOptions;
-    const activeTemplate = template ?? options.template;
-    const mergedVariables = { input, ...variables ?? {} };
-    const content = activeTemplate ? applyPromptTemplate(activeTemplate, mergedVariables) : input;
-    const userMessage = { role: "user", content };
-    const nextMessages = [...messages, userMessage];
-    const response = await options.client.sendChat({
-      messages: nextMessages,
-      ...chatOptions
-    });
-    const assistantMessage = response.message ?? {
-      role: "assistant",
-      content: response.content,
-      toolCalls: response.toolCalls
-    };
-    messages = [...nextMessages, assistantMessage];
-    return response;
-  };
-  return {
-    getMessages: () => messages,
-    setSystemPrompt,
-    reset,
-    sendMessage
-  };
-};
-var buildBaseMessages2 = (systemPrompt, initialMessages) => {
-  const baseMessages = [];
-  if (systemPrompt) {
-    baseMessages.push({ role: "system", content: systemPrompt });
+  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;
+    }
   }
-  if (initialMessages?.length) {
-    baseMessages.push(...initialMessages);
+  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));
   }
-  return baseMessages;
-};
-var useAiChat = (options) => {
-  const systemPromptRef = React107.useRef(options.systemPrompt);
-  const templateRef = React107.useRef(options.template);
-  const [messages, setMessages] = React107.useState(
-    () => buildBaseMessages2(systemPromptRef.current, options.initialMessages)
-  );
-  const messagesRef = React107.useRef(messages);
-  const [status, setStatus] = React107.useState("idle");
-  const [error, setError] = React107.useState(null);
-  const [lastResponse, setLastResponse] = React107.useState(null);
-  const syncMessages = (nextMessages) => {
-    messagesRef.current = nextMessages;
-    setMessages(nextMessages);
-  };
-  const reset = React107.useCallback(() => {
-    syncMessages(buildBaseMessages2(systemPromptRef.current, options.initialMessages));
-    setStatus("idle");
-    setError(null);
-    setLastResponse(null);
-  }, [options.initialMessages]);
-  const setSystemPrompt = React107.useCallback(
-    (prompt2) => {
-      systemPromptRef.current = prompt2;
-      reset();
-    },
-    [reset]
-  );
-  const sendMessage = React107.useCallback(
-    async (input, requestOptions = {}) => {
-      const { template, variables, ...chatOptions } = requestOptions;
-      const activeTemplate = template ?? templateRef.current;
-      const mergedVariables = { input, ...variables ?? {} };
-      const content = activeTemplate ? applyPromptTemplate(activeTemplate, mergedVariables) : input;
-      const userMessage = { role: "user", content };
-      const nextMessages = [...messagesRef.current, userMessage];
-      syncMessages(nextMessages);
-      setStatus("loading");
-      setError(null);
-      try {
-        const response = await options.client.sendChat({
-          messages: nextMessages,
-          ...chatOptions
-        });
-        const assistantMessage = response.message ?? {
-          role: "assistant",
-          content: response.content,
-          toolCalls: response.toolCalls
-        };
-        const updatedMessages = [...nextMessages, assistantMessage];
-        syncMessages(updatedMessages);
-        setStatus("success");
-        setLastResponse(response);
-        return response;
-      } catch (err) {
-        const nextError = err instanceof Error ? err : new Error(String(err));
-        setStatus("error");
-        setError(nextError);
-        throw nextError;
-      }
+  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}`
     },
-    [options.client]
-  );
-  return {
-    status,
-    isLoading: status === "loading",
-    error,
-    messages,
-    lastResponse,
-    sendMessage,
-    reset,
-    setSystemPrompt
-  };
-};
+    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/ai/llm/skills/registry.ts
-var skillToToolDefinition = (skill) => {
-  const toolDefinition = {
-    type: "function",
-    function: {
-      name: skill.name,
-      description: skill.description
-    }
-  };
-  if (skill.inputSchema) {
-    toolDefinition.function.parameters = skill.inputSchema;
+// src/common/aiApi/taskRegistry.ts
+var registry2 = /* @__PURE__ */ new Map();
+function registerAiTask(task) {
+  if (registry2.has(task.id)) {
+    console.warn(`[aiApi] task "${task.id}" already registered, skipping duplicate`);
+    return;
   }
-  return toolDefinition;
-};
-var InMemorySkillRegistry = class {
-  constructor(initialSkills) {
-    this.skills = /* @__PURE__ */ new Map();
-    initialSkills?.forEach((skill) => {
-      this.skills.set(skill.name, skill);
-    });
+  registry2.set(task.id, task);
+}
+function getAiTask(taskId) {
+  return registry2.get(taskId);
+}
+function listAiTasks() {
+  return Array.from(registry2.keys());
+}
+function clearAiTasksForTest() {
+  registry2.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
+      }
+    };
   }
-  registerSkill(skill) {
-    this.skills.set(skill.name, skill);
+}
+function classifyError(message) {
+  if (message.includes("\u672A\u914D\u7F6E") || message.includes("AI_API_KEY") || message.includes("apiKey")) {
+    return "AI_CONFIG_MISSING";
   }
-  unregisterSkill(name) {
-    return this.skills.delete(name);
+  if (message.includes("\u56FE\u7247") || message.includes("\u683C\u5F0F")) {
+    return message.includes("\u8FC7\u5927") ? "PAYLOAD_TOO_LARGE" : "UNSUPPORTED_MEDIA";
   }
-  getSkill(name) {
-    return this.skills.get(name);
+  if (message.includes("\u89E3\u6790") || message.includes("JSON")) {
+    return "AI_PARSE_FAILED";
   }
-  listSkills() {
-    return Array.from(this.skills.values());
+  if (message.includes("\u5FC5\u586B") || message.includes("\u65E0\u6548")) {
+    return "INVALID_INPUT";
   }
-  async executeSkill(name, input, context) {
-    const skill = this.skills.get(name);
-    if (!skill) {
-      throw new Error(`Skill not found: ${name}`);
+  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 await skill.execute(input, context);
+    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"
+      }
+    };
   }
-  toToolDefinitions() {
-    return this.listSkills().map(skillToToolDefinition);
+};
+
+// 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 json2 = extractJsonObject(result.content);
+    return {
+      data: {
+        json: json2,
+        rawText: result.content
+      },
+      meta: {
+        model: result.model,
+        provider: "openai-compatible",
+        rawSummary: result.audioHandling ? `audio=${result.audioHandling}` : void 0
+      }
+    };
   }
 };
-var createSkillRegistry = (initialSkills) => {
-  return new InMemorySkillRegistry(initialSkills);
+
+// 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 json2 = extractJsonObject(result.content);
+      ok = json2.ok === true || json2.ok === "true";
+      reply = String(json2.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.About = AboutWithDefaults_default;
 exports.AboutBase = About_default;
 exports.AlertDialog = Dialog;
@@ -38005,6 +38650,9 @@ exports.BackgroundRemover = BackgroundRemover;
 exports.Badge = Badge;
 exports.BoothVaultService = BoothVaultService;
 exports.Button = Button;
+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.Card = Card;
 exports.CardContent = CardContent;
 exports.CardDescription = CardDescription;
@@ -38023,7 +38671,7 @@ exports.DEFAULT_FESTIVAL_CARD_CONFIG = DEFAULT_FESTIVAL_CARD_CONFIG;
 exports.DEFAULT_MAX_ACTIVE_FIREWORKS = DEFAULT_MAX_ACTIVE_FIREWORKS;
 exports.DEFAULT_MAX_PARTICLES = DEFAULT_MAX_PARTICLES;
 exports.DEFAULT_OPENAI_BASE_URL = DEFAULT_OPENAI_BASE_URL;
-exports.DEFAULT_OPENAI_MODEL = DEFAULT_OPENAI_MODEL;
+exports.DEFAULT_TEXT_MODEL = DEFAULT_TEXT_MODEL2;
 exports.DanmakuPanel = DanmakuPanel;
 exports.Dialog = Dialog;
 exports.DialogClose = DialogClose;
@@ -38073,7 +38721,6 @@ exports.GenericOrderManager = GenericOrderManager;
 exports.Grid = Grid;
 exports.Home = Home_default;
 exports.ImageMappingPanel = ImageMappingPanel;
-exports.InMemorySkillRegistry = InMemorySkillRegistry;
 exports.Input = Input;
 exports.Label = Label;
 exports.LocalImageMappingPanel = LocalImageMappingPanel;
@@ -38143,17 +38790,29 @@ exports.TooltipProvider = TooltipProvider;
 exports.TooltipTrigger = TooltipTrigger;
 exports.UserInfoBar = UserInfoBar;
 exports.WebSocketTransport = WebSocketTransport;
-exports.applyPromptTemplate = applyPromptTemplate;
+exports.appendTranscriptionsToPrompt = appendTranscriptionsToPrompt;
 exports.arrayUtils = arrayUtils;
+exports.assertMultimodalCapableModel = assertMultimodalCapableModel;
+exports.assertValidAudioInput = assertValidAudioInput;
+exports.assertValidImageInput = assertValidImageInput;
+exports.assertValidMultimodalMedia = assertValidMultimodalMedia;
+exports.assertVisionCapableModel = assertVisionCapableModel;
 exports.badgeVariants = badgeVariants;
+exports.base64ToBlob = base64ToBlob;
 exports.bubbleShooter = bubbleShooter_exports;
+exports.buildMultimodalMessages = buildMultimodalMessages;
 exports.business = business_exports;
 exports.buttonVariants = buttonVariants;
+exports.callChat = callChat;
+exports.callCompletion = callCompletion;
+exports.callMultimodalChat = callMultimodalChat;
 exports.checkVoteEligibility = checkVoteEligibility;
+exports.clearAiTasksForTest = clearAiTasksForTest;
 exports.cn = cn;
 exports.common = common_exports;
-exports.createAiClient = createAiClient;
-exports.createChatSession = createChatSession;
+exports.coreConnectivityTestTask = coreConnectivityTestTask;
+exports.coreLlmCompletionTask = coreLlmCompletionTask;
+exports.coreStructuredMultimodalTask = coreStructuredMultimodalTask;
 exports.createCreateSubmissionHandler = createCreateSubmissionHandler;
 exports.createDefaultMikuContestConfig = createDefaultMikuContestConfig;
 exports.createExportSubmissionsHandler = createExportSubmissionsHandler;
@@ -38165,21 +38824,28 @@ exports.createMikuContestApiClient = createMikuContestApiClient;
 exports.createMikuContestDrizzlePersistenceAdapter = createMikuContestDrizzlePersistenceAdapter;
 exports.createMikuContestPersistentService = createMikuContestPersistentService;
 exports.createMikuContestService = createMikuContestService;
-exports.createOpenAICompatibleProvider = createOpenAICompatibleProvider;
 exports.createResetVotesHandler = createResetVotesHandler;
 exports.createReviewSubmissionHandler = createReviewSubmissionHandler;
 exports.createSetVoterRestrictionHandler = createSetVoterRestrictionHandler;
-exports.createSkillRegistry = createSkillRegistry;
 exports.createUpdateContestConfigHandler = createUpdateContestConfigHandler;
 exports.createVoteHandler = createVoteHandler;
 exports.debugUtils = debugUtils;
 exports.defaultMikuVotingRules = defaultMikuVotingRules;
 exports.defaultVocaloidBoothConfig = defaultVocaloidBoothConfig;
+exports.detectVisionMessageFormat = detectVisionMessageFormat;
+exports.ensureCoreAiTasksRegistered = ensureCoreAiTasksRegistered;
 exports.errorUtils = errorUtils;
+exports.extractJsonObject = extractJsonObject;
+exports.fileToAiAudioInput = fileToAiAudioInput;
+exports.fileToAiImageInput = fileToAiImageInput;
 exports.fileUtils = fileUtils;
+exports.filterChatModels = filterChatModels;
 exports.filterExperiments = filterExperiments;
+exports.filterSttModels = filterSttModels;
+exports.filterVisionModels = filterVisionModels;
 exports.formatTime = formatTime;
 exports.generateMatchCode = generateMatchCode;
+exports.getAiTask = getAiTask;
 exports.getAllTags = getAllTags;
 exports.getCategoryColor = getCategoryColor;
 exports.getCategoryDisplayName = getCategoryDisplayName;
@@ -38187,7 +38853,15 @@ exports.getCompletionFilterDisplayName = getCompletionFilterDisplayName;
 exports.getCompletionStatusColor = getCompletionStatusColor;
 exports.getCompletionStatusText = getCompletionStatusText;
 exports.getExperimentCounts = getExperimentCounts;
+exports.isAudioInputError = isAudioInputError;
+exports.isImageUrlVariantError = isImageUrlVariantError;
+exports.isKnownTextOnlyModel = isKnownTextOnlyModel;
+exports.isLikelyNativeAudioChatModel = isLikelyNativeAudioChatModel;
+exports.isLikelySttModel = isLikelySttModel;
+exports.isLikelyVisionModel = isLikelyVisionModel;
 exports.japaneseUtils = japaneseUtils;
+exports.listAiTasks = listAiTasks;
+exports.listOpenAiCompatibleModels = listOpenAiCompatibleModels;
 exports.logger = logger;
 exports.mikuContestConfigs = mikuContestConfigs;
 exports.mikuContestDbService = mikuContestDbService;
@@ -38195,20 +38869,32 @@ exports.mikuContestNotices = mikuContestNotices;
 exports.mikuContestSubmissions = mikuContestSubmissions;
 exports.mikuContestVoterRestrictions = mikuContestVoterRestrictions;
 exports.mikuContestVotes = mikuContestVotes;
+exports.mimeToAudioFormat = mimeToAudioFormat;
 exports.miniappService = miniapp_exports;
 exports.miniappUI = miniapp_exports2;
 exports.normalizeFestivalCardConfig = normalizeFestivalCardConfig;
 exports.normalizeMatchCode = normalizeMatchCode;
-exports.normalizePromptVariables = normalizePromptVariables;
 exports.normalizeVocaloidBoothConfig = normalizeVocaloidBoothConfig;
+exports.pickDefaultSttModel = pickDefaultSttModel;
+exports.pickDefaultVisionModel = pickDefaultVisionModel;
+exports.registerAiTask = registerAiTask;
+exports.registerCoreAiTasks = registerCoreAiTasks;
+exports.requestJson = requestJson;
+exports.requireAiConnectionConfig = requireAiConnectionConfig;
+exports.resetCoreAiTasksForTest = resetCoreAiTasksForTest;
 exports.resizeFestivalCardPages = resizeFestivalCardPages;
+exports.resolveAiConnectionConfig = resolveAiConnectionConfig;
+exports.resolveAudioHandling = resolveAudioHandling;
 exports.resolveScreenReceiverSignalUrl = resolveScreenReceiverSignalUrl;
-exports.skillToToolDefinition = skillToToolDefinition;
+exports.runAiTask = runAiTask;
 exports.sortByVotesDesc = sortByVotesDesc;
 exports.sortExperiments = sortExperiments;
+exports.splitMediaByKind = splitMediaByKind;
 exports.stringUtils = stringUtils;
+exports.toVisionApiErrorMessage = toVisionApiErrorMessage;
 exports.toVoteDayKey = toVoteDayKey;
-exports.useAiChat = useAiChat;
+exports.transcribeAudio = transcribeAudio;
+exports.transcribeAudios = transcribeAudios;
 exports.useAsyncStorage = useAsyncStorage;
 exports.useBackgroundRemoval = useBackgroundRemoval;
 exports.useDanmakuController = useDanmakuController;