@h-ai/ai 0.1.0-alpha.49 → 0.1.0-alpha.51

package/dist/index.js

@@ -1,5 +1,5 @@
-import { aiM, AIConfigSchema, MemoryConfigSchema, RetrievalConfigSchema, KnowledgeConfigSchema, TokenConfigSchema, SummaryConfigSchema, CompressConfigSchema, AudioConfigSchema, ImageConfigSchema, resolveImageModel, resolveModelEntry, resolveAudioModel, resolveModelApi } from './chunk-4FDOGXIS.js';
-export { A2AConfigSchema, A2ASkillConfigSchema, AIConfigSchema, AUDIO_WS_PATH, ApiTypeSchema, AudioConfigSchema, AudioFormatSchema, AudioModelEntrySchema, AudioProviderSchema, AudioWsClientMessageSchema, AudioWsDoneMessageSchema, AudioWsStartMessageSchema, AudioWsTextMessageSchema, CompressConfigSchema, CompressionStrategySchema, EmbeddingConfigSchema, EntityTypeSchema, FileConfigSchema, ImageConfigSchema, ImageModelEntrySchema, ImageProviderSchema, KnowledgeConfigSchema, LLMConfigSchema, MCPConfigSchema, MCPServerCapabilitiesSchema, MCPServerConfigSchema, MemoryConfigSchema, MemoryTypeSchema, ModelEntrySchema, ModelScenarioSchema, OptionalSecretSchema, RetrievalConfigSchema, RetrievalSourceSchema, SummaryConfigSchema, TokenConfigSchema, resolveAudioModel, resolveImageModel, resolveModelApi, resolveModelEntry, serializePlayableAudio } from './chunk-4FDOGXIS.js';
+import { aiM, AIConfigSchema, MemoryConfigSchema, RetrievalConfigSchema, KnowledgeConfigSchema, TokenConfigSchema, SummaryConfigSchema, CompressConfigSchema, AudioConfigSchema, ImageConfigSchema, resolveImageModel, resolveModelEntry, resolveAudioModel, ensureAudioCredential, resolveModelApi } from './chunk-PLNY4UUT.js';
+export { A2AConfigSchema, A2ASkillConfigSchema, AIConfigSchema, AUDIO_WS_PATH, ApiTypeSchema, AudioConfigSchema, AudioFormatSchema, AudioModelEntrySchema, AudioOperationSchema, AudioOperationsSchema, AudioProviderSchema, AudioWsClientMessageSchema, AudioWsDoneMessageSchema, AudioWsStartMessageSchema, AudioWsTextMessageSchema, CompressConfigSchema, CompressionStrategySchema, EmbeddingConfigSchema, EntityTypeSchema, FileConfigSchema, ImageConfigSchema, ImageModelEntrySchema, ImageProviderSchema, KnowledgeConfigSchema, LLMConfigSchema, MCPConfigSchema, MCPServerCapabilitiesSchema, MCPServerConfigSchema, MemoryConfigSchema, MemoryTypeSchema, ModelEntrySchema, ModelScenarioSchema, OptionalSecretSchema, RetrievalConfigSchema, RetrievalSourceSchema, SummaryConfigSchema, TokenConfigSchema, ensureAudioCredential, resolveAudioModel, resolveImageModel, resolveModelApi, resolveModelEntry, serializePlayableAudio } from './chunk-PLNY4UUT.js';
 import { HaiAIError } from './chunk-JC7QBT3C.js';
 export { HaiAIError } from './chunk-JC7QBT3C.js';
 import { core, err, ok } from '@h-ai/core';
