kiku-agent 1.3.2 → 1.3.4

package/server/agent/cli.js

@@ -6,6 +6,8 @@ import { stdin as input } from 'node:process';
 import { existsSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import './envBootstrap.js';
+import { resolveDynamicWindowsAppPaths } from './appPaths.js';
+import { registerBackgroundProcess } from './processManager.js';
 import { KikuAgent } from './agentCore.js';
 import { LLMClient, LMStudioClient } from './llmClient.js';
 import { toolsSchema, toolHandlers, executeTool } from './tools.js';
@@ -116,6 +118,15 @@ function recordQueryDiagnostics(details) {
   return lastQueryDetails;
 }
 
+export function resolveModelFallbackWarning(modelResolution = {}, opts = {}) {
+  if (!modelResolution.usedFallback) return null;
+  if (!opts.model) return null;
+  return {
+    requested: modelResolution.requestedModel || opts.model,
+    selected: modelResolution.selectedModel,
+  };
+}
+
 export function parseCliArgs(customArgs = null) {
   const args = customArgs || process.argv.slice(2);
   const options = {
@@ -144,6 +155,9 @@ export function parseCliArgs(customArgs = null) {
     eval: null,
     hub: null,
     portal: null,
+    gpuOffload: null,
+    cpuThreads: null,
+    nGpuLayers: null,
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -205,6 +219,20 @@ export function parseCliArgs(customArgs = null) {
     else if (arg === '--portal') {
       options.portal = (args[i + 1] && !args[i + 1].startsWith('-')) ? args[++i] : 'open';
     }
+    else if (arg === '--n-gpu-layers' || arg === '--gpu-layers' || arg === '-ngl') {
+      const val = args[++i];
+      options.nGpuLayers = val;
+      options.gpuOffload = val;
+    }
+    else if (arg === '--gpu-offload') {
+      options.gpuOffload = args[++i];
+    }
+    else if (arg === '--threads' || arg === '--cpu-threads') {
+      const maybeThreads = Number(args[++i]);
+      if (Number.isFinite(maybeThreads) && maybeThreads >= 1) {
+        options.cpuThreads = Math.trunc(maybeThreads);
+      }
+    }
     else if (!arg.startsWith('-') && !options.query) { options.query = args.slice(i).join(' '); break; }
     else if (arg.startsWith('-')) {
       console.error(`Unknown option: ${arg}`);
@@ -243,11 +271,7 @@ async function attemptAutoStartLMStudio(baseUrl, model) {
   const isMac = process.platform === 'darwin';
 
   const candidates = isWin
-    ? [
-      `${process.env.LOCALAPPDATA}\\LM Studio\\LM Studio.exe`,
-      `${process.env.LOCALAPPDATA}\\Programs\\LM Studio\\LM Studio.exe`,
-      'C:\\Program Files\\LM Studio\\LM Studio.exe'
-    ]
+    ? resolveDynamicWindowsAppPaths('LM Studio', 'LM Studio.exe')
     : isMac
       ? ['/Applications/LM Studio.app/Contents/MacOS/LM Studio']
       : ['lmstudio', '/usr/local/bin/lmstudio', '/opt/lmstudio/bin/lmstudio'];
@@ -275,6 +299,13 @@ async function attemptAutoStartLMStudio(baseUrl, model) {
       : ['serve', '--model', model, '--port', port],
       { detached: true, stdio: 'ignore', windowsHide: true }
     );
+    if (child.pid) {
+      registerBackgroundProcess('lmstudio', child, {
+        command: exe,
+        args: isWin ? ['--model', model, '--serve', '--port', port] : ['serve', '--model', model, '--port', port],
+        metadata: { model, port },
+      });
+    }
     child.unref();
 
     return await waitForLMStudio(baseUrl, 45000);
@@ -638,6 +669,8 @@ export function printHelp(specificCmd = null) {
   helpLines.push(`  ${C.emerald}${"--web-chat, --web".padEnd(28)}${C.reset} ${C.white}Start standalone web chatbot (default port 3300)${C.reset}`);
   helpLines.push(`  ${C.emerald}${"--cn-tools, --cn".padEnd(28)}${C.reset} ${C.white}Enable Chinese web tools (search_bilibili, Baidu)${C.reset}`);
   helpLines.push(`  ${C.emerald}${"--port <n>".padEnd(28)}${C.reset} ${C.white}Web chatbot port 1-65535 (or --web-chat=<port>)${C.reset}`);
+  helpLines.push(`  ${C.emerald}${"--n-gpu-layers <n>".padEnd(28)}${C.reset} ${C.white}GPU offload layers/mode (max, off, 0.0-1.0, or layer count)${C.reset}`);
+  helpLines.push(`  ${C.emerald}${"--threads <n>".padEnd(28)}${C.reset} ${C.white}CPU thread pool size (1-256) for local model execution${C.reset}`);
   helpLines.push(`  ${C.emerald}${"--no-open, --open".padEnd(28)}${C.reset} ${C.white}Skip or force auto-open browser for --web-chat${C.reset}`);
   helpLines.push(`  ${C.emerald}${"-v, --verbose".padEnd(28)}${C.reset} ${C.white}Verbose logging and thinking${C.reset}`);
   helpLines.push(`  ${C.emerald}${"-V, --version".padEnd(28)}${C.reset} ${C.white}Print version${C.reset}`);
@@ -742,7 +775,7 @@ function printAd() {
 
 function getInitialViewportLines() {
   const heroLines = getWelcomeHeroLines();
-  const galleryLines = getWelcomeGalleryLines(2);
+  const galleryLines = process.env.KIKU_WELCOME_GALLERY === 'true' ? getWelcomeGalleryLines(2) : [];
   return galleryLines.length > 0 ? [...heroLines, ...galleryLines] : heroLines;
 }
 
@@ -768,6 +801,7 @@ class InteractiveTuiPrompt {
     this.isResolving = false;
     this.activeResolve = null;
     this.activeReject = null;
+    this.parkedReads = [];
     this.onCancel = options.onCancel || null;
     this.onSigInt = options.onSigInt || null;
     this._keyHandler = null;
@@ -844,6 +878,24 @@ class InteractiveTuiPrompt {
 
   async readLine(options = {}) {
     return new Promise((resolve, reject) => {
+      if (this.activeResolve && !this.isResolving) {
+        // A read is already active (the main input loop). Park it instead of
+        // leaking its promise: modal callers (/env init, /quiz, clarifying
+        // answers) own the terminal until they finish, then the parked read
+        // resumes via _resumeParked().
+        this.parkedReads.push({
+          resolve: this.activeResolve,
+          reject: this.activeReject,
+          line: this.line,
+          cursor: this.cursor,
+          promptText: this.promptText,
+          placeholder: this.inputPlaceholder,
+          cancelValue: this.cancelValue,
+          recordInputHistory: this.recordInputHistory,
+        });
+        this.activeResolve = null;
+        this.activeReject = null;
+      }
       this._cleanupInput();
       const inputOptions = typeof options === 'string' ? { prompt: options } : options;
       this.promptText = inputOptions.prompt || this.defaultPromptText;
@@ -890,6 +942,38 @@ class InteractiveTuiPrompt {
     this.activeResolve = null;
     this.activeReject = null;
     if (resolve) resolve(result);
+    this._resumeParked();
+  }
+
+  _resumeParked() {
+    const parked = this.parkedReads.pop();
+    if (!parked || this.isDisposed || this.activeResolve) return;
+    this.isResolving = false;
+    this.activeResolve = parked.resolve;
+    this.activeReject = parked.reject;
+    this.line = parked.line;
+    this.cursor = parked.cursor;
+    this.promptText = parked.promptText;
+    this.inputPlaceholder = parked.placeholder;
+    this.cancelValue = parked.cancelValue;
+    this.recordInputHistory = parked.recordInputHistory;
+    this.historyIndex = -1;
+    this.popoverIndex = 0;
+    this.popoverActive = false;
+    this.popoverItems = [];
+    this.ghostText = '';
+    try {
+      this.updateState();
+      readline.emitKeypressEvents(input);
+      if (input.isTTY) input.setRawMode(true);
+      this._keyHandler = (str, key) => {
+        try { this.handleKeypress(str, key); } catch (error) { this.fail(error); }
+      };
+      input.on('keypress', this._keyHandler);
+      this.render();
+    } catch (error) {
+      this.fail(error);
+    }
   }
 
   abortActiveRead(result = null) {
@@ -905,6 +989,7 @@ class InteractiveTuiPrompt {
     this.activeResolve = null;
     this.activeReject = null;
     resolve(result);
+    this._resumeParked();
     return true;
   }
 
@@ -916,6 +1001,7 @@ class InteractiveTuiPrompt {
     this.activeResolve = null;
     this.activeReject = null;
     if (reject) reject(error);
+    this._resumeParked();
   }
 
   dispose() {
@@ -925,6 +1011,10 @@ class InteractiveTuiPrompt {
     this.activeResolve = null;
     this.activeReject = null;
     this.isResolving = true;
+    const parked = this.parkedReads.splice(0);
+    for (const entry of parked) {
+      try { entry.resolve(null); } catch { }
+    }
   }
 
   updateState() {
@@ -1712,6 +1802,10 @@ async function executeQueryWithUI(agent, prompt, isThinkingVisible = false, sign
                 console.log(formatQuestionsForCLI(questions, C));
               },
               onClarifyingAnswer: (queryId) => {
+                if (globalTuiPrompt && typeof globalTuiPrompt.readLine === 'function') {
+                  return globalTuiPrompt.readLine({ prompt: `${C.gold}> ${C.reset}`, history: false, cancelValue: '' })
+                    .then(answer => String(answer ?? '').trim());
+                }
                 return new Promise((resolve) => {
                   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
                   rl.question(`${C.gold}> ${C.reset}`, (answer) => {
@@ -1926,7 +2020,7 @@ function vramZoneTag(zone) {
  * model's estimated footprint, so users immediately see whether the loaded
  * model is a heavy fit for their card. Informational only — never blocks.
  */
-async function printResourceVerificationPanel(client) {
+async function printResourceVerificationPanel(client, { verbose = false } = {}) {
   if (!client || client.provider !== 'lmstudio') return;
   try {
     const [hw, runtime] = await Promise.all([
@@ -1950,12 +2044,44 @@ async function printResourceVerificationPanel(client) {
       contextLength: runtimeCtx,
     });
 
-    const lines = [];
     let livePct = null;
     if (hw.available && hw.freeBytes !== null && hw.freeBytes !== undefined) {
       const usedBytes = Math.max(0, hw.totalBytes - hw.freeBytes);
       const live = classifyAllocation({ totalBytes: usedBytes, availableBytes: hw.totalBytes });
       livePct = live.usagePct;
+    }
+
+    let verdict = null;
+    if (livePct !== null) {
+      if (livePct <= 80) verdict = `${C.emerald}Resource load is comfortable (${livePct}% VRAM in use).${C.reset}`;
+      else if (livePct <= 95) verdict = `${C.gold}This model is heavy for the card (${livePct}% VRAM in use) — expect slower prefill on long contexts.${C.reset}`;
+      else verdict = `${C.roseGlow}VRAM is critically full (${livePct}%) — lower the context or switch to a smaller quant in LM Studio.${C.reset}`;
+    } else if (estimate.totalBytes > 0 && hw.available) {
+      const estCls = classifyAllocation({ totalBytes: estimate.totalBytes, availableBytes: hw.totalBytes });
+      if (estCls.zone === 'RED') verdict = `${C.gold}Naive estimate exceeds the card — if it loads anyway, sliding-window caching is saving you; otherwise lower ctx/quant.${C.reset}`;
+      else verdict = `${C.dim}Live usage unavailable — estimate says ${estCls.zone}.${C.reset}`;
+    }
+
+    if (!verbose) {
+      const gpuDesc = hw.available && hw.freeBytes !== null
+        ? `${hw.name} (${livePct !== null ? `${livePct}% VRAM used` : 'active'}, ${formatGb(hw.freeBytes)} free)`
+        : (hw.available ? hw.name : 'CPU / RAM');
+      const cleanVerdict = verdict ? stripAnsi(verdict).replace(/\s*\([^)]*\)/, '') : 'Ready';
+      printRichCard({
+        title: 'Hardware & Inference Target',
+        status: livePct && livePct > 95 ? 'warning' : 'connected',
+        lines: [
+          `• GPU: ${gpuDesc}  • Model: ${client.model}`,
+          `• Memory: ${cleanVerdict} (use /vram for full telemetry)`,
+        ],
+      });
+      return;
+    }
+
+    const lines = [];
+    if (hw.available && hw.freeBytes !== null && hw.freeBytes !== undefined) {
+      const usedBytes = Math.max(0, hw.totalBytes - hw.freeBytes);
+      const live = classifyAllocation({ totalBytes: usedBytes, availableBytes: hw.totalBytes });
       lines.push(`${C.gold}GPU (live):${C.reset}   ${C.white}${hw.name}${C.reset} — ${C.bold}${live.usagePct}%${C.reset} ${C.dim}(${formatGb(usedBytes)} / ${formatGb(hw.totalBytes)} used)${C.reset} ${vramZoneTag(live.zone)}`);
       lines.push(`${C.gold}Free VRAM:${C.reset}   ${C.emerald}${formatGb(hw.freeBytes)}${C.reset}`);
     } else if (hw.available) {
@@ -1975,16 +2101,6 @@ async function printResourceVerificationPanel(client) {
         (estCls && estCls.zone !== 'UNKNOWN' ? ` ${vramZoneTag(estCls.zone)}` : ''));
     }
 
-    let verdict = null;
-    if (livePct !== null) {
-      if (livePct <= 80) verdict = `${C.emerald}Resource load is comfortable (${livePct}% VRAM in use).${C.reset}`;
-      else if (livePct <= 95) verdict = `${C.gold}This model is heavy for the card (${livePct}% VRAM in use) — expect slower prefill on long contexts.${C.reset}`;
-      else verdict = `${C.roseGlow}VRAM is critically full (${livePct}%) — lower the context or switch to a smaller quant in LM Studio.${C.reset}`;
-    } else if (estimate.totalBytes > 0 && hw.available) {
-      const estCls = classifyAllocation({ totalBytes: estimate.totalBytes, availableBytes: hw.totalBytes });
-      if (estCls.zone === 'RED') verdict = `${C.gold}Naive estimate exceeds the card — if it loads anyway, sliding-window caching is saving you; otherwise lower ctx/quant.${C.reset}`;
-      else verdict = `${C.dim}Live usage unavailable — estimate says ${estCls.zone}.${C.reset}`;
-    }
     if (verdict) lines.push(`${C.gold}Verdict:${C.reset}    ${verdict}`);
     lines.push(`${C.dim}Details: /vram live • /vram compare • /vram ctx${C.reset}`);
 
@@ -2072,7 +2188,7 @@ async function executeHeadlessQuery(opts, query) {
   let executionError = null;
 
   try {
-    const modelManager = new ModelManager(client, { requestedModel: opts.model || client.model });
+    const modelManager = new ModelManager(client, { requestedModel: opts.model || client.model, strictModel: Boolean(opts.model) });
     const modelResolution = await modelManager.resolve({ requestedModel: opts.model || client.model });
 
     if (!modelResolution.connected || !modelResolution.selectedModel) {
@@ -2322,8 +2438,13 @@ async function main() {
       apiKey: opts.apiKey,
       model: opts.model
     });
-    const modelManager = new ModelManager(client, { requestedModel: opts.model || client.model });
-    const modelResolution = await modelManager.resolve({ requestedModel: opts.model || client.model });
+    const modelManager = new ModelManager(client, { requestedModel: opts.model || client.model, strictModel: Boolean(opts.model) });
+    const modelResolution = await modelManager.resolve({
+      requestedModel: opts.model || client.model,
+      autoWakeup: true,
+      gpuOffload: opts.gpuOffload,
+      cpuThreads: opts.cpuThreads,
+    });
     if (!modelResolution.connected || !modelResolution.selectedModel) {
       console.error(modelResolution.error || `No available chat model found for ${client.providerName}`);
       process.exit(2);
@@ -2429,24 +2550,15 @@ async function main() {
             }
 
             if (!health.connected) {
-              printRichCard({
-                title: `${client.providerName} Offline`,
-                status: 'offline',
-                lines: [
-                  `• Endpoint: ${baseUrl || 'local'} (${health.error || 'unreachable'})`,
-                  ...(client.provider === 'lmstudio' ? ['• Action: Attempting auto-start of local LM Studio...'] : []),
-                ],
-              });
-
               if (client.provider === 'lmstudio') {
                 const autoHealth = await attemptAutoStartLMStudio(baseUrl, opts.model || client.model);
                 if (autoHealth) {
                   health = autoHealth;
                   printRichCard({
-                    title: 'LM Studio Started',
-                    status: 'ok',
+                    title: 'LM Studio Auto-Started',
+                    status: 'connected',
                     lines: [
-                      'Local LM Studio process started and responding.',
+                      '• Local LM Studio process started and responding.',
                     ],
                   });
                 } else {
@@ -2456,9 +2568,9 @@ async function main() {
                     title: 'LM Studio Offline • AI Chat Locked',
                     status: 'offline',
                     lines: [
-                      'LM Studio is not running. Free-form chat typing is locked to prevent errors.',
-                      'Open LM Studio and load a model (e.g. google/gemma-4-e4b) — it will auto-connect once loaded.',
-                      'Offline commands available: /model reconnect, /help, /provider, /doctor, /theme, /exit',
+                      `• Endpoint: ${baseUrl || 'http://127.0.0.1:1234/v1'} (unreachable)`,
+                      '• Open LM Studio and load google/gemma-4-e4b — auto-connects when loaded in VRAM.',
+                      '• Offline commands available: /model reconnect, /help, /provider, /doctor, /theme, /exit',
                     ],
                   });
                 }
@@ -2478,10 +2590,15 @@ async function main() {
             }
           }
 
-          const modelManager = new ModelManager(client, { requestedModel: opts.model || client.model });
+          const modelManager = new ModelManager(client, { requestedModel: opts.model || client.model, strictModel: Boolean(opts.model) });
           const modelResolution = catalogOnlyMode
             ? { connected: false, state: 'catalog_only' }
-            : await modelManager.resolve({ requestedModel: opts.model || client.model });
+            : await modelManager.resolve({
+                requestedModel: opts.model || client.model,
+                autoWakeup: true,
+                gpuOffload: opts.gpuOffload,
+                cpuThreads: opts.cpuThreads,
+              });
           if (!catalogOnlyMode && (!modelResolution.connected || !modelResolution.selectedModel)) {
             printRichCard({
               title: 'Model Not Loaded • AI Chat Locked',
@@ -2505,13 +2622,14 @@ async function main() {
               ],
             });
           }
-          if (modelResolution.usedFallback) {
+          const fallbackWarning = resolveModelFallbackWarning(modelResolution, opts);
+          if (fallbackWarning) {
             printRichCard({
               title: 'Model Fallback',
               status: 'warning',
               lines: [
-                `Requested model ${opts.model} was unavailable.`,
-                `Fallback model ${modelResolution.selectedModel} selected.`,
+                `Requested model ${fallbackWarning.requested} was unavailable.`,
+                `Fallback model ${fallbackWarning.selected} selected.`,
               ],
             });
           }
@@ -2571,12 +2689,18 @@ async function main() {
           }
 
           if (!catalogOnlyMode) {
-            await printResourceVerificationPanel(client);
+            await printResourceVerificationPanel(client, { verbose: opts.verbose });
           }
 
           if (agent.restoredMessageCount > 0) {
             const s = agent.session;
-            console.log(`\n  ${C.sakura}${C.bold}[SESSION RESTORED]${C.reset} ${C.dim}${s.id} — ${s.messages.length} messages${C.reset}\n`);
+            printRichCard({
+              title: 'Active Session Restored',
+              status: 'session',
+              lines: [
+                `• Session: ${s.id} — ${s.messages.length} message(s) loaded from history`,
+              ],
+            });
           }
 
           agent.stateMachine.on('enter:' + AgentStates.FETCHING_TOOL, ({ toolName }) => {
@@ -2631,7 +2755,7 @@ async function main() {
                   ? await modelManager.resolve()
                   : await client.checkConnection();
 
-                if (resolution?.connected && (resolution.selectedModel || resolution.activeLoadedModel)) {
+                if (resolution?.connected && resolution.isModelLoaded !== false && (resolution.selectedModel || resolution.activeLoadedModel)) {
                   const detectedModel = resolution.selectedModel || resolution.activeLoadedModel;
                   catalogOnlyMode = false;
                   tuiPrompt.isConnected = true;
@@ -2749,7 +2873,7 @@ async function main() {
                     if (catalogOnlyMode && modelManager) {
                       try {
                         const autoProbe = await modelManager.resolve();
-                        if (autoProbe?.connected && (autoProbe.selectedModel || autoProbe.activeLoadedModel)) {
+                        if (autoProbe?.connected && autoProbe.isModelLoaded !== false && (autoProbe.selectedModel || autoProbe.activeLoadedModel)) {
                           cmdCtx.setCatalogOnlyMode(false);
                           if (tuiPrompt) {
                             tuiPrompt.modelName = autoProbe.selectedModel || autoProbe.activeLoadedModel;
@@ -2835,6 +2959,7 @@ async function main() {
             '/config', '/settings', '/conf',
             '/sources', '/src', '/srcs',
             '/queue',
+            '/unload',
             '/ads', '/sponsor', '/ad',
           ]);
 
@@ -2853,7 +2978,7 @@ async function main() {
             if (base === '/session' && (!sub || ['info', 'list', 'summary'].includes(sub))) return true;
             if (base === '/lang' && !sub) return true;
             if (base === '/thinking' && !sub) return true;
-            if (base === '/model' && (!sub || sub === 'status' || sub === 'list' || sub === 'recommend')) return true;
+            if (base === '/model' && (!sub || ['status', 'list', 'recommend', 'unload', 'engine', 'config', 'params', 'preset', 'presets', 'files', 'gguf', 'temp', 'temperature', 'topp', 'ctx', 'context', 'thinking'].includes(sub))) return true;
             if (base === '/provider' && (!sub || sub === 'list' || sub === 'status' || sub === 'info')) return true;
             if (base === '/mcp' && (!sub || sub === 'status' || sub === 'list' || sub === 'tools')) return true;
             if (base === '/env' && (!sub || sub === 'get' || sub === 'path')) return true;
@@ -3051,7 +3176,7 @@ async function main() {
                 const autoProbe = modelManager
                   ? await modelManager.resolve()
                   : await client.checkConnection();
-                if (autoProbe?.connected && (autoProbe.selectedModel || autoProbe.activeLoadedModel)) {
+                if (autoProbe?.connected && autoProbe.isModelLoaded !== false && (autoProbe.selectedModel || autoProbe.activeLoadedModel)) {
                   catalogOnlyMode = false;
                   tuiPrompt.isConnected = true;
                   tuiPrompt.modelName = autoProbe.selectedModel || autoProbe.activeLoadedModel;
@@ -3108,6 +3233,7 @@ async function main() {
 
             lastQuery = trimmed;
             queryQueue.push({ id: 'q_' + Date.now(), number: queryNumber, prompt: trimmed, addedAt: Date.now() });
+            queryCount++;
             triggerQueueProcessing();
           }
 
@@ -3116,7 +3242,10 @@ async function main() {
             globalTuiPrompt.dispose();
             globalTuiPrompt = null;
           }
-          exitAlternateScreen();
+          exitAlternateScreen();
+          if (queryCount === 0 && !process.stdin.isTTY) {
+            console.log(`\n  ${C.dim}Tip: Run 'kiku-agent' directly on its own line. Avoid chaining with ';' in PowerShell (e.g. 'cmd1 ; kiku-agent') as PowerShell pipes empty input into stdin.${C.reset}`);
+          }
           process.stdout.write(`\n  ${C.sakura}Goodbye • 再见 (鞠躬 ~ 谢谢!)${C.reset}\n\n`, () => {
             process.exit(0);
           });

package/server/agent/cloudAdapters.js

@@ -0,0 +1,116 @@
+export function toAnthropicMessages(messages = []) {
+  const system = [];
+  const converted = [];
+  for (const message of messages) {
+    const role = message?.role;
+    if (role === 'system') {
+      if (message.content) system.push(String(message.content));
+      continue;
+    }
+    if (role === 'tool') {
+      const toolUseId = message.tool_call_id || message.tool_use_id || 'unknown_tool_call';
+      const rawContent = String(message.content ?? '');
+      let isError = false;
+      try {
+        const parsed = JSON.parse(rawContent);
+        if (parsed && (parsed.status === 'error' || parsed.error || parsed.is_error)) {
+          isError = true;
+        }
+      } catch {}
+
+      const toolResultBlock = {
+        type: 'tool_result',
+        tool_use_id: toolUseId,
+        content: rawContent,
+        ...(isError ? { is_error: true } : {}),
+      };
+
+      
+      const lastMsg = converted[converted.length - 1];
+      if (lastMsg && lastMsg.role === 'user' && Array.isArray(lastMsg.content) && lastMsg.content[0]?.type === 'tool_result') {
+        lastMsg.content.push(toolResultBlock);
+      } else {
+        converted.push({
+          role: 'user',
+          content: [toolResultBlock],
+        });
+      }
+      continue;
+    }
+    if (role === 'assistant') {
+      const blocks = [];
+    
+      if (Array.isArray(message.thinking_blocks) && message.thinking_blocks.length > 0) {
+        blocks.push(...message.thinking_blocks);
+      }
+     
+      const textContent = normalizeContent(message?.content);
+      if (textContent) {
+        blocks.push({ type: 'text', text: textContent });
+      }
+     
+      if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+        for (const call of message.tool_calls) {
+          blocks.push({
+            type: 'tool_use',
+            id: call.id || `call_${Date.now()}`,
+            name: call.function?.name || call.name || '',
+            input: parseJson(call.function?.arguments ?? call.arguments),
+          });
+        }
+      }
+      if (blocks.length > 0) {
+        converted.push({ role: 'assistant', content: blocks });
+      } else {
+        converted.push({ role: 'assistant', content: textContent || '' });
+      }
+      continue;
+    }
+    converted.push({ role: role === 'assistant' ? 'assistant' : 'user', content: normalizeContent(message?.content) });
+  }
+  return { system: system.join('\n\n'), messages: converted };
+}
+
+export function toAnthropicTools(tools = []) {
+  return (tools || []).map(tool => ({
+    name: tool.function?.name || tool.name,
+    description: tool.function?.description || tool.description || '',
+    input_schema: tool.function?.parameters || tool.parameters || { type: 'object', properties: {} },
+  })).filter(tool => tool.name);
+}
+
+export function normalizeAnthropicResponse(data = {}) {
+  const blocks = Array.isArray(data.content) ? data.content : [];
+  const text = blocks.filter(block => block.type === 'text').map(block => block.text || '').join('');
+  const reasoning = blocks.filter(block => block.type === 'thinking').map(block => block.thinking || '').join('');
+  const thinkingBlocks = blocks.filter(block => block.type === 'thinking' || block.type === 'redacted_thinking');
+  const toolCalls = blocks.filter(block => block.type === 'tool_use').map(block => ({
+    id: block.id || `call_${Date.now()}`,
+    type: 'function',
+    function: { name: block.name || '', arguments: JSON.stringify(block.input || {}) },
+  }));
+  return {
+    role: 'assistant',
+    content: text,
+    ...(reasoning ? { reasoning_content: reasoning } : {}),
+    ...(thinkingBlocks.length ? { thinking_blocks: thinkingBlocks } : {}),
+    ...(toolCalls.length ? { tool_calls: toolCalls } : {}),
+    usage: data.usage ? {
+      prompt_tokens: data.usage.input_tokens || 0,
+      completion_tokens: data.usage.output_tokens || 0,
+      reasoning_tokens: 0,
+      total_tokens: (data.usage.input_tokens || 0) + (data.usage.output_tokens || 0),
+    } : undefined,
+  };
+}
+
+function normalizeContent(content) {
+  if (Array.isArray(content)) return content.map(part => part?.text || '').join('');
+  return content == null ? '' : String(content);
+}
+
+function parseJson(value) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) return value;
+  try { return JSON.parse(String(value || '{}')); } catch { return {}; }
+}
+