@@ -339,6 +339,40 @@ function fromBase64(base64) {
 function concatChunks(chunks) {
   return new Uint8Array(Buffer.concat(chunks.map((c) => Buffer.from(c))));
 }
+var AUDIO_UPLOAD_EXT = { pcm16: "wav", wav: "wav", mp3: "mp3", opus: "ogg" };
+var AUDIO_UPLOAD_MIME = { pcm16: "audio/wav", wav: "audio/wav", mp3: "audio/mpeg", opus: "audio/opus" };
+function toAudioUploadPart(audio, baseName = "audio") {
+  if (audio.format === "pcm16") {
+    const wav = wrapPcm16ToWav(audio.data, audio.sampleRate ?? 16e3, audio.channels ?? 1);
+    return { data: wav, filename: `${baseName}.wav`, mimeType: "audio/wav" };
+  }
+  return { data: audio.data, filename: `${baseName}.${AUDIO_UPLOAD_EXT[audio.format]}`, mimeType: AUDIO_UPLOAD_MIME[audio.format] };
+}
+function toAudioBlob(part) {
+  return new Blob([new Uint8Array(part.data)], { type: part.mimeType });
+}
+function wrapPcm16ToWav(pcm, sampleRate, channels = 1) {
+  const bitsPerSample = 16;
+  const byteRate = sampleRate * channels * bitsPerSample / 8;
+  const blockAlign = channels * bitsPerSample / 8;
+  const dataSize = pcm.length;
+  const buffer = Buffer.alloc(44 + dataSize);
+  buffer.write("RIFF", 0);
+  buffer.writeUInt32LE(36 + dataSize, 4);
+  buffer.write("WAVE", 8);
+  buffer.write("fmt ", 12);
+  buffer.writeUInt32LE(16, 16);
+  buffer.writeUInt16LE(1, 20);
+  buffer.writeUInt16LE(channels, 22);
+  buffer.writeUInt32LE(sampleRate, 24);
+  buffer.writeUInt32LE(byteRate, 28);
+  buffer.writeUInt16LE(blockAlign, 32);
+  buffer.writeUInt16LE(bitsPerSample, 34);
+  buffer.write("data", 36);
+  buffer.writeUInt32LE(dataSize, 40);
+  Buffer.from(pcm).copy(buffer, 44);
+  return new Uint8Array(buffer);
+}
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -362,6 +396,14 @@ function mapStreamError(error, signal) {
 function toAudioErrorResult(error, signal) {
   return { success: false, error: mapStreamError(error, signal) };
 }
+function combineSignal(signal, timeout) {
+  const timeoutSignal = AbortSignal.timeout(timeout);
+  return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+}
+async function describeHttpError(response) {
+  const text = await response.text().catch(() => "");
+  return `HTTP ${response.status} ${text.slice(0, 200)}`.trim();
+}
 var logger2 = core.logger.child({ module: "ai", scope: "audio-ws" });
 function openAudioWebSocket(url, headers, options) {
   return new Promise((resolve, reject) => {
@@ -759,7 +801,11 @@ function createDoubaoAudioProvider() {
       conn.close();
     }
   }
-  return { transcribe, transcribeStream, synthesize, synthesizeStream, resolveSynthesisOutput, capabilities: DOUBAO_CAPABILITIES };
+  return {
+    transcription: { transcribe, transcribeStream },
+    synthesis: { synthesize, synthesizeStream, resolveSynthesisOutput },
+    getCapabilities: () => DOUBAO_CAPABILITIES
+  };
 }
 function resolveSynthesisOutput(request) {
   const format = request.format ?? "pcm16";
@@ -776,6 +822,120 @@ function decodeBinaryMessage(message) {
     return void 0;
   return decodeFrame(message.binary);
 }
+var logger4 = core.logger.child({ module: "ai", scope: "audio-indextts" });
+var INDEX_TTS_CAPABILITIES = {
+  synthesize: {
+    supported: true,
+    incrementalTextInput: false,
+    streamingAudioOutput: false,
+    languageSelection: true,
+    presetVoice: false,
+    speakerReference: true,
+    speakerReferenceRequired: true,
+    styleReference: true,
+    instruction: false,
+    speedControl: true,
+    targetDuration: true,
+    supportedLanguages: ["zh", "en", "ja"]
+  }
+};
+var HEADER_DURATION_MS = "x-hai-audio-duration-ms";
+var HEADER_DURATION_MATCHED = "x-hai-duration-matched";
+var HEADER_APPLIED_SPEED = "x-hai-applied-speed";
+var HEADER_SAMPLE_RATE = "x-hai-audio-sample-rate";
+var HEADER_CHANNELS = "x-hai-audio-channels";
+function createIndexTtsAudioProvider() {
+  async function synthesize(request) {
+    const { model, text, language, speakerReference, styleReference, styleStrength, speed, targetDurationMs, durationToleranceMs, format, sampleRate, signal } = request;
+    if (!speakerReference)
+      return err(HaiAIError.AUDIO_INVALID_REQUEST, aiM("ai_audioInvalidRequest", { params: { reason: "speaker_reference is required" } }));
+    const out = resolveSynthesisOutput2({ format, sampleRate });
+    try {
+      const form = new FormData();
+      form.append("text", text);
+      form.append("model", model.model);
+      if (language)
+        form.append("language", language);
+      appendReference(form, "speaker_reference", speakerReference);
+      if (styleReference)
+        appendReference(form, "style_reference", styleReference);
+      if (styleStrength !== void 0)
+        form.append("style_strength", String(styleStrength));
+      if (speed !== void 0)
+        form.append("speed", String(speed));
+      if (targetDurationMs !== void 0)
+        form.append("target_duration_ms", String(targetDurationMs));
+      if (durationToleranceMs !== void 0)
+        form.append("duration_tolerance_ms", String(durationToleranceMs));
+      form.append("response_format", out.format);
+      if (out.sampleRate !== void 0)
+        form.append("sample_rate", String(out.sampleRate));
+      const headers = {};
+      if (model.apiKey)
+        headers.Authorization = `Bearer ${model.apiKey}`;
+      const response = await fetch(`${model.baseUrl.replace(/\/$/, "")}/audio/speech`, {
+        method: "POST",
+        headers,
+        body: form,
+        signal: combineSignal(signal, model.timeout)
+      });
+      if (!response.ok)
+        return err(HaiAIError.AUDIO_UPSTREAM_ERROR, aiM("ai_audioUpstreamError", { params: { error: await describeHttpError(response) } }));
+      const data = new Uint8Array(await response.arrayBuffer());
+      return ok(buildSynthesisResult(data, out, response.headers));
+    } catch (error) {
+      logger4.debug("IndexTTS synthesize failed", { error: errorMessage(error) });
+      return toAudioErrorResult(error, signal);
+    }
+  }
+  return {
+    synthesis: { synthesize, resolveSynthesisOutput: resolveSynthesisOutput2 },
+    getCapabilities: () => INDEX_TTS_CAPABILITIES
+  };
+}
+function resolveSynthesisOutput2(request) {
+  const format = request.format ?? "wav";
+  return { format, sampleRate: format === "pcm16" ? request.sampleRate ?? 24e3 : void 0, channels: 1 };
+}
+function appendReference(form, field, reference) {
+  const part = toAudioUploadPart(reference.audio, field);
+  form.append(field, toAudioBlob(part), part.filename);
+  if (reference.transcript)
+    form.append(`${field}_text`, reference.transcript);
+  if (reference.language)
+    form.append(`${field}_language`, reference.language);
+}
+function buildSynthesisResult(data, out, headers) {
+  const durationMs = parseNumberHeader(headers.get(HEADER_DURATION_MS));
+  const sampleRate = parseNumberHeader(headers.get(HEADER_SAMPLE_RATE)) ?? out.sampleRate;
+  const channels = parseNumberHeader(headers.get(HEADER_CHANNELS)) === 2 ? 2 : out.channels;
+  const durationMatched = parseBooleanHeader(headers.get(HEADER_DURATION_MATCHED));
+  const appliedSpeed = parseNumberHeader(headers.get(HEADER_APPLIED_SPEED));
+  const metadata = {};
+  if (durationMatched !== void 0)
+    metadata.durationMatched = durationMatched;
+  if (appliedSpeed !== void 0)
+    metadata.speed = appliedSpeed;
+  return {
+    data,
+    format: out.format,
+    sampleRate,
+    channels,
+    ...durationMs !== void 0 ? { durationMs } : {},
+    ...Object.keys(metadata).length ? { metadata } : {}
+  };
+}
+function parseNumberHeader(value) {
+  if (value === null)
+    return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseBooleanHeader(value) {
+  if (value === null)
+    return void 0;
+  return value === "true" || value === "1";
+}
 
 // src/llm/ai-llm-stream.ts
 function createStreamProcessor() {
@@ -928,7 +1088,7 @@ function encodeSSE(event) {
 }
 
 // src/audio/providers/ai-audio-provider-mimo.ts
-var logger4 = core.logger.child({ module: "ai", scope: "audio-mimo" });
+var logger5 = core.logger.child({ module: "ai", scope: "audio-mimo" });
 var MIMO_CAPABILITIES = {
   transcribe: { supported: true, realtimeAudioInput: false, speechBoundaryEvents: false, streamingTranscriptOutput: true },
   synthesize: { supported: true, incrementalTextInput: false, streamingAudioOutput: true }
@@ -955,7 +1115,7 @@ function createMimoAudioProvider() {
       const text = body.choices?.[0]?.message?.content ?? "";
       return ok({ text });
     } catch (error) {
-      logger4.debug("MiMo transcribe failed", { error: errorMessage(error) });
+      logger5.debug("MiMo transcribe failed", { error: errorMessage(error) });
       return toAudioErrorResult(error, signal);
     }
   }
@@ -988,7 +1148,7 @@ function createMimoAudioProvider() {
   }
   async function synthesize(request) {
     const { model, text, voice, instruction, format, sampleRate, signal } = request;
-    const out = resolveSynthesisOutput2({ format, sampleRate });
+    const out = resolveSynthesisOutput3({ format, sampleRate });
     try {
       const response = await postChat(model.baseUrl, model.apiKey, {
         model: model.model,
@@ -1003,13 +1163,13 @@ function createMimoAudioProvider() {
         return err(HaiAIError.AUDIO_UPSTREAM_ERROR, aiM("ai_audioUpstreamError", { params: { error: "missing audio data" } }));
       return ok({ data: fromBase64(base64), format: out.format, sampleRate: out.sampleRate, channels: out.channels });
     } catch (error) {
-      logger4.debug("MiMo synthesize failed", { error: errorMessage(error) });
+      logger5.debug("MiMo synthesize failed", { error: errorMessage(error) });
       return toAudioErrorResult(error, signal);
     }
   }
   async function* synthesizeStream(request) {
     const { model, text, voice, instruction, format, signal } = request;
-    const outFormat = resolveSynthesisOutput2({ format }).format;
+    const outFormat = resolveSynthesisOutput3({ format }).format;
     const segments = typeof text === "string" ? [text] : streamSentences(text);
     for await (const segment of segments) {
       if (!segment)
@@ -1029,9 +1189,13 @@ function createMimoAudioProvider() {
       }
     }
   }
-  return { transcribe, transcribeStream, synthesize, synthesizeStream, resolveSynthesisOutput: resolveSynthesisOutput2, capabilities: MIMO_CAPABILITIES };
+  return {
+    transcription: { transcribe, transcribeStream },
+    synthesis: { synthesize, synthesizeStream, resolveSynthesisOutput: resolveSynthesisOutput3 },
+    getCapabilities: () => MIMO_CAPABILITIES
+  };
 }
-function resolveSynthesisOutput2(request) {
+function resolveSynthesisOutput3(request) {
   const format = request.format === "wav" ? "wav" : "pcm16";
   return { format, sampleRate: format === "pcm16" ? request.sampleRate ?? 24e3 : void 0, channels: 1 };
 }
@@ -1080,15 +1244,7 @@ async function* readChunks(response) {
     reader.releaseLock();
   }
 }
-function combineSignal(signal, timeout) {
-  const timeoutSignal = AbortSignal.timeout(timeout);
-  return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-}
-async function describeHttpError(response) {
-  const text = await response.text().catch(() => "");
-  return `HTTP ${response.status} ${text.slice(0, 200)}`.trim();
-}
-var logger5 = core.logger.child({ module: "ai", scope: "audio-openai" });
+var logger6 = core.logger.child({ module: "ai", scope: "audio-openai" });
 var OPENAI_CAPABILITIES = {
   transcribe: { supported: true, realtimeAudioInput: false, speechBoundaryEvents: false, streamingTranscriptOutput: false },
   synthesize: { supported: true, incrementalTextInput: false, streamingAudioOutput: true }
@@ -1099,12 +1255,6 @@ var OPENAI_SPEECH_FORMAT = {
   mp3: "mp3",
   opus: "opus"
 };
-var OPENAI_UPLOAD_FILENAME = {
-  pcm16: "audio.wav",
-  wav: "audio.wav",
-  mp3: "audio.mp3",
-  opus: "audio.ogg"
-};
 function createOpenAIAudioProvider() {
   function createClient(apiKey, baseUrl, timeout) {
     return new OpenAI3({ apiKey, baseURL: baseUrl, timeout });
@@ -1124,7 +1274,7 @@ function createOpenAIAudioProvider() {
       }, { signal });
       return ok({ text: result.text });
     } catch (error) {
-      logger5.debug("OpenAI transcribe failed", { error: errorMessage(error) });
+      logger6.debug("OpenAI transcribe failed", { error: errorMessage(error) });
       return toAudioErrorResult(error, signal);
     }
   }
@@ -1161,7 +1311,7 @@ function createOpenAIAudioProvider() {
     const { model, text, voice, instruction, format, sampleRate, signal } = request;
     if (!model.apiKey)
       return err(HaiAIError.CONFIGURATION_ERROR, aiM("ai_audioMissingApiKey", { params: { provider: "openai" } }));
-    const out = resolveSynthesisOutput3({ format, sampleRate });
+    const out = resolveSynthesisOutput4({ format, sampleRate });
     try {
       const client = createClient(model.apiKey, model.baseUrl, model.timeout);
       const response = await client.audio.speech.create({
@@ -1174,7 +1324,7 @@ function createOpenAIAudioProvider() {
       const data = new Uint8Array(await response.arrayBuffer());
       return ok({ data, format: out.format, sampleRate: out.sampleRate, channels: out.channels });
     } catch (error) {
-      logger5.debug("OpenAI synthesize failed", { error: errorMessage(error) });
+      logger6.debug("OpenAI synthesize failed", { error: errorMessage(error) });
       return toAudioErrorResult(error, signal);
     }
   }
@@ -1182,7 +1332,7 @@ function createOpenAIAudioProvider() {
     const { model, text, voice, instruction, format, signal } = request;
     if (!model.apiKey)
       throw audioError(HaiAIError.CONFIGURATION_ERROR, aiM("ai_audioMissingApiKey", { params: { provider: "openai" } }));
-    const outFormat = resolveSynthesisOutput3({ format }).format;
+    const outFormat = resolveSynthesisOutput4({ format }).format;
     const client = createClient(model.apiKey, model.baseUrl, model.timeout);
     const segments = typeof text === "string" ? [text] : streamSentences(text);
     for await (const segment of segments) {
@@ -1214,42 +1364,21 @@ function createOpenAIAudioProvider() {
       }
     }
   }
-  return { transcribe, transcribeStream, synthesize, synthesizeStream, resolveSynthesisOutput: resolveSynthesisOutput3, capabilities: OPENAI_CAPABILITIES };
+  return {
+    transcription: { transcribe, transcribeStream },
+    synthesis: { synthesize, synthesizeStream, resolveSynthesisOutput: resolveSynthesisOutput4 },
+    getCapabilities: () => OPENAI_CAPABILITIES
+  };
 }
-function resolveSynthesisOutput3(request) {
+function resolveSynthesisOutput4(request) {
   const format = request.format ?? "mp3";
   return { format, sampleRate: format === "pcm16" ? request.sampleRate ?? 24e3 : void 0, channels: 1 };
 }
 async function toUploadFile(audio) {
-  if (audio.format === "pcm16") {
-    const wav = wrapPcmToWav(audio.data, audio.sampleRate ?? 16e3, audio.channels ?? 1);
-    return toFile(Buffer.from(wav), "audio.wav");
-  }
-  return toFile(Buffer.from(audio.data), OPENAI_UPLOAD_FILENAME[audio.format]);
+  const part = toAudioUploadPart(audio);
+  return toFile(Buffer.from(part.data), part.filename);
 }
-function wrapPcmToWav(pcm, sampleRate, channels) {
-  const bitsPerSample = 16;
-  const byteRate = sampleRate * channels * bitsPerSample / 8;
-  const blockAlign = channels * bitsPerSample / 8;
-  const dataSize = pcm.length;
-  const buffer = Buffer.alloc(44 + dataSize);
-  buffer.write("RIFF", 0);
-  buffer.writeUInt32LE(36 + dataSize, 4);
-  buffer.write("WAVE", 8);
-  buffer.write("fmt ", 12);
-  buffer.writeUInt32LE(16, 16);
-  buffer.writeUInt16LE(1, 20);
-  buffer.writeUInt16LE(channels, 22);
-  buffer.writeUInt32LE(sampleRate, 24);
-  buffer.writeUInt32LE(byteRate, 28);
-  buffer.writeUInt16LE(blockAlign, 32);
-  buffer.writeUInt16LE(bitsPerSample, 34);
-  buffer.write("data", 36);
-  buffer.writeUInt32LE(dataSize, 40);
-  Buffer.from(pcm).copy(buffer, 44);
-  return new Uint8Array(buffer);
-}
-var logger6 = core.logger.child({ module: "ai", scope: "audio-qwen" });
+var logger7 = core.logger.child({ module: "ai", scope: "audio-qwen" });
 var QWEN_CAPABILITIES = {
   transcribe: { supported: true, realtimeAudioInput: true, speechBoundaryEvents: true, streamingTranscriptOutput: true },
   synthesize: { supported: true, incrementalTextInput: true, streamingAudioOutput: true }
@@ -1282,7 +1411,7 @@ function createQwenAudioProvider() {
       }
       return ok({ text: finalText });
     } catch (error) {
-      logger6.debug("Qwen transcribe failed", { error: errorMessage(error) });
+      logger7.debug("Qwen transcribe failed", { error: errorMessage(error) });
       return toAudioErrorResult(error);
     }
   }
@@ -1354,21 +1483,21 @@ function createQwenAudioProvider() {
   }
   async function synthesize(request) {
     const { format, sampleRate } = request;
-    const out = resolveSynthesisOutput4({ format, sampleRate });
+    const out = resolveSynthesisOutput5({ format, sampleRate });
     try {
       const chunks = [];
       for await (const audio of synthesizeStream({ model: request.model, text: request.text, voice: request.voice, instruction: request.instruction, format: out.format, sampleRate, signal: request.signal }))
         chunks.push(audio);
       return ok({ data: concatChunks(chunks), format: out.format, sampleRate: out.sampleRate, channels: out.channels });
     } catch (error) {
-      logger6.debug("Qwen synthesize failed", { error: errorMessage(error) });
+      logger7.debug("Qwen synthesize failed", { error: errorMessage(error) });
       return toAudioErrorResult(error);
     }
   }
   async function* synthesizeStream(request) {
     const { model, text, voice, instruction, format, sampleRate, signal } = request;
     const isStreamInput = typeof text !== "string";
-    const outFormat = resolveSynthesisOutput4({ format }).format;
+    const outFormat = resolveSynthesisOutput5({ format }).format;
     const conn = await connect(model, signal);
     try {
       conn.send(JSON.stringify({
@@ -1417,9 +1546,13 @@ function createQwenAudioProvider() {
       conn.close();
     }
   }
-  return { transcribe, transcribeStream, synthesize, synthesizeStream, resolveSynthesisOutput: resolveSynthesisOutput4, capabilities: QWEN_CAPABILITIES };
+  return {
+    transcription: { transcribe, transcribeStream },
+    synthesis: { synthesize, synthesizeStream, resolveSynthesisOutput: resolveSynthesisOutput5 },
+    getCapabilities: () => QWEN_CAPABILITIES
+  };
 }
-function resolveSynthesisOutput4(request) {
+function resolveSynthesisOutput5(request) {
   const format = request.format ?? "pcm16";
   return { format, sampleRate: format === "pcm16" ? request.sampleRate ?? 24e3 : void 0, channels: 1 };
 }
@@ -1430,9 +1563,95 @@ function parseEvent(text) {
     return {};
   }
 }
+var logger8 = core.logger.child({ module: "ai", scope: "audio-whisper" });
+var WHISPER_CAPABILITIES = {
+  transcribe: {
+    supported: true,
+    realtimeAudioInput: false,
+    speechBoundaryEvents: false,
+    streamingTranscriptOutput: false,
+    languageHint: true,
+    languageDetection: true,
+    segmentTimestamps: true,
+    wordTimestamps: true,
+    contextHints: true,
+    vad: true,
+    speakerDiarization: false
+  }
+};
+function createWhisperAudioProvider() {
+  async function transcribe(request) {
+    const { model, audio, language, contextHints, timestampGranularities, vad, signal } = request;
+    try {
+      const part = toAudioUploadPart(audio);
+      const form = new FormData();
+      form.append("file", toAudioBlob(part), part.filename);
+      form.append("model", model.model);
+      if (language)
+        form.append("language", language);
+      if (contextHints?.length)
+        form.append("prompt", contextHints.join(", "));
+      for (const granularity of timestampGranularities ?? [])
+        form.append("timestamp_granularities", granularity);
+      if (vad !== void 0)
+        form.append("vad", String(vad));
+      const headers = {};
+      if (model.apiKey)
+        headers.Authorization = `Bearer ${model.apiKey}`;
+      const response = await fetch(`${model.baseUrl.replace(/\/$/, "")}/audio/transcriptions`, {
+        method: "POST",
+        headers,
+        body: form,
+        signal: combineSignal(signal, model.timeout)
+      });
+      if (!response.ok)
+        return err(HaiAIError.AUDIO_UPSTREAM_ERROR, aiM("ai_audioUpstreamError", { params: { error: await describeHttpError(response) } }));
+      const body = await response.json();
+      return ok(mapWhisperResponse(body));
+    } catch (error) {
+      logger8.debug("Whisper transcribe failed", { error: errorMessage(error) });
+      return toAudioErrorResult(error, signal);
+    }
+  }
+  return {
+    transcription: { transcribe },
+    getCapabilities: () => WHISPER_CAPABILITIES
+  };
+}
+function mapWhisperResponse(body) {
+  const segments = body.segments?.map(mapWhisperSegment).filter((segment) => segment !== null);
+  return {
+    text: body.text ?? "",
+    language: body.language,
+    durationMs: body.durationMs,
+    ...segments?.length ? { segments } : {}
+  };
+}
+function mapWhisperSegment(segment) {
+  if (typeof segment.startMs !== "number" || typeof segment.endMs !== "number")
+    return null;
+  const words = segment.words?.map(mapWhisperWord).filter((word) => word !== null);
+  return {
+    ...segment.id !== void 0 ? { id: String(segment.id) } : {},
+    text: segment.text ?? "",
+    startMs: segment.startMs,
+    endMs: segment.endMs,
+    ...words?.length ? { words } : {}
+  };
+}
+function mapWhisperWord(word) {
+  if (typeof word.startMs !== "number" || typeof word.endMs !== "number")
+    return null;
+  return {
+    text: word.text ?? "",
+    startMs: word.startMs,
+    endMs: word.endMs,
+    ...typeof word.confidence === "number" ? { confidence: word.confidence } : {}
+  };
+}
 
 // src/audio/ai-audio-functions.ts
-var logger7 = core.logger.child({ module: "ai", scope: "audio" });
+var logger9 = core.logger.child({ module: "ai", scope: "audio" });
 function createAudioOperations(config) {
   const audioConfig = AudioConfigSchema.parse(config.audio ?? {});
   const providerCache = /* @__PURE__ */ new Map();
@@ -1449,6 +1668,19 @@ function createAudioOperations(config) {
       return audioError(HaiAIError.AUDIO_INPUT_TOO_LARGE, aiM("ai_audioInputTooLarge", { params: { limit: audioConfig.maxAudioBytes } }));
     return null;
   }
+  function guardSynthesisReferences(options) {
+    if (options.speakerReference) {
+      const e = guardAudioSize(options.speakerReference.audio);
+      if (e)
+        return e;
+    }
+    if (options.styleReference) {
+      const e = guardAudioSize(options.styleReference.audio);
+      if (e)
+        return e;
+    }
+    return null;
+  }
   function withStreamTimeout(signal) {
     const timeout = AbortSignal.timeout(audioConfig.maxStreamDurationMs);
     return signal ? AbortSignal.any([signal, timeout]) : timeout;
@@ -1462,14 +1694,26 @@ function createAudioOperations(config) {
     const resolved = resolveAudioModel(audioConfig, "transcribe", request.model, config.llm.apiKey);
     if (!resolved.success)
       return resolved;
+    const provider = getProvider(resolved.data.provider);
+    const transcription = provider.transcription;
+    if (!transcription)
+      return err(HaiAIError.AUDIO_UNSUPPORTED_INPUT, aiM("ai_audioUnsupportedInput", { params: { provider: resolved.data.provider, reason: "transcription" } }));
+    const credErr = ensureAudioCredential(resolved.data);
+    if (credErr)
+      return { success: false, error: credErr };
+    if (request.strictCapabilities) {
+      const capErr = checkTranscribeCapabilities(resolved.data.provider, request, provider.getCapabilities(resolved.data));
+      if (capErr)
+        return { success: false, error: capErr };
+    }
     const startedAt = Date.now();
     const context = { provider: resolved.data.provider, model: resolved.data.model, audioBytes: request.audio.data.length };
-    logger7.debug("Audio transcription started", context);
-    const result = await getProvider(resolved.data.provider).transcribe({ model: resolved.data, audio: request.audio, language: request.language, contextHints: request.contextHints, signal: request.signal });
+    logger9.debug("Audio transcription started", context);
+    const result = await transcription.transcribe({ model: resolved.data, audio: request.audio, language: request.language, contextHints: request.contextHints, timestampGranularities: request.timestampGranularities, vad: request.vad, signal: request.signal });
     if (result.success)
-      logger7.info("Audio transcription completed", { ...context, durationMs: Date.now() - startedAt, textLength: result.data.text.length });
+      logger9.info("Audio transcription completed", { ...context, durationMs: Date.now() - startedAt, textLength: result.data.text.length });
     else
-      logger7.warn("Audio transcription failed", { ...context, durationMs: Date.now() - startedAt, code: result.error.code, error: result.error.message });
+      logger9.warn("Audio transcription failed", { ...context, durationMs: Date.now() - startedAt, code: result.error.code, error: result.error.message });
     return result;
   }
   async function* transcribeStream(request) {
@@ -1483,75 +1727,112 @@ function createAudioOperations(config) {
     const resolved = resolveAudioModel(audioConfig, "transcribe", request.model, config.llm.apiKey);
     if (!resolved.success)
       throw resolved.error;
+    const provider = getProvider(resolved.data.provider);
+    const transcription = provider.transcription;
+    if (!transcription)
+      throw audioError(HaiAIError.AUDIO_UNSUPPORTED_INPUT, aiM("ai_audioUnsupportedInput", { params: { provider: resolved.data.provider, reason: "transcription" } }));
+    const credErr = ensureAudioCredential(resolved.data);
+    if (credErr)
+      throw credErr;
+    if (request.strictCapabilities) {
+      const capErr = checkTranscribeCapabilities(resolved.data.provider, request, provider.getCapabilities(resolved.data));
+      if (capErr)
+        throw capErr;
+    }
     const startedAt = Date.now();
     const context = { provider: resolved.data.provider, model: resolved.data.model };
-    logger7.debug("Audio transcription stream started", context);
+    logger9.debug("Audio transcription stream started", context);
     const signal = withStreamTimeout(request.signal);
     try {
-      yield* getProvider(resolved.data.provider).transcribeStream({ model: resolved.data, audio: request.audio, language: request.language, contextHints: request.contextHints, signal });
-      logger7.info("Audio transcription stream completed", { ...context, durationMs: Date.now() - startedAt });
+      yield* transcribeStreamOrFallback(transcription, { model: resolved.data, audio: request.audio, language: request.language, contextHints: request.contextHints, timestampGranularities: request.timestampGranularities, vad: request.vad, signal });
+      logger9.info("Audio transcription stream completed", { ...context, durationMs: Date.now() - startedAt });
     } catch (error) {
-      logger7.warn("Audio transcription stream failed", { ...context, durationMs: Date.now() - startedAt, error });
+      logger9.warn("Audio transcription stream failed", { ...context, durationMs: Date.now() - startedAt, error });
       throw mapStreamError(error, signal);
     }
   }
   async function synthesize(request) {
     if (!request.text)
       return err(HaiAIError.AUDIO_INVALID_REQUEST, aiM("ai_audioInvalidRequest", { params: { reason: "empty text" } }));
+    const validErr = validateSynthesisRequest(request);
+    if (validErr)
+      return { success: false, error: validErr };
+    const refErr = guardSynthesisReferences(request);
+    if (refErr)
+      return { success: false, error: refErr };
     const resolved = resolveAudioModel(audioConfig, "synthesize", request.model, config.llm.apiKey);
     if (!resolved.success)
       return resolved;
+    const provider = getProvider(resolved.data.provider);
+    const synthesis = provider.synthesis;
+    if (!synthesis)
+      return err(HaiAIError.AUDIO_UNSUPPORTED_INPUT, aiM("ai_audioUnsupportedInput", { params: { provider: resolved.data.provider, reason: "synthesis" } }));
+    const credErr = ensureAudioCredential(resolved.data);
+    if (credErr)
+      return { success: false, error: credErr };
+    if (request.strictCapabilities) {
+      const capErr = checkSynthesizeCapabilities(resolved.data.provider, request, provider.getCapabilities(resolved.data));
+      if (capErr)
+        return { success: false, error: capErr };
+    }
     const startedAt = Date.now();
     const context = { provider: resolved.data.provider, model: resolved.data.model, textLength: request.text.length, voice: request.voice };
-    logger7.debug("Audio synthesis started", context);
-    const result = await getProvider(resolved.data.provider).synthesize({ model: resolved.data, text: request.text, voice: request.voice, instruction: request.instruction, format: request.format, sampleRate: request.sampleRate, signal: request.signal });
+    logger9.debug("Audio synthesis started", context);
+    const result = await synthesis.synthesize({ model: resolved.data, text: request.text, language: request.language, voice: request.voice, speakerReference: request.speakerReference, styleReference: request.styleReference, styleStrength: request.styleStrength, instruction: request.instruction, speed: request.speed, targetDurationMs: request.targetDurationMs, durationToleranceMs: request.durationToleranceMs, format: request.format, sampleRate: request.sampleRate, signal: request.signal });
     if (result.success)
-      logger7.info("Audio synthesis completed", { ...context, durationMs: Date.now() - startedAt, audioBytes: result.data.data.length, format: result.data.format });
+      logger9.info("Audio synthesis completed", { ...context, durationMs: Date.now() - startedAt, audioBytes: result.data.data.length, format: result.data.format });
     else
-      logger7.warn("Audio synthesis failed", { ...context, durationMs: Date.now() - startedAt, code: result.error.code, error: result.error.message });
+      logger9.warn("Audio synthesis failed", { ...context, durationMs: Date.now() - startedAt, code: result.error.code, error: result.error.message });
     return result;
   }
   async function* synthesizeStream(request) {
+    const validErr = validateSynthesisRequest(request);
+    if (validErr)
+      throw validErr;
+    const refErr = guardSynthesisReferences(request);
+    if (refErr)
+      throw refErr;
     const resolved = resolveAudioModel(audioConfig, "synthesize", request.model, config.llm.apiKey);
     if (!resolved.success)
       throw resolved.error;
+    const provider = getProvider(resolved.data.provider);
+    const synthesis = provider.synthesis;
+    if (!synthesis)
+      throw audioError(HaiAIError.AUDIO_UNSUPPORTED_INPUT, aiM("ai_audioUnsupportedInput", { params: { provider: resolved.data.provider, reason: "synthesis" } }));
+    const credErr = ensureAudioCredential(resolved.data);
+    if (credErr)
+      throw credErr;
+    if (request.strictCapabilities) {
+      const capErr = checkSynthesizeCapabilities(resolved.data.provider, request, provider.getCapabilities(resolved.data));
+      if (capErr)
+        throw capErr;
+    }
     const startedAt = Date.now();
     const context = { provider: resolved.data.provider, model: resolved.data.model, voice: request.voice };
-    logger7.debug("Audio synthesis stream started", context);
+    logger9.debug("Audio synthesis stream started", context);
     const signal = withStreamTimeout(request.signal);
-    const provider = getProvider(resolved.data.provider);
-    const output = provider.resolveSynthesisOutput({ format: request.format, sampleRate: request.sampleRate });
+    const output = synthesis.resolveSynthesisOutput({ format: request.format, sampleRate: request.sampleRate });
     try {
       const segments = isSynthesisTextSegment(request.text) ? singleSegment(request.text) : request.text;
       for await (const segment of segments) {
         if (!segment.id || !segment.text)
           throw audioError(HaiAIError.AUDIO_INVALID_REQUEST, aiM("ai_audioInvalidRequest", { params: { reason: "empty segment id or text" } }));
         yield { type: "segment_started", segmentId: segment.id, text: segment.text, format: output.format, sampleRate: output.sampleRate, channels: output.channels };
-        for await (const data of provider.synthesizeStream({ model: resolved.data, text: segment.text, voice: request.voice, instruction: request.instruction, format: request.format, sampleRate: request.sampleRate, signal }))
+        for await (const data of synthesizeSegmentAudio(synthesis, { model: resolved.data, text: segment.text, language: request.language, voice: request.voice, speakerReference: request.speakerReference, styleReference: request.styleReference, styleStrength: request.styleStrength, instruction: request.instruction, speed: request.speed, format: request.format, sampleRate: request.sampleRate, signal }))
           yield { type: "audio", segmentId: segment.id, data };
         yield { type: "segment_done", segmentId: segment.id };
       }
-      logger7.info("Audio synthesis stream completed", { ...context, durationMs: Date.now() - startedAt });
+      logger9.info("Audio synthesis stream completed", { ...context, durationMs: Date.now() - startedAt });
     } catch (error) {
-      logger7.warn("Audio synthesis stream failed", { ...context, durationMs: Date.now() - startedAt, error });
+      logger9.warn("Audio synthesis stream failed", { ...context, durationMs: Date.now() - startedAt, error });
       throw mapStreamError(error, signal);
     }
   }
   function getCapabilities(request) {
-    const targetId = request.model ?? (request.operation === "transcribe" ? audioConfig.transcribeModel : audioConfig.synthesizeModel);
-    if (!targetId)
-      return err(HaiAIError.AUDIO_MODEL_NOT_FOUND, aiM("ai_audioModelNotFound", { params: { model: `<${request.operation}>` } }));
-    const entry = audioConfig.models?.find((model) => model.id === targetId || model.model === targetId);
-    if (!entry)
-      return err(HaiAIError.AUDIO_MODEL_NOT_FOUND, aiM("ai_audioModelNotFound", { params: { model: targetId } }));
-    const operations = entry.operations;
-    if (!operations.includes(request.operation)) {
-      return err(
-        HaiAIError.AUDIO_UNSUPPORTED_INPUT,
-        aiM("ai_audioUnsupportedInput", { params: { provider: entry.provider, reason: `model ${entry.id} does not support ${request.operation}` } })
-      );
-    }
-    const capabilities = getProvider(entry.provider).capabilities;
+    const resolved = resolveAudioModel(audioConfig, request.operation, request.model, config.llm.apiKey);
+    if (!resolved.success)
+      return resolved;
+    const capabilities = getProvider(resolved.data.provider).getCapabilities(resolved.data);
     return ok(request.operation === "transcribe" ? { transcribe: capabilities.transcribe } : { synthesize: capabilities.synthesize });
   }
   return { transcribe, transcribeStream, synthesize, synthesizeStream, getCapabilities };
@@ -1562,6 +1843,96 @@ function isSynthesisTextSegment(value) {
 async function* singleSegment(segment) {
   yield segment;
 }
+function invalidRequest(reason) {
+  return audioError(HaiAIError.AUDIO_INVALID_REQUEST, aiM("ai_audioInvalidRequest", { params: { reason } }));
+}
+function unsupportedCapability(provider, feature) {
+  return audioError(HaiAIError.AUDIO_UNSUPPORTED_INPUT, aiM("ai_audioUnsupportedInput", { params: { provider, reason: `${feature} not supported by this model` } }));
+}
+function validateSynthesisOptions(options) {
+  if (options.styleStrength !== void 0 && (options.styleStrength < 0 || options.styleStrength > 1))
+    return invalidRequest("styleStrength must be between 0 and 1");
+  if (options.styleStrength !== void 0 && !options.styleReference)
+    return invalidRequest("styleStrength requires styleReference");
+  if (options.speed !== void 0 && (!Number.isFinite(options.speed) || options.speed <= 0))
+    return invalidRequest("speed must be greater than 0");
+  return null;
+}
+function validateSynthesisRequest(request) {
+  const base = validateSynthesisOptions(request);
+  if (base)
+    return base;
+  const targetDurationMs = "targetDurationMs" in request ? request.targetDurationMs : void 0;
+  const durationToleranceMs = "durationToleranceMs" in request ? request.durationToleranceMs : void 0;
+  if (targetDurationMs !== void 0 && (!Number.isInteger(targetDurationMs) || targetDurationMs <= 0))
+    return invalidRequest("targetDurationMs must be a positive integer");
+  if (durationToleranceMs !== void 0 && targetDurationMs === void 0)
+    return invalidRequest("durationToleranceMs requires targetDurationMs");
+  if (durationToleranceMs !== void 0 && (!Number.isInteger(durationToleranceMs) || durationToleranceMs < 0))
+    return invalidRequest("durationToleranceMs must be a non-negative integer");
+  if (request.speed !== void 0 && targetDurationMs !== void 0)
+    return invalidRequest("speed and targetDurationMs cannot be used together");
+  return null;
+}
+function checkTranscribeCapabilities(provider, options, capabilities) {
+  const caps = capabilities.transcribe;
+  if (!caps?.supported)
+    return unsupportedCapability(provider, "transcription");
+  if (options.timestampGranularities?.includes("word") && !caps.wordTimestamps)
+    return unsupportedCapability(provider, "word timestamps");
+  if (options.timestampGranularities?.includes("segment") && !caps.segmentTimestamps)
+    return unsupportedCapability(provider, "segment timestamps");
+  if (options.vad && !caps.vad)
+    return unsupportedCapability(provider, "vad");
+  if (options.contextHints?.length && !caps.contextHints)
+    return unsupportedCapability(provider, "context hints");
+  return null;
+}
+function checkSynthesizeCapabilities(provider, options, capabilities) {
+  const caps = capabilities.synthesize;
+  if (!caps?.supported)
+    return unsupportedCapability(provider, "synthesis");
+  if (options.speakerReference && !caps.speakerReference)
+    return unsupportedCapability(provider, "speaker reference");
+  if (options.styleReference && !caps.styleReference)
+    return unsupportedCapability(provider, "style reference");
+  if (options.instruction && !caps.instruction)
+    return unsupportedCapability(provider, "instruction");
+  if (options.speed !== void 0 && !caps.speedControl)
+    return unsupportedCapability(provider, "speed control");
+  if (options.targetDurationMs !== void 0 && !caps.targetDuration)
+    return unsupportedCapability(provider, "target duration");
+  return null;
+}
+async function* transcribeStreamOrFallback(transcription, request) {
+  if (transcription.transcribeStream) {
+    yield* transcription.transcribeStream(request);
+    return;
+  }
+  if ("chunks" in request.audio)
+    throw audioError(HaiAIError.AUDIO_UNSUPPORTED_INPUT, aiM("ai_audioUnsupportedInput", { params: { provider: request.model.provider, reason: "streaming audio input" } }));
+  const result = await transcription.transcribe({ model: request.model, audio: request.audio, language: request.language, contextHints: request.contextHints, timestampGranularities: request.timestampGranularities, vad: request.vad, signal: request.signal });
+  if (!result.success)
+    throw result.error;
+  yield { type: "transcript", text: result.data.text, final: true };
+}
+async function* synthesizeSegmentAudio(synthesis, request) {
+  if (synthesis.synthesizeStream) {
+    yield* synthesis.synthesizeStream(request);
+    return;
+  }
+  const text = typeof request.text === "string" ? request.text : await collectText(request.text);
+  const result = await synthesis.synthesize({ model: request.model, text, language: request.language, voice: request.voice, speakerReference: request.speakerReference, styleReference: request.styleReference, styleStrength: request.styleStrength, instruction: request.instruction, speed: request.speed, format: request.format, sampleRate: request.sampleRate, signal: request.signal });
+  if (!result.success)
+    throw result.error;
+  yield result.data.data;
+}
+async function collectText(stream) {
+  let text = "";
+  for await (const part of stream)
+    text += part;
+  return text;
+}
 function createProvider(name) {
   switch (name) {
     case "openai":
@@ -1572,9 +1943,13 @@ function createProvider(name) {
       return createQwenAudioProvider();
     case "doubao":
       return createDoubaoAudioProvider();
+    case "whisper":
+      return createWhisperAudioProvider();
+    case "indextts":
+      return createIndexTtsAudioProvider();
   }
 }
-var logger8 = core.logger.child({ module: "ai", scope: "compress" });
+var logger10 = core.logger.child({ module: "ai", scope: "compress" });
 var CONVERSATION_SUMMARY_PREFIX = "[Conversation Summary]";
 var CONVERSATION_SUMMARY_NAME = "hai_internal_conversation_summary_v1";
 function completeCompression(result, maxTokens) {
@@ -1712,7 +2087,7 @@ function createCompressOperations(config, token, summary, modelMaxTokens) {
     const maxTokens = resolveMaxTokens(options?.maxTokens);
     const preserveSystem = options?.preserveSystem ?? true;
     const preserveLastN = options?.preserveLastN ?? config.preserveLastN;
-    logger8.trace("Compressing context", { strategy, maxTokens, messageCount: messages.length });
+    logger10.trace("Compressing context", { strategy, maxTokens, messageCount: messages.length });
     try {
       const originalTokens = token.estimateMessages(messages);
       if (originalTokens <= maxTokens) {
@@ -1731,7 +2106,7 @@ function createCompressOperations(config, token, summary, modelMaxTokens) {
           preserveLastN
         );
         const compressedTokens = token.estimateMessages(compressed);
-        logger8.trace("Sliding window compression completed", { originalTokens, compressedTokens, removedCount });
+        logger10.trace("Sliding window compression completed", { originalTokens, compressedTokens, removedCount });
         return completeCompression({
           messages: compressed,
           originalTokens,
@@ -1764,7 +2139,7 @@ ${summaryText}`
         };
         const compressed = [...systemMessages2, summaryMessage, ...preserved];
         const compressedTokens = token.estimateMessages(compressed);
-        logger8.trace("Summary compression completed", { originalTokens, compressedTokens, removedCount: toSummarize2.length });
+        logger10.trace("Summary compression completed", { originalTokens, compressedTokens, removedCount: toSummarize2.length });
         return completeCompression({
           messages: compressed,
           originalTokens,
@@ -1805,7 +2180,7 @@ ${summaryText}`
         };
         const compressed = [...systemMessages, summaryMessage, ...preservedMessages];
         const compressedTokens = token.estimateMessages(compressed);
-        logger8.trace("Hybrid compression completed", { originalTokens, compressedTokens, removedCount: toSummarize.length });
+        logger10.trace("Hybrid compression completed", { originalTokens, compressedTokens, removedCount: toSummarize.length });
         return completeCompression({
           messages: compressed,
           originalTokens,
@@ -1821,7 +2196,7 @@ ${summaryText}`
         removedCount: windowRemoved
       }, maxTokens);
     } catch (error) {
-      logger8.error("Context compression failed", { error });
+      logger10.error("Context compression failed", { error });
       return err(HaiAIError.CONTEXT_COMPRESS_FAILED, aiM("ai_contextCompressFailed", { params: { error: String(error) } }), error);
     }
   }
@@ -1836,7 +2211,7 @@ function sessionStoreKey(scope) {
 }
 
 // src/context/ai-context-functions.ts
-var logger9 = core.logger.child({ module: "ai", scope: "context" });
+var logger11 = core.logger.child({ module: "ai", scope: "context" });
 function createContextOperations(compressConfig, tokenOps, compressOps, contextStore, sessionStore, deps) {
   function resolveMaxTokens(optionMaxTokens) {
     const fromOption = optionMaxTokens ?? compressConfig.defaultMaxTokens;
@@ -1882,7 +2257,7 @@ function createContextOperations(compressConfig, tokenOps, compressOps, contextS
         types: options.memory.types,
         model: options.memory.extractionModel,
         systemPrompt: options.memory.extractionSystemPrompt
-      }).catch((e) => logger9.warn("Memory extract failed", { error: e })).finally(() => {
+      }).catch((e) => logger11.warn("Memory extract failed", { error: e })).finally(() => {
         pendingMemoryTasks.delete(task);
       });
       pendingMemoryTasks.add(task);
@@ -1961,7 +2336,7 @@ function createContextOperations(compressConfig, tokenOps, compressOps, contextS
         const currentTokens = tokenOps.estimateMessages(state.messages);
         if (currentTokens <= managerMaxTokens)
           return ok(void 0);
-        logger9.trace("Auto-compressing context", { currentTokens, budget: managerMaxTokens });
+        logger11.trace("Auto-compressing context", { currentTokens, budget: managerMaxTokens });
         const compressResult = await compressOps.tryCompress(state.messages, {
           strategy,
           maxTokens: managerMaxTokens,
@@ -1970,7 +2345,7 @@ function createContextOperations(compressConfig, tokenOps, compressOps, contextS
           summaryModel
         });
         if (!compressResult.success) {
-          logger9.warn("Auto-compression failed, keeping original messages", { error: compressResult.error });
+          logger11.warn("Auto-compression failed, keeping original messages", { error: compressResult.error });
           return compressResult;
         }
         if (compressResult.data.summary) {
@@ -2104,7 +2479,7 @@ function createContextOperations(compressConfig, tokenOps, compressOps, contextS
             return extracted;
           return ok({ summary: summaryText, memories: extracted.data });
         } catch (error) {
-          logger9.error("Context consolidate failed", { error });
+          logger11.error("Context consolidate failed", { error });
           return err(HaiAIError.MEMORY_PROMOTE_FAILED, aiM("ai_memoryPromoteFailed", { params: { error: String(error) } }), error);
         }
       },
@@ -2239,7 +2614,7 @@ function createContextOperations(compressConfig, tokenOps, compressOps, contextS
           turnId = await finalizeAssistantReply(message, fallbackReply, epoch);
           return ok({ reply: fallbackReply, model: lastModel, turnId, usage: lastUsage });
         } catch (error) {
-          logger9.error("Context chat failed", { error });
+          logger11.error("Context chat failed", { error });
           return err(HaiAIError.INTERNAL_ERROR, aiM("ai_internalError", { params: { error: String(error) } }), error);
         } finally {
           settleGeneration(turnId, release);
@@ -2504,7 +2879,7 @@ function createContextOperations(compressConfig, tokenOps, compressOps, contextS
         if (persisted) {
           initialMessages = persisted.messages;
           initialSummaries = persisted.summaries;
-          logger9.trace("Context manager restored from store", { scope, messageCount: initialMessages.length });
+          logger11.trace("Context manager restored from store", { scope, messageCount: initialMessages.length });
         }
       }
       const manager = buildManager(
@@ -2566,7 +2941,7 @@ function createContextOperations(compressConfig, tokenOps, compressOps, contextS
     }
   };
 }
-var logger10 = core.logger.child({ module: "ai", scope: "embedding" });
+var logger12 = core.logger.child({ module: "ai", scope: "embedding" });
 function createEmbeddingOperations(config) {
   const embeddingConfig = config.embedding ?? { batchSize: 100 };
   let cachedClient = null;
@@ -2612,7 +2987,7 @@ function createEmbeddingOperations(config) {
         }
       });
     } catch (error) {
-      logger10.error("Embedding API call failed", { error });
+      logger12.error("Embedding API call failed", { error });
       return err(HaiAIError.EMBEDDING_API_ERROR, aiM("ai_internalError", { params: { error: String(error) } }), error);
     }
   }
@@ -2670,7 +3045,7 @@ function createEmbeddingOperations(config) {
     }
   };
 }
-var logger11 = core.logger.child({ module: "ai", scope: "file" });
+var logger13 = core.logger.child({ module: "ai", scope: "file" });
 var HTML_SCRIPT_BLOCK_REGEX = /<script[^>]*>[\s\S]*?<\/script[^>]*>/gi;
 var HTML_STYLE_BLOCK_REGEX = /<style[^>]*>[\s\S]*?<\/style[^>]*>/gi;
 var HTML_LIST_OPEN_TAG_REGEX = /<[ou]l[^>]*>/gi;
@@ -2910,7 +3285,7 @@ async function parseImageWithOcr(content, mimeType, llmOps, model, outputFormat
   const dataUrl = `data:${mimeType};base64,${base64}`;
   const defaultPrompt = outputFormat === "markdown" ? "Please extract all text content from this image as Markdown, preserving document structure (headings, bullet lists, bold/italic). Return only the Markdown without additional commentary." : "Please extract all text content from this image accurately. Return only the extracted text without any additional commentary.";
   const prompt = customPrompt ?? defaultPrompt;
-  logger11.trace("Running OCR via vision LLM", { mimeType, model });
+  logger13.trace("Running OCR via vision LLM", { mimeType, model });
   const result = await llmOps.chat({
     model,
     messages: [
@@ -2961,7 +3336,7 @@ function createFileOperations(config, llmOps) {
     const { content, filename, options = {} } = request;
     const mimeType = detectMimeType(content, filename, options.mimeType);
     const outputFormat = options.outputFormat ?? "text";
-    logger11.trace("Parsing file", { filename, mimeType, outputFormat, useOcr: options.useOcr });
+    logger13.trace("Parsing file", { filename, mimeType, outputFormat, useOcr: options.useOcr });
     if (options.useOcr) {
       if (!Buffer.isBuffer(content)) {
         return err(HaiAIError.FILE_INVALID_CONTENT, aiM("ai_fileInvalidContent", { params: { reason: "OCR requires Buffer content" } }));
@@ -2997,7 +3372,7 @@ function createFileOperations(config, llmOps) {
           metadata: { filename, mimeType, charCount: pdfResult.data.text.length }
         });
       }
-      logger11.warn("PDF native parser failed, falling back to OCR", { filename });
+      logger13.warn("PDF native parser failed, falling back to OCR", { filename });
       return runOcr(content, mimeType, filename, options.model, outputFormat, options.systemPrompt);
     }
     if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || mimeType === "application/msword" || mimeType === "application/zip") {
@@ -3012,7 +3387,7 @@ function createFileOperations(config, llmOps) {
           metadata: { filename, mimeType, charCount: docxResult.data.length }
         });
       }
-      logger11.warn("DOCX native parser failed, falling back to OCR", { filename });
+      logger13.warn("DOCX native parser failed, falling back to OCR", { filename });
       return runOcr(content, mimeType, filename, options.model, outputFormat, options.systemPrompt);
     }
     if (IMAGE_MIME_TYPES.has(mimeType)) {
@@ -3028,7 +3403,7 @@ function createFileOperations(config, llmOps) {
       try {
         return await doParse(request);
       } catch (error) {
-        logger11.error("File parse failed unexpectedly", { filename: request.filename, error });
+        logger13.error("File parse failed unexpectedly", { filename: request.filename, error });
         return err(HaiAIError.FILE_PARSE_FAILED, aiM("ai_fileParseFailed", { params: { error: String(error) } }), error);
       }
     },
@@ -3376,7 +3751,7 @@ function createSeedreamImageProvider() {
 }
 
 // src/image/ai-image-functions.ts
-var logger12 = core.logger.child({ module: "ai", scope: "image" });
+var logger14 = core.logger.child({ module: "ai", scope: "image" });
 function createImageOperations(config) {
   const imageConfig = ImageConfigSchema.parse(config.image ?? {});
   const providers = /* @__PURE__ */ new Map();
@@ -3400,7 +3775,7 @@ function createImageOperations(config) {
         return err(HaiAIError.IMAGE_CANCELLED, aiM("ai_imageCancelled"));
       const resolved = resolveImageModel(imageConfig, request.model);
       if (!resolved.success) {
-        logger12.warn("Image model resolution failed", {
+        logger14.warn("Image model resolution failed", {
           code: resolved.error.code,
           error: resolved.error.message,
           requestedModel: request.model
@@ -3415,7 +3790,7 @@ function createImageOperations(config) {
         width: request.size?.width,
         height: request.size?.height
       };
-      logger12.debug("Image generation started", logContext);
+      logger14.debug("Image generation started", logContext);
       const generated = await provider(resolved.data.provider).generate({
         model: resolved.data,
         prompt: request.prompt.trim(),
@@ -3424,7 +3799,7 @@ function createImageOperations(config) {
         signal: request.signal
       });
       if (!generated.success) {
-        logger12.warn("Image generation failed", {
+        logger14.warn("Image generation failed", {
           ...logContext,
           durationMs: Date.now() - startedAt,
           code: generated.error.code,
@@ -3433,7 +3808,7 @@ function createImageOperations(config) {
         });
         return generated;
       }
-      logger12.info("Image generation completed", {
+      logger14.info("Image generation completed", {
         ...logContext,
         durationMs: Date.now() - startedAt,
         imageCount: generated.data.length,
@@ -3457,7 +3832,7 @@ function createProvider2(name) {
       return createPollinationsImageProvider();
   }
 }
-var logger13 = core.logger.child({ module: "ai", scope: "knowledge-entity" });
+var logger15 = core.logger.child({ module: "ai", scope: "knowledge-entity" });
 var LEADING_MARKDOWN_FENCE_REGEX = /^```(?:json)?\n?/;
 var TRAILING_MARKDOWN_FENCE_REGEX = /\n?```$/;
 var DEFAULT_ENTITY_TYPES = ["person", "project", "concept", "organization", "location", "event", "other"];
@@ -3495,16 +3870,16 @@ async function extractEntities(llm, text, model, entityTypes, systemPrompt) {
       enablePersist: false
     });
     if (!chatResult.success) {
-      logger13.warn("Entity extraction LLM call failed", { error: chatResult.error });
+      logger15.warn("Entity extraction LLM call failed", { error: chatResult.error });
       return err(HaiAIError.KNOWLEDGE_ENTITY_EXTRACT_FAILED, aiM("ai_knowledgeEntityExtractFailed", { params: { error: String(chatResult.error.message) } }), chatResult.error);
     }
     const content = chatResult.data.choices[0]?.message?.content ?? "";
     const validTypes = new Set(resolvedTypes);
     const entities = parseEntityResponse(content, validTypes);
-    logger13.trace("Entity extraction completed", { textLength: text.length, entityCount: entities.length });
+    logger15.trace("Entity extraction completed", { textLength: text.length, entityCount: entities.length });
     return ok(entities);
   } catch (error) {
-    logger13.error("Entity extraction failed", { error });
+    logger15.error("Entity extraction failed", { error });
     return err(HaiAIError.KNOWLEDGE_ENTITY_EXTRACT_FAILED, aiM("ai_knowledgeEntityExtractFailed", { params: { error: String(error) } }), error);
   }
 }
@@ -3524,10 +3899,10 @@ function parseEntityResponse(content, validTypes) {
         return entities.filter(isValidEntity).map((e) => normalizeEntity(e, validTypes));
       }
     }
-    logger13.warn("Entity extraction returned unexpected format", { content: content.slice(0, 200) });
+    logger15.warn("Entity extraction returned unexpected format", { content: content.slice(0, 200) });
     return [];
   } catch {
-    logger13.warn("Entity extraction returned invalid JSON", { content: content.slice(0, 200) });
+    logger15.warn("Entity extraction returned invalid JSON", { content: content.slice(0, 200) });
     return [];
   }
 }
@@ -3556,7 +3931,7 @@ async function extractEntitiesBatch(llm, chunks, model, entityTypes, systemPromp
         if (result.success) {
           return result.data.map((e) => ({ entity: e, chunkId: chunk.chunkId }));
         }
-        logger13.warn("Entity extraction failed for chunk", { chunkId: chunk.chunkId });
+        logger15.warn("Entity extraction failed for chunk", { chunkId: chunk.chunkId });
         return [];
       })
     );
@@ -3590,7 +3965,7 @@ async function extractEntitiesBatch(llm, chunks, model, entityTypes, systemPromp
 }
 
 // src/knowledge/ai-knowledge-functions.ts
-var logger14 = core.logger.child({ module: "ai", scope: "knowledge" });
+var logger16 = core.logger.child({ module: "ai", scope: "knowledge" });
 var DEFAULT_KNOWLEDGE_ASK_SYSTEM_PROMPT = `You are an expert assistant. Answer the user's question based ONLY on the provided context.
 
 Rules:
@@ -3622,14 +3997,14 @@ function createKnowledgeOperations(config, llm, embedding, datapipe2, store) {
       }
       const collection = options?.collection ?? config.collection;
       const dimension = options?.dimension ?? config.dimension;
-      logger14.debug("Setting up knowledge base", { collection, dimension });
+      logger16.debug("Setting up knowledge base", { collection, dimension });
       try {
         await store.initialize(collection, dimension);
         await store.registerCollection(collection, dimension);
-        logger14.debug("Knowledge base setup completed", { collection });
+        logger16.debug("Knowledge base setup completed", { collection });
         return ok(void 0);
       } catch (error) {
-        logger14.error("Knowledge base setup failed", { error });
+        logger16.error("Knowledge base setup failed", { error });
         return err(HaiAIError.KNOWLEDGE_SETUP_FAILED, aiM("ai_knowledgeSetupFailed", { params: { error: String(error) } }), error);
       }
     },
@@ -3667,7 +4042,7 @@ function createKnowledgeOperations(config, llm, embedding, datapipe2, store) {
         ...config.chunkOptions,
         ...input.chunkOptions
       };
-      logger14.trace("Ingesting document", { documentId: input.documentId, collection, contentLength: input.content.length });
+      logger16.trace("Ingesting document", { documentId: input.documentId, collection, contentLength: input.content.length });
       try {
         const cleanResult = datapipe2.clean(input.content, cleanOptions);
         const cleanedText = cleanResult.success ? cleanResult.data : input.content;
@@ -3742,11 +4117,11 @@ function createKnowledgeOperations(config, llm, embedding, datapipe2, store) {
               }
             }
           } else {
-            logger14.warn("Entity extraction failed, skipping", { error: entityResult.error });
+            logger16.warn("Entity extraction failed, skipping", { error: entityResult.error });
           }
         }
         const duration = Date.now() - startTime;
-        logger14.debug("Document ingested", {
+        logger16.debug("Document ingested", {
           documentId: input.documentId,
           chunkCount: chunks.length,
           entityCount: extractedEntities.length,
@@ -3759,7 +4134,7 @@ function createKnowledgeOperations(config, llm, embedding, datapipe2, store) {
           duration
         });
       } catch (error) {
-        logger14.error("Document ingestion failed", { documentId: input.documentId, error });
+        logger16.error("Document ingestion failed", { documentId: input.documentId, error });
         return err(HaiAIError.KNOWLEDGE_INGEST_FAILED, aiM("ai_knowledgeIngestFailed", { params: { error: String(error) } }), error);
       }
     },
@@ -3782,7 +4157,7 @@ function createKnowledgeOperations(config, llm, embedding, datapipe2, store) {
       const startTime = Date.now();
       const topK = options?.topK ?? 10;
       const enableEntityBoost = options?.enableEntityBoost ?? true;
-      logger14.trace("Knowledge retrieval", { query: query.slice(0, 100), collection, topK });
+      logger16.trace("Knowledge retrieval", { query: query.slice(0, 100), collection, topK });
       try {
         const embedResult = await embedding.embedText(query);
         if (!embedResult.success) {
@@ -3860,7 +4235,7 @@ function createKnowledgeOperations(config, llm, embedding, datapipe2, store) {
           }
         }
         const duration = Date.now() - startTime;
-        logger14.trace("Knowledge retrieval completed", { resultCount: items.length, duration });
+        logger16.trace("Knowledge retrieval completed", { resultCount: items.length, duration });
         return ok({
           items,
           citations: Array.from(citationMap.values()),
@@ -3868,7 +4243,7 @@ function createKnowledgeOperations(config, llm, embedding, datapipe2, store) {
           duration
         });
       } catch (error) {
-        logger14.error("Knowledge retrieval failed", { error });
+        logger16.error("Knowledge retrieval failed", { error });
         return err(HaiAIError.KNOWLEDGE_RETRIEVE_FAILED, aiM("ai_knowledgeRetrieveFailed", { params: { error: String(error) } }), error);
       }
     },
@@ -3916,7 +4291,7 @@ ${contextText}
       }
       const choice = chatResult.data.choices[0];
       const answer = choice?.message?.content ?? "";
-      logger14.trace("Knowledge ask completed", {
+      logger16.trace("Knowledge ask completed", {
         contextCount: items.length,
         model: chatResult.data.model
       });
@@ -4032,13 +4407,13 @@ ${contextText}
           try {
             await store.removeVectors(collection, vectorIds);
           } catch (vecError) {
-            logger14.warn("Failed to delete some vectors", { documentId, error: vecError });
+            logger16.warn("Failed to delete some vectors", { documentId, error: vecError });
           }
         }
         await store.deleteDocumentEntities(documentId, collection);
         await store.removeDocumentEntityRelations(documentId, collection);
         await store.removeDocument(documentId, collection);
-        logger14.debug("Document removed", { documentId, collection });
+        logger16.debug("Document removed", { documentId, collection });
         return ok(void 0);
       } catch (error) {
         return err(HaiAIError.KNOWLEDGE_INGEST_FAILED, aiM("ai_knowledgeIngestFailed", { params: { error: String(error) } }), error);
@@ -4099,13 +4474,13 @@ ${contextText}
         return err(HaiAIError.KNOWLEDGE_SETUP_FAILED, aiM("ai_knowledgeSetupFailed", { params: { error: "KnowledgeStore not available. Provider may not support knowledge operations." } }));
       }
       const col = collection ?? config.collection;
-      logger14.debug("Deleting knowledge collection", { collection: col });
+      logger16.debug("Deleting knowledge collection", { collection: col });
       try {
         await store.deleteCollection(col);
-        logger14.debug("Knowledge collection deleted", { collection: col });
+        logger16.debug("Knowledge collection deleted", { collection: col });
         return ok(void 0);
       } catch (error) {
-        logger14.error("Knowledge collection deletion failed", { collection: col, error });
+        logger16.error("Knowledge collection deletion failed", { collection: col, error });
         return err(HaiAIError.KNOWLEDGE_SETUP_FAILED, aiM("ai_knowledgeSetupFailed", { params: { error: String(error) } }), error);
       }
     }
@@ -4938,7 +5313,7 @@ function createLLMProvider(deps) {
 }
 
 // src/llm/ai-llm-functions.ts
-var logger15 = core.logger.child({ module: "ai", scope: "llm" });
+var logger17 = core.logger.child({ module: "ai", scope: "llm" });
 function createAILLMFunctions(config, deps) {
   const provider = createLLMProvider({ config });
   const recordStore = deps?.recordStore;
@@ -4956,7 +5331,7 @@ function createAILLMFunctions(config, deps) {
   }
   async function saveRecordAndSession(record, messages) {
     await recordStore.save(record.id, record, { objectId: record.objectId, sessionId: record.sessionId });
-    logger15.trace("Chat record saved", { id: record.id, objectId: record.objectId, sessionId: record.sessionId });
+    logger17.trace("Chat record saved", { id: record.id, objectId: record.objectId, sessionId: record.sessionId });
     if (sessionStore) {
       const sessionKey = sessionStoreKey({ objectId: record.objectId, sessionId: record.sessionId });
       const existing = await sessionStore.get(sessionKey);
@@ -4977,10 +5352,10 @@ function createAILLMFunctions(config, deps) {
   async function chatWithRecord(request) {
     const start = Date.now();
     const context = { model: request.model ?? request.tempModel?.model, messageCount: request.messages.length };
-    logger15.debug("LLM chat started", context);
+    logger17.debug("LLM chat started", context);
     const result = await provider.chat(request);
     if (result.success) {
-      logger15.info("LLM chat completed", {
+      logger17.info("LLM chat completed", {
         ...context,
         model: result.data.model,
         durationMs: Date.now() - start,
@@ -4988,7 +5363,7 @@ function createAILLMFunctions(config, deps) {
         totalTokens: result.data.usage?.total_tokens
       });
     } else {
-      logger15.warn("LLM chat failed", {
+      logger17.warn("LLM chat failed", {
         ...context,
         durationMs: Date.now() - start,
         code: result.error.code,
@@ -5018,7 +5393,7 @@ function createAILLMFunctions(config, deps) {
         };
         await saveRecordAndSession(record, request.messages);
       } catch (error) {
-        logger15.debug("Failed to save chat record", { error });
+        logger17.debug("Failed to save chat record", { error });
       }
     }
     return result;
@@ -5026,7 +5401,7 @@ function createAILLMFunctions(config, deps) {
   async function* chatStreamWithRecord(request) {
     const start = Date.now();
     const logContext = { model: request.model ?? request.tempModel?.model, messageCount: request.messages.length };
-    logger15.debug("LLM chat stream started", logContext);
+    logger17.debug("LLM chat stream started", logContext);
     const shouldRecord = !!(request.objectId && recordStore && request.enablePersist !== false);
     let content = "";
     let finishReason = null;
@@ -5062,7 +5437,7 @@ function createAILLMFunctions(config, deps) {
           }
         }
       }
-      logger15.info("LLM chat stream completed", {
+      logger17.info("LLM chat stream completed", {
         ...logContext,
         model: resolvedModel || logContext.model,
         durationMs: Date.now() - start,
@@ -5070,7 +5445,7 @@ function createAILLMFunctions(config, deps) {
         finishReason
       });
     } catch (error) {
-      logger15.warn("LLM chat stream failed", { ...logContext, durationMs: Date.now() - start, error });
+      logger17.warn("LLM chat stream failed", { ...logContext, durationMs: Date.now() - start, error });
       throw error;
     }
     if (shouldRecord) {
@@ -5095,7 +5470,7 @@ function createAILLMFunctions(config, deps) {
         };
         await saveRecordAndSession(record, request.messages);
       } catch (error) {
-        logger15.debug("Failed to save stream chat record", { error });
+        logger17.debug("Failed to save stream chat record", { error });
       }
     }
   }
@@ -5335,25 +5710,25 @@ function createAIMCPFunctions(_deps) {
     }
   };
 }
-function createScopedMemory(core30, binding) {
+function createScopedMemory(core32, binding) {
   const { objectId, scope } = binding;
   const accessScope = { objectId, scope };
   return {
-    extract: (messages, options) => core30.extract(messages, { ...options, objectId, scope }),
-    recall: (query, options) => core30.recall(query, { ...options, objectId, scope }),
-    injectMemories: (messages, options) => core30.injectMemories(messages, { ...options, objectId, scope }),
-    add: (entry) => core30.add({ ...entry, objectId, scope }),
-    update: (memoryId, updates) => core30.update(memoryId, updates, accessScope),
-    get: (memoryId) => core30.get(memoryId, accessScope),
-    remove: (memoryId) => core30.remove(memoryId, accessScope),
-    list: (options) => core30.list({ ...options, objectId, scope }),
-    listPage: (options) => core30.listPage({ ...options, objectId, scope }),
-    clear: (options) => core30.clear({ ...options, objectId, scope })
+    extract: (messages, options) => core32.extract(messages, { ...options, objectId, scope }),
+    recall: (query, options) => core32.recall(query, { ...options, objectId, scope }),
+    injectMemories: (messages, options) => core32.injectMemories(messages, { ...options, objectId, scope }),
+    add: (entry) => core32.add({ ...entry, objectId, scope }),
+    update: (memoryId, updates) => core32.update(memoryId, updates, accessScope),
+    get: (memoryId) => core32.get(memoryId, accessScope),
+    remove: (memoryId) => core32.remove(memoryId, accessScope),
+    list: (options) => core32.list({ ...options, objectId, scope }),
+    listPage: (options) => core32.listPage({ ...options, objectId, scope }),
+    clear: (options) => core32.clear({ ...options, objectId, scope })
   };
 }
-function createMemoryOperations(core30) {
+function createMemoryOperations(core32) {
   return {
-    ...core30,
+    ...core32,
     /**
      * 清空记忆（空过滤保护）。
      *
@@ -5365,20 +5740,20 @@ function createMemoryOperations(core30) {
       if (!hasFilter) {
         return err(HaiAIError.MEMORY_STORE_FAILED, aiM("ai_memoryClearRequiresFilter"));
       }
-      return core30.clear(options);
+      return core32.clear(options);
     },
-    scoped: (binding) => createScopedMemory(core30, binding),
+    scoped: (binding) => createScopedMemory(core32, binding),
     admin: {
       async clearAll(options) {
         if (options?.confirm !== true) {
           return err(HaiAIError.MEMORY_STORE_FAILED, aiM("ai_memoryClearAllUnconfirmed"));
         }
-        return core30.clear();
+        return core32.clear();
       }
     }
   };
 }
-var logger16 = core.logger.child({ module: "ai", scope: "memory-extractor" });
+var logger18 = core.logger.child({ module: "ai", scope: "memory-extractor" });
 var LEADING_MARKDOWN_FENCE_REGEX2 = /^```(?:json)?\n?/;
 var TRAILING_MARKDOWN_FENCE_REGEX2 = /\n?```$/;
 var MEMORY_EXTRACTION_SYSTEM_PROMPT = `You are a memory extraction assistant. Analyze the conversation and extract important information worth remembering for future interactions.
@@ -5431,7 +5806,7 @@ Only extract memories of these types: ${options.types.join(", ")}`;
       signal: options?.signal
     });
     if (!chatResult.success) {
-      logger16.warn("Memory extraction LLM call failed", { error: chatResult.error });
+      logger18.warn("Memory extraction LLM call failed", { error: chatResult.error });
       return err(HaiAIError.MEMORY_EXTRACT_FAILED, aiM("ai_memoryExtractFailed", { params: { error: String(chatResult.error.message) } }), chatResult.error);
     }
     const content = chatResult.data.choices[0]?.message?.content ?? "";
@@ -5446,10 +5821,10 @@ Only extract memories of these types: ${options.types.join(", ")}`;
     if (options?.objectId) {
       entries = entries.map((e) => ({ ...e, objectId: options.objectId }));
     }
-    logger16.trace("Memory extraction completed", { messageCount: messages.length, extractedCount: entries.length });
+    logger18.trace("Memory extraction completed", { messageCount: messages.length, extractedCount: entries.length });
     return ok(entries);
   } catch (error) {
-    logger16.error("Memory extraction failed", { error });
+    logger18.error("Memory extraction failed", { error });
     return err(HaiAIError.MEMORY_EXTRACT_FAILED, aiM("ai_memoryExtractFailed", { params: { error: String(error) } }), error);
   }
 }
@@ -5470,10 +5845,10 @@ function parseMemoryResponse(content) {
         return memories.filter(isValidMemoryItem).map(normalizeMemoryItem);
       }
     }
-    logger16.warn("Memory extraction returned unexpected format", { content: content.slice(0, 200) });
+    logger18.warn("Memory extraction returned unexpected format", { content: content.slice(0, 200) });
     return [];
   } catch {
-    logger16.warn("Memory extraction returned invalid JSON", { content: content.slice(0, 200) });
+    logger18.warn("Memory extraction returned invalid JSON", { content: content.slice(0, 200) });
     return [];
   }
 }
@@ -5492,7 +5867,7 @@ function normalizeMemoryItem(item) {
     importance
   };
 }
-var logger17 = core.logger.child({ module: "ai", scope: "memory" });
+var logger19 = core.logger.child({ module: "ai", scope: "memory" });
 function isMemoryAccessDenied(entry, accessScope) {
   if (!accessScope)
     return false;
@@ -5577,16 +5952,16 @@ ${memoryText}
         });
       }
     }
-    logger17.trace("Memories enriched", { count: recallResult.data.length, position });
+    logger19.trace("Memories enriched", { count: recallResult.data.length, position });
     return ok(result);
   } catch (error) {
-    logger17.error("Memory enrichment failed", { error });
+    logger19.error("Memory enrichment failed", { error });
     return err(HaiAIError.MEMORY_ENRICH_FAILED, aiM("ai_memoryEnrichFailed", { params: { error: String(error) } }), error);
   }
 }
 
 // src/memory/providers/ai-memory-provider-mem0-oss.ts
-var logger18 = core.logger.child({ module: "ai", scope: "memory-mem0-oss" });
+var logger20 = core.logger.child({ module: "ai", scope: "memory-mem0-oss" });
 var DEFAULT_IMPORTANCE = 0.5;
 var DEFAULT_OBJECT_ID = "hai-global";
 var MEMORY_TYPES = /* @__PURE__ */ new Set(["fact", "preference", "event", "entity", "instruction"]);
@@ -5697,7 +6072,7 @@ function buildVectorStoreConfig(deps) {
     );
   }
   if (backend)
-    logger18.warn("Mem0 OSS falls back to in-memory vector store (allowEphemeralFallback=true); data will not survive restart", { backend: backend.type });
+    logger20.warn("Mem0 OSS falls back to in-memory vector store (allowEphemeralFallback=true); data will not survive restart", { backend: backend.type });
   return ok({
     provider: "memory",
     persistent: false,
@@ -5779,7 +6154,7 @@ async function extractMemories2(context, messages, options) {
     }));
     return ok(stored.filter((entry) => entry !== void 0));
   } catch (error) {
-    logger18.error("Mem0 OSS extract failed", { error });
+    logger20.error("Mem0 OSS extract failed", { error });
     return err(HaiAIError.MEMORY_EXTRACT_FAILED, aiM("ai_memoryExtractFailed", { params: { error: String(error) } }), error);
   }
 }
@@ -5807,7 +6182,7 @@ async function recallMemories(context, query, options) {
     }
     return ok(entries.slice(0, topK));
   } catch (error) {
-    logger18.error("Mem0 OSS recall failed", { error });
+    logger20.error("Mem0 OSS recall failed", { error });
     return err(HaiAIError.MEMORY_RECALL_FAILED, aiM("ai_memoryRecallFailed", { params: { error: String(error) } }), error);
   }
 }
@@ -5824,7 +6199,7 @@ async function addMemory(context, entry) {
       throw new Error("Mem0 OSS did not return the stored memory");
     return ok(toMemoryEntry(stored, objectId));
   } catch (error) {
-    logger18.error("Mem0 OSS add failed", { error });
+    logger20.error("Mem0 OSS add failed", { error });
     return err(HaiAIError.MEMORY_STORE_FAILED, aiM("ai_memoryStoreFailed", { params: { error: String(error) } }), error);
   }
 }
@@ -5863,7 +6238,7 @@ async function updateMemory(context, memoryId, updates, accessScope) {
       throw new Error("Mem0 OSS did not return the updated memory");
     return ok(toMemoryEntry(stored, objectId));
   } catch (error) {
-    logger18.error("Mem0 OSS update failed", { id: memoryId, error });
+    logger20.error("Mem0 OSS update failed", { id: memoryId, error });
     return err(HaiAIError.MEMORY_STORE_FAILED, aiM("ai_memoryStoreFailed", { params: { error: String(error) } }), error);
   }
 }
@@ -5911,10 +6286,10 @@ async function createMem0OssMemoryOperations(deps) {
   try {
     mod = await import('mem0ai/oss');
   } catch (error) {
-    logger18.error("Failed to load mem0ai/oss", { error });
+    logger20.error("Failed to load mem0ai/oss", { error });
     throw new Error('mem0ai is required for memory.provider="mem0"; install it with `pnpm add mem0ai`');
   }
-  logger18.info("Mem0 OSS memory initialized", {
+  logger20.info("Mem0 OSS memory initialized", {
     vectorProvider: configResult.data.vectorProvider,
     persistent: configResult.data.persistent
   });
@@ -5981,7 +6356,7 @@ async function createMem0OssMemoryOperations(deps) {
         const matched = await listMemories(context, { objectId: options?.objectId, types: options?.types, scope: options?.scope });
         for (const entry of matched)
           await context.memory.delete(entry.id);
-        logger18.debug("Mem0 OSS memories cleared", { removed: matched.length, objectId: options?.objectId, types: options?.types, scoped: Boolean(options?.scope) });
+        logger20.debug("Mem0 OSS memories cleared", { removed: matched.length, objectId: options?.objectId, types: options?.types, scoped: Boolean(options?.scope) });
         return ok(void 0);
       } catch (error) {
         return err(HaiAIError.MEMORY_STORE_FAILED, aiM("ai_memoryStoreFailed", { params: { error: String(error) } }), error);
@@ -5989,7 +6364,7 @@ async function createMem0OssMemoryOperations(deps) {
     }
   };
 }
-var logger19 = core.logger.child({ module: "ai", scope: "memory-consolidation" });
+var logger21 = core.logger.child({ module: "ai", scope: "memory-consolidation" });
 var DEFAULT_IMPORTANCE2 = 0.5;
 var MEMORY_TYPES2 = /* @__PURE__ */ new Set(["fact", "preference", "event", "entity", "instruction"]);
 var LEADING_CODE_FENCE_REGEX = /^```(?:json)?\n?/;
@@ -6090,7 +6465,7 @@ async function applyConsolidationOps(deps, ops, options) {
     if (op.event === "DELETE" && op.id) {
       const removeResult = await deps.remove(op.id);
       if (!removeResult.success)
-        logger19.warn("Consolidation delete skipped", { id: op.id, error: removeResult.error.message });
+        logger21.warn("Consolidation delete skipped", { id: op.id, error: removeResult.error.message });
       continue;
     }
     if (op.event === "UPDATE" && op.id) {
@@ -6120,7 +6495,7 @@ async function applyConsolidationOps(deps, ops, options) {
   return ok(entries);
 }
 async function extractAndConsolidate(deps, messages, options) {
-  logger19.trace("Consolidation extract", { messageCount: messages.length });
+  logger21.trace("Consolidation extract", { messageCount: messages.length });
   const extractResult = await extractMemories(deps.llm, messages, {
     types: options?.types,
     model: options?.model,
@@ -6174,7 +6549,7 @@ async function extractAndConsolidate(deps, messages, options) {
   try {
     ops = parseConsolidationOps(rawContent, candidates, relatedIds);
   } catch {
-    logger19.warn("Consolidation returned invalid JSON, falling back to ADD-all", { content: rawContent.slice(0, 200) });
+    logger21.warn("Consolidation returned invalid JSON, falling back to ADD-all", { content: rawContent.slice(0, 200) });
     ops = candidates.map((candidate) => ({
       event: "ADD",
       text: candidate.content,
@@ -6185,12 +6560,12 @@ async function extractAndConsolidate(deps, messages, options) {
   const applyResult = await applyConsolidationOps(deps, ops, options);
   if (!applyResult.success)
     return applyResult;
-  logger19.trace("Consolidation completed", { candidates: candidates.length, related: related.length, ops: ops.length, written: applyResult.data.length });
+  logger21.trace("Consolidation completed", { candidates: candidates.length, related: related.length, ops: ops.length, written: applyResult.data.length });
   return ok(applyResult.data);
 }
 
 // src/memory/providers/ai-memory-provider-native.ts
-var logger20 = core.logger.child({ module: "ai", scope: "memory-native" });
+var logger22 = core.logger.child({ module: "ai", scope: "memory-native" });
 var EVICTION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 function generateId() {
   return `mem_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
@@ -6221,7 +6596,7 @@ function createNativeMemoryOperations(config, llm, embedding, store, vectorStore
     const result = await embedding.embedText(text);
     if (result.success)
       return result.data;
-    logger20.warn("Failed to compute embedding for memory", { error: result.error });
+    logger22.warn("Failed to compute embedding for memory", { error: result.error });
     return void 0;
   }
   async function evictLowest(candidates) {
@@ -6308,10 +6683,10 @@ function createNativeMemoryOperations(config, llm, embedding, store, vectorStore
         }
       }
       await store.save(memoryId, existing, { objectId: existing.objectId });
-      logger20.trace("Memory updated", { id: memoryId });
+      logger22.trace("Memory updated", { id: memoryId });
       return ok(existing);
     } catch (error) {
-      logger20.error("Memory update failed", { id: memoryId, error });
+      logger22.error("Memory update failed", { id: memoryId, error });
       return err(HaiAIError.MEMORY_STORE_FAILED, aiM("ai_memoryStoreFailed", { params: { error: String(error) } }), error);
     }
   }
@@ -6319,7 +6694,7 @@ function createNativeMemoryOperations(config, llm, embedding, store, vectorStore
     const topK = options?.topK ?? config.defaultTopK;
     const recencyWeight = options?.recencyWeight ?? 1 - config.recencyDecay;
     const candidateMultiplier = Math.max(1, options?.candidateMultiplier ?? config.candidateMultiplier);
-    logger20.trace("Recalling memories", { query: query.slice(0, 100), topK, updateAccessStats });
+    logger22.trace("Recalling memories", { query: query.slice(0, 100), topK, updateAccessStats });
     try {
       const where = {};
       const types = options?.types;
@@ -6385,10 +6760,10 @@ function createNativeMemoryOperations(config, llm, embedding, store, vectorStore
         }
         results.push({ ...entry });
       }
-      logger20.trace("Memory recall completed", { query: query.slice(0, 50), resultCount: results.length, updateAccessStats });
+      logger22.trace("Memory recall completed", { query: query.slice(0, 50), resultCount: results.length, updateAccessStats });
       return ok(results);
     } catch (error) {
-      logger20.error("Memory recall failed", { error });
+      logger22.error("Memory recall failed", { error });
       return err(HaiAIError.MEMORY_RECALL_FAILED, aiM("ai_memoryRecallFailed", { params: { error: String(error) } }), error);
     }
   }
@@ -6436,10 +6811,10 @@ function createNativeMemoryOperations(config, llm, embedding, store, vectorStore
       try {
         const vector = await computeVector(entry.content);
         const stored = await saveEntry(entry, vector);
-        logger20.trace("Memory added", { id: stored.id, type: stored.type });
+        logger22.trace("Memory added", { id: stored.id, type: stored.type });
         return ok(stored);
       } catch (error) {
-        logger20.error("Memory add failed", { error });
+        logger22.error("Memory add failed", { error });
         return err(HaiAIError.MEMORY_STORE_FAILED, aiM("ai_memoryStoreFailed", { params: { error: String(error) } }), error);
       }
     },
@@ -6485,7 +6860,7 @@ function createNativeMemoryOperations(config, llm, embedding, store, vectorStore
         return err(HaiAIError.MEMORY_NOT_FOUND, aiM("ai_memoryNotFound", { params: { id: memoryId } }));
       }
       await vectorStore.remove(memoryId);
-      logger20.trace("Memory removed", { id: memoryId });
+      logger22.trace("Memory removed", { id: memoryId });
       return ok(void 0);
     },
     /**
@@ -6565,7 +6940,7 @@ function createNativeMemoryOperations(config, llm, embedding, store, vectorStore
       if (!options?.types && !options?.objectId && !options?.scope) {
         await store.clear();
         await vectorStore.clear();
-        logger20.debug("All memories cleared");
+        logger22.debug("All memories cleared");
         return ok(void 0);
       }
       const where = {};
@@ -6583,13 +6958,13 @@ function createNativeMemoryOperations(config, llm, embedding, store, vectorStore
         await store.remove(entry.id);
         await vectorStore.remove(entry.id);
       }
-      logger20.debug("Memories cleared", { removed: toRemove.length, objectId: options.objectId, types: options.types, scoped: Boolean(options.scope) });
+      logger22.debug("Memories cleared", { removed: toRemove.length, objectId: options.objectId, types: options.types, scoped: Boolean(options.scope) });
       return ok(void 0);
     }
   };
   return operations;
 }
-var logger21 = core.logger.child({ module: "ai", scope: "persona" });
+var logger23 = core.logger.child({ module: "ai", scope: "persona" });
 var DEFAULT_OBJECT_ID2 = "system";
 function personaKey(objectId, id) {
   return JSON.stringify([objectId, id]);
@@ -6622,7 +6997,7 @@ function createPersonaOperations(store) {
           updatedAt: now
         };
         await store.save(key, profile, { objectId });
-        logger21.trace("Persona saved", { id: profile.id, objectId });
+        logger23.trace("Persona saved", { id: profile.id, objectId });
         return ok(profile);
       } catch (error) {
         return err(HaiAIError.PERSONA_SAVE_FAILED, aiM("ai_personaSaveFailed", { params: { error: String(error) } }), error);
@@ -6675,7 +7050,7 @@ function createPersonaOperations(store) {
     }
   };
 }
-var logger22 = core.logger.child({ module: "ai", scope: "rag" });
+var logger24 = core.logger.child({ module: "ai", scope: "rag" });
 var DEFAULT_RAG_SYSTEM_PROMPT = `You are a helpful assistant. Answer the user's question based on the provided context.
 If the context doesn't contain relevant information, say so honestly.
 When using information from the context, cite the source by its number, e.g. [1] or [2].`;
@@ -6704,7 +7079,7 @@ function createRagOperations(llm, retrieval) {
      * @returns `ok(RagResult)` 含 answer、context 列表与引用信源；检索或生成失败时返回错误
      */
     async query(query, options) {
-      logger22.trace("Starting RAG query", { query: query.slice(0, 100) });
+      logger24.trace("Starting RAG query", { query: query.slice(0, 100) });
       try {
         const retrieveResult = await retrieval.retrieve({
           query,
@@ -6753,7 +7128,7 @@ ${contextText}
         }
         const choice = chatResult.data.choices[0];
         const answer = choice?.message?.content ?? "";
-        logger22.trace("RAG query completed", {
+        logger24.trace("RAG query completed", {
           contextCount: contextItems.length,
           model: chatResult.data.model
         });
@@ -6780,7 +7155,7 @@ ${contextText}
           } : void 0
         });
       } catch (error) {
-        logger22.error("RAG query failed", { error });
+        logger24.error("RAG query failed", { error });
         return err(HaiAIError.RAG_FAILED, aiM("ai_internalError", { params: { error: String(error) } }), error);
       }
     },
@@ -6788,7 +7163,7 @@ ${contextText}
      * 流式 RAG 查询：先产出 context，再逐 chunk 产出 delta，最后 done
      */
     async *queryStream(query, options) {
-      logger22.trace("Starting RAG stream", { query: query.slice(0, 100) });
+      logger24.trace("Starting RAG stream", { query: query.slice(0, 100) });
       const retrieveResult = await retrieval.retrieve({
         query,
         sources: options?.sources,
@@ -6865,7 +7240,7 @@ ${contextText}
     }
   };
 }
-var logger23 = core.logger.child({ module: "ai", scope: "reasoning" });
+var logger25 = core.logger.child({ module: "ai", scope: "reasoning" });
 var REACT_SYSTEM_PROMPT = `You are a reasoning agent that follows the ReAct (Reasoning and Acting) framework.
 For each step:
 1. Think: Analyze what you know and what you need to find out.
@@ -7105,7 +7480,7 @@ ${query}` }
   return {
     async run(query, options) {
       const strategy = options?.strategy ?? "react";
-      logger23.trace("Starting reasoning", { strategy, maxRounds: options?.maxRounds });
+      logger25.trace("Starting reasoning", { strategy, maxRounds: options?.maxRounds });
       try {
         switch (strategy) {
           case "react":
@@ -7118,7 +7493,7 @@ ${query}` }
             return err(HaiAIError.REASONING_STRATEGY_NOT_FOUND, aiM("ai_internalError", { params: { error: `Unknown strategy: ${strategy}` } }));
         }
       } catch (error) {
-        logger23.error("Reasoning failed", { error });
+        logger25.error("Reasoning failed", { error });
         return err(HaiAIError.REASONING_FAILED, aiM("ai_internalError", { params: { error: String(error) } }), error);
       }
     },
@@ -7146,7 +7521,7 @@ ${query}` }
     }
   };
 }
-var logger24 = core.logger.child({ module: "ai", scope: "rerank" });
+var logger26 = core.logger.child({ module: "ai", scope: "rerank" });
 function createRerankOperations(config) {
   function normalizeDocuments(documents) {
     if (documents.length === 0) {
@@ -7184,7 +7559,7 @@ function createRerankOperations(config) {
     if (request.returnDocuments) {
       body.return_documents = true;
     }
-    logger24.trace("Calling rerank API", { model: resolved.model, documentCount: texts.length, topN: request.topN });
+    logger26.trace("Calling rerank API", { model: resolved.model, documentCount: texts.length, topN: request.topN });
     try {
       const response = await fetch(`${resolved.baseUrl}/v1/rerank`, {
         method: "POST",
@@ -7196,7 +7571,7 @@ function createRerankOperations(config) {
       });
       if (!response.ok) {
         const errorText = await response.text().catch(() => response.statusText);
-        logger24.error("Rerank API request failed", { status: response.status, error: errorText });
+        logger26.error("Rerank API request failed", { status: response.status, error: errorText });
         return err(HaiAIError.RERANK_API_ERROR, aiM("ai_rerankApiFailed", { params: { error: `HTTP ${response.status}: ${errorText}` } }));
       }
       const data = await response.json();
@@ -7206,10 +7581,10 @@ function createRerankOperations(config) {
         relevanceScore: item.relevance_score,
         document: item.document?.text
       }));
-      logger24.trace("Rerank completed", { resultCount: results.length });
+      logger26.trace("Rerank completed", { resultCount: results.length });
       return ok({ model: resolved.model, results });
     } catch (error) {
-      logger24.error("Rerank API call failed", { error });
+      logger26.error("Rerank API call failed", { error });
       return err(HaiAIError.RERANK_API_ERROR, aiM("ai_rerankApiFailed", { params: { error: String(error) } }), error);
     }
   }
@@ -7241,7 +7616,7 @@ function createRerankOperations(config) {
     }
   };
 }
-var logger25 = core.logger.child({ module: "ai", scope: "retrieval" });
+var logger27 = core.logger.child({ module: "ai", scope: "retrieval" });
 function createRetrievalOperations(embeddingOps, storeProvider, sourceStore, rerankOps) {
   const vectorStoreCache = /* @__PURE__ */ new Map();
   function getVectorStore(collection) {
@@ -7268,7 +7643,7 @@ function createRetrievalOperations(embeddingOps, storeProvider, sourceStore, rer
         return err(HaiAIError.RETRIEVAL_FAILED, aiM("ai_internalError", { params: { error: `Source '${source.id}' already exists` } }));
       }
       await sourceStore.save(source.id, source);
-      logger25.debug("Retrieval source added", { sourceId: source.id, collection: source.collection });
+      logger27.debug("Retrieval source added", { sourceId: source.id, collection: source.collection });
       return ok(void 0);
     },
     /**
@@ -7285,7 +7660,7 @@ function createRetrievalOperations(embeddingOps, storeProvider, sourceStore, rer
         return err(HaiAIError.RETRIEVAL_SOURCE_NOT_FOUND, aiM("ai_internalError", { params: { error: `Source '${sourceId}' not found` } }));
       }
       await sourceStore.remove(sourceId);
-      logger25.debug("Retrieval source removed", { sourceId });
+      logger27.debug("Retrieval source removed", { sourceId });
       return ok(void 0);
     },
     /**
@@ -7364,27 +7739,27 @@ function createRetrievalOperations(embeddingOps, storeProvider, sourceStore, rer
             allItems.length = 0;
             allItems.push(...reranked);
           } else {
-            logger25.warn("Rerank failed, falling back to vector scores", { error: rerankResult.error });
+            logger27.warn("Rerank failed, falling back to vector scores", { error: rerankResult.error });
           }
         }
         allItems.sort((a, b) => b.score - a.score);
         const topK = request.topK ?? 10;
         const limitedItems = allItems.slice(0, topK);
         const duration = Date.now() - startTime;
-        logger25.trace("Retrieval completed", { query: request.query, resultCount: limitedItems.length, duration });
+        logger27.trace("Retrieval completed", { query: request.query, resultCount: limitedItems.length, duration });
         return ok({
           items: limitedItems,
           query: request.query,
           duration
         });
       } catch (error) {
-        logger25.error("Retrieval failed", { error });
+        logger27.error("Retrieval failed", { error });
         return err(HaiAIError.RETRIEVAL_FAILED, aiM("ai_internalError", { params: { error: String(error) } }), error);
       }
     }
   };
 }
-var logger26 = core.logger.child({ module: "ai", scope: "summary" });
+var logger28 = core.logger.child({ module: "ai", scope: "summary" });
 var SUMMARIZE_SYSTEM_PROMPT = `You are a conversation summarizer. Create a concise summary of the conversation that preserves:
 1. Key facts and decisions made
 2. Important context and background information
@@ -7438,7 +7813,7 @@ ${INCREMENTAL_SUMMARIZE_SUFFIX.replace("{previousSummary}", options.previousSumm
     return ok(chatResult.data.choices[0]?.message?.content ?? "");
   }
   async function summarize(messages, options) {
-    logger26.trace("Summarizing messages", { messageCount: messages.length });
+    logger28.trace("Summarizing messages", { messageCount: messages.length });
     try {
       const result = await generate(messages, options);
       if (!result.success)
@@ -7450,7 +7825,7 @@ ${INCREMENTAL_SUMMARIZE_SUFFIX.replace("{previousSummary}", options.previousSumm
         coveredMessages: messages.filter((m) => m.role !== "system").length
       });
     } catch (error) {
-      logger26.error("Context summarization failed", { error });
+      logger28.error("Context summarization failed", { error });
       return err(HaiAIError.CONTEXT_SUMMARIZE_FAILED, aiM("ai_contextSummarizeFailed", { params: { error: String(error) } }), error);
     }
   }
@@ -7494,7 +7869,7 @@ function createTokenOperations(config) {
 }
 
 // src/ai-functions.ts
-var logger27 = core.logger.child({ module: "ai", scope: "functions" });
+var logger29 = core.logger.child({ module: "ai", scope: "functions" });
 async function createAISubsystems(config, deps) {
   const { storeProvider, datapipe: datapipeDep } = deps;
   const memoryParsed = MemoryConfigSchema.parse(config.memory ?? {});
@@ -7516,7 +7891,7 @@ async function createAISubsystems(config, deps) {
   const retrieval = createRetrievalOperations(embedding, storeProvider, sourceStore, rerank);
   if (config.retrieval?.sources?.length) {
     const configSources = RetrievalConfigSchema.parse(config.retrieval).sources ?? [];
-    sourceStore.saveMany(configSources.map((s) => ({ id: s.id, data: s }))).catch((e) => logger27.warn("Failed to pre-register retrieval sources", { error: e }));
+    sourceStore.saveMany(configSources.map((s) => ({ id: s.id, data: s }))).catch((e) => logger29.warn("Failed to pre-register retrieval sources", { error: e }));
   }
   const rag = createRagOperations(llm, retrieval);
   const knowledgeParsed = KnowledgeConfigSchema.parse(config.knowledge ?? {});
@@ -7550,7 +7925,7 @@ async function createAISubsystems(config, deps) {
   const image = createImageOperations(config);
   return { llm, mcp, embedding, reasoning, rerank, retrieval, rag, knowledge, memory, persona, token, summary, compress, context, file, audio, image };
 }
-var logger28 = core.logger.child({ module: "ai", scope: "store-provider-db" });
+var logger30 = core.logger.child({ module: "ai", scope: "store-provider-db" });
 var MAX_BATCH_SQL_PARAMS = 900;
 var ReldbAIRelStore = class {
   sql;
@@ -8007,7 +8382,7 @@ var DbKnowledgeStore = class {
     for (const stmt of statements) {
       const result = await this.sql.execute(stmt);
       if (!result.success) {
-        logger28.error("Knowledge schema creation failed", { sql: stmt.trim().slice(0, 60), error: result.error });
+        logger30.error("Knowledge schema creation failed", { sql: stmt.trim().slice(0, 60), error: result.error });
         throw new Error(`Knowledge schema creation failed: ${String(result.error)}`);
       }
     }
@@ -8275,7 +8650,7 @@ function createDbStoreProvider(deps) {
     async initialize() {
       if (relStores.length > 0) {
         await Promise.all(relStores.map((s) => s.createTable()));
-        logger28.debug("DB store provider initialized", { tableCount: relStores.length });
+        logger30.debug("DB store provider initialized", { tableCount: relStores.length });
       }
     },
     async close() {
@@ -8488,7 +8863,7 @@ function createMemoryStoreProvider() {
 }
 
 // src/ai-main.ts
-var logger29 = core.logger.child({ module: "ai", scope: "main" });
+var logger31 = core.logger.child({ module: "ai", scope: "main" });
 var initInProgress = false;
 var currentConfig = null;
 var currentLLM = null;
@@ -8629,7 +9004,7 @@ async function resetAllState() {
     try {
       await storeProvider.close();
     } catch (error) {
-      logger29.error("AI store provider close failed", { error });
+      logger31.error("AI store provider close failed", { error });
     }
   }
 }
@@ -8646,19 +9021,19 @@ var streamOperations = {
 var ai = {
   async init(config, options) {
     if (initInProgress) {
-      logger29.warn("AI init already in progress, skipping concurrent call");
+      logger31.warn("AI init already in progress, skipping concurrent call");
       return err(HaiAIError.INIT_IN_PROGRESS, aiM("ai_initInProgress"));
     }
     initInProgress = true;
     try {
       if (currentConfig) {
-        logger29.warn("AI module is already initialized, reinitializing");
+        logger31.warn("AI module is already initialized, reinitializing");
         await ai.close();
       }
-      logger29.info("Initializing AI module");
+      logger31.info("Initializing AI module");
       const parseResult = AIConfigSchema.safeParse(config ?? {});
       if (!parseResult.success) {
-        logger29.error("AI config validation failed", { error: parseResult.error.message });
+        logger31.error("AI config validation failed", { error: parseResult.error.message });
         return err(
           HaiAIError.CONFIGURATION_ERROR,
           aiM("ai_configError", { params: { error: parseResult.error.message } }),
@@ -8673,7 +9048,7 @@ var ai = {
         storeProvider = createDbStoreProviderFromModules();
       } else {
         storeProvider = createMemoryStoreProvider();
-        logger29.warn("AI is using the ephemeral in-memory store; initialize reldb and vecdb before ai.init() for persistent data");
+        logger31.warn("AI is using the ephemeral in-memory store; initialize reldb and vecdb before ai.init() for persistent data");
       }
       currentStoreProvider = storeProvider;
       const subs = await createAISubsystems(parsed, {
@@ -8699,11 +9074,11 @@ var ai = {
       currentImage = subs.image;
       currentA2AConfig = parsed.a2a;
       currentConfig = parsed;
-      logger29.info("AI module initialized", { model: parsed.llm?.model });
+      logger31.info("AI module initialized", { model: parsed.llm?.model });
       return ok(void 0);
     } catch (error) {
       await resetAllState();
-      logger29.error("AI module initialization failed", { error });
+      logger31.error("AI module initialization failed", { error });
       return err(
         HaiAIError.CONFIGURATION_ERROR,
         aiM("ai_initFailed", {
@@ -8783,12 +9158,12 @@ var ai = {
   },
   async close() {
     if (!currentConfig) {
-      logger29.info("AI module already closed, skipping");
+      logger31.info("AI module already closed, skipping");
       return;
     }
-    logger29.info("Closing AI module");
+    logger31.info("Closing AI module");
     await resetAllState();
-    logger29.info("AI module closed");
+    logger31.info("AI module closed");
   }
 };
 function createMcpServer(options) {