@zythum02/fello-server 0.1.51 → 0.1.53

package/out/server/main.js

@@ -231,6 +231,25 @@ function readSettings() {
       model: p.model,
       active: typeof p.active === "boolean" ? p.active : false
     })) : [];
+    const speechToText = Array.isArray(rawObj?.speechToText) ? rawObj.speechToText.filter((value) => isObject(value)).filter((value) => {
+      const provider = value.provider;
+      return typeof value.id === "string" && typeof value.name === "string" && typeof value.apiKey === "string" && (provider === "volcengine" || provider === "dashscope" || provider === "openai" || provider === "iflytek");
+    }).map((value) => ({
+      id: value.id,
+      name: value.name,
+      provider: value.provider,
+      apiKey: value.apiKey,
+      appId: typeof value.appId === "string" ? value.appId : void 0,
+      apiSecret: typeof value.apiSecret === "string" ? value.apiSecret : void 0,
+      resourceId: typeof value.resourceId === "string" ? value.resourceId : void 0,
+      model: typeof value.model === "string" ? value.model : void 0,
+      baseUrl: typeof value.baseUrl === "string" ? value.baseUrl : void 0,
+      workspaceId: typeof value.workspaceId === "string" ? value.workspaceId : void 0,
+      region: value.region === "cn-beijing" || value.region === "ap-southeast-1" ? value.region : void 0,
+      workspace: typeof value.workspace === "string" ? value.workspace : void 0,
+      language: typeof value.language === "string" ? value.language : void 0,
+      active: typeof value.active === "boolean" ? value.active : false
+    })) : [];
     const editor = (() => {
       const raw2 = rawObj && isObject(rawObj.editor) ? rawObj.editor : null;
       if (raw2 && typeof raw2.name === "string" && raw2.name.trim()) {
@@ -249,7 +268,8 @@ function readSettings() {
       sound,
       proxy,
       snippets,
-      imageGeneration
+      imageGeneration,
+      speechToText
     };
   } catch {
     return DEFAULT_SETTINGS;
@@ -351,6 +371,22 @@ function getSettings() {
       extraBody: p.extraBody ?? void 0,
       model: p.model,
       active: p.active
+    })),
+    speechToText: (meta.speechToText ?? []).map((p) => ({
+      id: p.id,
+      name: p.name,
+      provider: p.provider,
+      apiKey: p.apiKey,
+      appId: p.appId,
+      apiSecret: p.apiSecret,
+      resourceId: p.resourceId,
+      model: p.model,
+      baseUrl: p.baseUrl,
+      workspaceId: p.workspaceId,
+      region: p.region,
+      workspace: p.workspace,
+      language: p.language,
+      active: p.active
     }))
   };
 }
@@ -506,7 +542,23 @@ function updateSettings(settings) {
       extraBody: p.extraBody ?? void 0,
       model: p.model,
       active: p.active
-    })) : prevMeta.imageGeneration
+    })) : prevMeta.imageGeneration,
+    speechToText: settings.speechToText ? settings.speechToText.map((p) => ({
+      id: p.id,
+      name: p.name,
+      provider: p.provider,
+      apiKey: p.apiKey,
+      appId: p.appId?.trim() || void 0,
+      apiSecret: p.apiSecret?.trim() || void 0,
+      resourceId: p.resourceId?.trim() || void 0,
+      model: p.model?.trim() || void 0,
+      baseUrl: p.baseUrl?.trim() || void 0,
+      workspaceId: p.workspaceId?.trim() || void 0,
+      region: p.region,
+      workspace: p.workspace?.trim() || void 0,
+      language: p.language?.trim() || void 0,
+      active: p.active
+    })) : prevMeta.speechToText
   };
   writeSettings(meta);
 }
@@ -913,6 +965,35 @@ function readTerminalOutput(sessionIdOrSubSessionId, terminalId) {
   if (!existsSync3(filePath)) return null;
   return readFileSync3(filePath, "utf-8");
 }
+function appendTokenUsage(sessionId, record) {
+  const dir = sessionDir(sessionId);
+  if (!dir) return;
+  mkdirSync3(dir, { recursive: true });
+  const filePath = join5(dir, "token-usage.jsonl");
+  appendFileSync(filePath, JSON.stringify(record) + "\n");
+}
+function isSessionTokenUsage(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  if (!record || typeof record.timestamp !== "number" || !record.usage) return false;
+  if (typeof record.usage !== "object") return false;
+  const usage = record.usage;
+  return typeof usage.totalTokens === "number" && typeof usage.inputTokens === "number" && typeof usage.outputTokens === "number";
+}
+function readTokenUsage(sessionId) {
+  const dir = sessionDir(sessionId);
+  if (!dir) return [];
+  const filePath = join5(dir, "token-usage.jsonl");
+  if (!existsSync3(filePath)) return [];
+  const content = readFileSync3(filePath, "utf-8");
+  return content.split("\n").filter((line) => line.trim()).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((value) => isSessionTokenUsage(value));
+}
 var storageOps = {
   getSettings,
   updateSettings,
@@ -932,7 +1013,9 @@ var storageOps = {
   appendSessionMessage,
   readSessionMessages,
   appendTerminalOutput,
-  readTerminalOutput
+  readTerminalOutput,
+  appendTokenUsage,
+  readTokenUsage
 };
 
 // src/backend/i18n.ts
@@ -4918,7 +5001,7 @@ async function executeSubagent(params, subSessionId, taskName, taskPrompt, signa
     }
     return accumulatedText || "[No output produced]";
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorMessage2 = error instanceof Error ? error.message : String(error);
     const conn3 = params.getConnection();
     if (conn3) {
       await sendSubagentStatusUpdate(
@@ -4936,7 +5019,7 @@ async function executeSubagent(params, subSessionId, taskName, taskPrompt, signa
             sessionUpdate: "agent_message_chunk",
             content: { type: "text", text: `
 
-**Error:** ${errorMessage}` }
+**Error:** ${errorMessage2}` }
           }
         });
       }
@@ -4944,7 +5027,7 @@ async function executeSubagent(params, subSessionId, taskName, taskPrompt, signa
     if (signal.aborted) {
       return accumulatedText || "[Cancelled]";
     }
-    return accumulatedText || `[Error: ${errorMessage}]`;
+    return accumulatedText || `[Error: ${errorMessage2}]`;
   } finally {
     await closeACPClientTools(subAcp);
   }
@@ -5049,6 +5132,183 @@ Results from all sub-agents are returned when they all complete.`,
   };
 }
 
+// src/agents/token-breakdown.ts
+var _countTokens = null;
+var _formatFunctionDefinitions = null;
+async function getTokenizer() {
+  if (!_countTokens) {
+    const mod = await import("gpt-tokenizer");
+    _countTokens = mod.countTokens;
+  }
+  if (!_formatFunctionDefinitions) {
+    const mod = await import("gpt-tokenizer/esm/functionCalling");
+    _formatFunctionDefinitions = mod.formatFunctionDefinitions;
+  }
+  return {
+    countTokens: _countTokens,
+    formatFunctionDefinitions: _formatFunctionDefinitions
+  };
+}
+async function estimateToolsDefinitionTokens(tools) {
+  const { countTokens, formatFunctionDefinitions } = await getTokenizer();
+  const entries = Object.entries(tools);
+  if (entries.length === 0) {
+    return { total: 0, perTool: [] };
+  }
+  const functionDefs = entries.map(([name, tool4]) => ({
+    name,
+    description: typeof tool4.description === "string" ? tool4.description : void 0,
+    parameters: extractJsonSchema(tool4)
+  }));
+  const totalFormatted = formatFunctionDefinitions(functionDefs);
+  const total = countTokens(totalFormatted) + 9;
+  const emptyNamespaceTokens = countTokens("namespace functions {\n\n} // namespace functions");
+  const perTool = functionDefs.map((fn) => {
+    const singleFormatted = formatFunctionDefinitions([fn]);
+    const singleTotal = countTokens(singleFormatted) + 9;
+    return {
+      name: fn.name,
+      tokens: Math.max(0, singleTotal - emptyNamespaceTokens)
+    };
+  });
+  return { total, perTool };
+}
+async function estimateInputComposition(params) {
+  const { countTokens } = await getTokenizer();
+  const systemPromptTokens = countTokens(params.systemPrompt) + 3;
+  const toolsDef = await estimateToolsDefinitionTokens(params.tools);
+  const historyTokens = params.historyText ? countTokens(params.historyText) : 0;
+  const userMessageTokens = countTokens(params.userMessageText) + 3;
+  const estimatedTotal = systemPromptTokens + toolsDef.total + historyTokens + userMessageTokens + 3;
+  return {
+    systemPrompt: systemPromptTokens,
+    toolsDefinition: toolsDef,
+    history: historyTokens,
+    userMessage: userMessageTokens,
+    userMessageText: params.userMessageText,
+    estimatedTotal,
+    delta: params.actualInputTokens - estimatedTotal
+  };
+}
+function buildStepBreakdown(steps) {
+  const stepDetails = steps.map((step, idx) => {
+    const next = steps[idx + 1];
+    const usage = step.usage;
+    const toolCallEstimates = buildToolCallEstimates(step, next);
+    return {
+      stepNumber: step.stepNumber,
+      finishReason: step.finishReason,
+      inputTokens: usage.inputTokens ?? 0,
+      outputTokens: usage.outputTokens ?? 0,
+      inputDetails: {
+        cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? void 0,
+        cacheWriteTokens: usage.inputTokenDetails?.cacheWriteTokens ?? void 0,
+        noCacheTokens: usage.inputTokenDetails?.noCacheTokens ?? void 0
+      },
+      outputDetails: {
+        textTokens: usage.outputTokenDetails?.textTokens ?? void 0,
+        reasoningTokens: usage.outputTokenDetails?.reasoningTokens ?? void 0
+      },
+      toolCalls: toolCallEstimates,
+      performance: {
+        stepTimeMs: step.performance.stepTimeMs,
+        responseTimeMs: step.performance.responseTimeMs,
+        timeToFirstOutputMs: step.performance.timeToFirstOutputMs ?? void 0,
+        outputTokensPerSecond: step.performance.outputTokensPerSecond ?? void 0
+      }
+    };
+  });
+  const totalTimeMs = steps.reduce((sum, s) => sum + s.performance.stepTimeMs, 0);
+  const lastStep = steps[steps.length - 1];
+  const effectiveOutputTokensPerSecond = lastStep?.performance.effectiveOutputTokensPerSecond ?? 0;
+  return {
+    steps: stepDetails,
+    performance: { totalTimeMs, effectiveOutputTokensPerSecond }
+  };
+}
+function buildToolCallEstimates(step, next) {
+  if (step.toolCalls.length === 0) return [];
+  const usage = step.usage;
+  const outputTokens = usage.outputTokens ?? 0;
+  const textTokens = usage.outputTokenDetails?.textTokens ?? 0;
+  const reasoningTokens = usage.outputTokenDetails?.reasoningTokens ?? 0;
+  const totalToolCallOutput = Math.max(0, outputTokens - textTokens - reasoningTokens);
+  let totalToolResultInput = 0;
+  if (next) {
+    const nextInput = next.usage.inputTokens ?? 0;
+    const currentInput = usage.inputTokens ?? 0;
+    const currentOutput = usage.outputTokens ?? 0;
+    totalToolResultInput = Math.max(0, nextInput - currentInput - currentOutput);
+  }
+  const count = step.toolCalls.length;
+  const toolExecutionMs = step.performance.toolExecutionMs;
+  return step.toolCalls.map((tc) => ({
+    toolName: tc.toolName,
+    args: serializeToolCallArgs(tc.input),
+    argumentsOutputTokens: Math.round(totalToolCallOutput / count),
+    resultInputTokens: Math.round(totalToolResultInput / count),
+    executionMs: toolExecutionMs?.[tc.toolCallId] ?? void 0
+  }));
+}
+function serializeToolCallArgs(input) {
+  if (input == null) return "";
+  if (typeof input === "string") return input;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+function extractJsonSchema(tool4) {
+  const schema = tool4.inputSchema;
+  if (!schema) return void 0;
+  if (typeof schema === "object" && schema !== null && "jsonSchema" in schema) {
+    const jsonSchema = schema.jsonSchema;
+    if (typeof jsonSchema === "object" && jsonSchema !== null) {
+      return jsonSchema;
+    }
+  }
+  if (typeof schema === "object" && schema !== null && "_def" in schema) {
+    return void 0;
+  }
+  if (typeof schema === "object" && schema !== null) {
+    return schema;
+  }
+  return void 0;
+}
+function serializeMessagesForCounting(messages) {
+  const serializedMessages = [];
+  for (const msg of messages) {
+    const serializedParts = [];
+    if (typeof msg.content === "string") {
+      serializedParts.push(msg.content);
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (typeof part === "string") {
+          serializedParts.push(part);
+          continue;
+        }
+        if (part && typeof part === "object" && "text" in part) {
+          serializedParts.push(String(part.text));
+          continue;
+        }
+        if (part != null) {
+          const serializedPart = JSON.stringify(part);
+          if (serializedPart !== void 0) serializedParts.push(serializedPart);
+        }
+      }
+    } else if (msg.content != null) {
+      const serializedContent = JSON.stringify(msg.content);
+      if (serializedContent !== void 0) serializedParts.push(serializedContent);
+    }
+    if (serializedParts.length > 0) {
+      const role = msg.role ? `[${msg.role}] ` : "";
+      serializedMessages.push(`${role}${serializedParts.join("\n")}`);
+    }
+  }
+  return serializedMessages.join("\n");
+}
+
 // src/agents/openai-compatible-agent.ts
 var MODEL_CONFIG_ID = "model";
 var THOUGHT_LEVEL_CONFIG_ID = "thought_level";
@@ -5145,6 +5405,12 @@ function buildSafeUserMessage(prompt) {
 var AVAILABLE_COMMANDS = [
   { name: "compact", description: "Compress conversation context" }
 ];
+var COMPACT_PROMPT = `Compress the conversation into a structured markdown summary.
+ Include: key decisions, code changes (with file paths),
+ technical context, and pending tasks.
+ Use headings and bullet points for clarity.
+ Detect the user's commonly used language from the conversation history and respond in that language.
+ Output only the summary.`;
 var OpenaiCompatibleAgent = class {
   sessions = /* @__PURE__ */ new Map();
   provider;
@@ -5323,16 +5589,70 @@ var OpenaiCompatibleAgent = class {
       );
     }
   }
-  async pushAvailableCommands(sessionId) {
+  async pushUsageUpdate(sessionId, usageUpdate) {
+    if (!this.connection) return;
+    await this.connection.sessionUpdate({
+      sessionId,
+      update: {
+        sessionUpdate: "usage_update",
+        ...usageUpdate
+      }
+    });
+  }
+  async pushAvailableCommands(sessionId, commands) {
     if (!this.connection) return;
     await this.connection.sessionUpdate({
       sessionId,
       update: {
         sessionUpdate: "available_commands_update",
-        availableCommands: AVAILABLE_COMMANDS
+        availableCommands: commands
       }
     });
   }
+  /**
+   * Build per-turn token breakdown metadata (best-effort).
+   * Shared by normal prompts and slash commands (e.g. /compact).
+   * Must never throw — breakdown is optional metadata that must not fail the prompt.
+   */
+  async buildTokenBreakdown(params) {
+    try {
+      const stepBreakdown = buildStepBreakdown(params.steps);
+      const historyText = serializeMessagesForCounting(params.history);
+      const userMessageText = serializeMessagesForCounting([params.userMessage]);
+      const inputComposition = await estimateInputComposition({
+        systemPrompt: params.systemPrompt,
+        tools: params.tools,
+        historyText,
+        userMessageText,
+        actualInputTokens: params.steps[0]?.usage.inputTokens ?? 0
+      });
+      return {
+        stepCount: params.steps.length,
+        inputComposition,
+        steps: stepBreakdown.steps,
+        performance: stepBreakdown.performance
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(
+        `[OpenaiCompatibleAgent] Failed to build token breakdown for a prompt: ${message}`
+      );
+      return {
+        stepCount: params.steps.length,
+        inputComposition: {
+          systemPrompt: 0,
+          toolsDefinition: { total: 0, perTool: [] },
+          history: 0,
+          userMessage: 0,
+          userMessageText: "",
+          estimatedTotal: 0,
+          delta: 0
+        },
+        steps: [],
+        performance: { totalTimeMs: 0, effectiveOutputTokensPerSecond: 0 }
+      };
+    }
+  }
   async newSession(params) {
     const modelState = await this.getModels();
     const sessionId = randomUUID6();
@@ -5355,7 +5675,7 @@ var OpenaiCompatibleAgent = class {
     this.sessions.set(sessionId, session);
     await this.persistSessionState(session);
     setTimeout(() => {
-      this.pushAvailableCommands(sessionId).catch(() => {
+      this.pushAvailableCommands(sessionId, AVAILABLE_COMMANDS).catch(() => {
       });
     }, 500);
     return {
@@ -5403,21 +5723,18 @@ var OpenaiCompatibleAgent = class {
     if (!currentModelExists) {
       active.modelId = modelState.currentModelId || null;
     }
-    if (persistedState) {
-      active.contextUsedTokens = persistedState.contextUsedTokens;
-    }
-    if (this.connection) {
-      await this.connection.sessionUpdate({
-        sessionId: params.sessionId,
-        update: {
-          sessionUpdate: "usage_update",
-          used: active.contextUsedTokens,
-          size: this.contextWindowTokens
-        }
-      });
-    }
+    const contextUsageUpdate = {
+      used: persistedState?.contextUsedTokens ?? 0,
+      size: this.contextWindowTokens
+    };
+    active.contextUsedTokens = contextUsageUpdate.used;
     await this.persistSessionState(active);
-    await this.pushAvailableCommands(params.sessionId);
+    setTimeout(() => {
+      this.pushUsageUpdate(params.sessionId, contextUsageUpdate).catch(() => {
+      });
+      this.pushAvailableCommands(params.sessionId, AVAILABLE_COMMANDS).catch(() => {
+      });
+    }, 500);
     return {
       configOptions: await this.buildConfigOptions(active.modelId, active.thoughtLevel)
     };
@@ -5476,18 +5793,14 @@ var OpenaiCompatibleAgent = class {
       }
       return { stopReason: "end_turn" };
     }
+    const historyBeforeCompact = session.history.slice();
     const summaryResult = await generateText2({
       model: this.provider.chatModel(session.modelId),
       messages: [
-        ...session.history,
+        ...historyBeforeCompact,
         {
           role: "user",
-          content: `Compress the conversation into a structured markdown summary.
- Include: key decisions, code changes (with file paths),
- technical context, and pending tasks.
- Use headings and bullet points for clarity.
- Detect the user's commonly used language from the conversation history and respond in that language.
- Output only the summary.`
+          content: COMPACT_PROMPT
         }
       ],
       maxOutputTokens: 5e3
@@ -5516,18 +5829,28 @@ var OpenaiCompatibleAgent = class {
     const summaryUsage = summaryResult.finalStep.usage;
     const outputTokens = summaryUsage.outputTokens ?? 0;
     session.contextUsedTokens = outputTokens;
-    if (this.connection) {
-      await this.connection.sessionUpdate({
-        sessionId,
-        update: {
-          sessionUpdate: "usage_update",
-          used: session.contextUsedTokens,
-          size: this.contextWindowTokens
-        }
-      });
-    }
+    await this.pushUsageUpdate(sessionId, {
+      used: session.contextUsedTokens,
+      size: this.contextWindowTokens
+    });
     await this.persistSessionState(session);
-    return { stopReason: "end_turn" };
+    const tokenBreakdown = await this.buildTokenBreakdown({
+      systemPrompt: "",
+      tools: {},
+      history: historyBeforeCompact,
+      userMessage: { role: "user", content: COMPACT_PROMPT },
+      steps: summaryResult.steps
+    });
+    const usage = {
+      totalTokens: summaryUsage.totalTokens ?? 0,
+      inputTokens: summaryUsage.inputTokens ?? 0,
+      outputTokens: summaryUsage.outputTokens ?? 0,
+      thoughtTokens: summaryUsage.outputTokenDetails?.reasoningTokens,
+      cachedReadTokens: summaryUsage.inputTokenDetails?.cacheReadTokens,
+      cachedWriteTokens: summaryUsage.inputTokenDetails?.cacheWriteTokens,
+      _meta: { fello: { tokenBreakdown } }
+    };
+    return { stopReason: "end_turn", usage };
   }
   async prompt(params) {
     const session = this.sessions.get(params.sessionId);
@@ -5626,15 +5949,16 @@ var OpenaiCompatibleAgent = class {
         getModel: () => this.provider.chatModel(session.modelId),
         parentSignal: abortController.signal
       });
+      const allTools = {
+        ...sharedTools,
+        ...subagentTool,
+        ...imageAnalysisTool
+      };
       const result = streamText2({
         model: this.provider.chatModel(session.modelId),
         system: systemPrompt,
         messages: [...session.history, userMessage],
-        tools: {
-          ...sharedTools,
-          ...subagentTool,
-          ...imageAnalysisTool
-        },
+        tools: allTools,
         stopWhen: isStepCount2(128),
         abortSignal: abortController.signal,
         providerOptions: {
@@ -5690,30 +6014,38 @@ var OpenaiCompatibleAgent = class {
           });
         }
       }
-      const response = await result.response;
-      session.history.push(userMessage, ...response.messages);
-      await this.appendSessionHistory(session.id, userMessage, ...response.messages);
-      const [turnUsage, finalStep] = await Promise.all([result.usage, result.finalStep]);
+      const [turnUsage, finalStep, steps, responseMessages] = await Promise.all([
+        result.usage,
+        result.finalStep,
+        result.steps,
+        result.responseMessages
+      ]);
       const finalStepUsage = finalStep.usage;
-      session.contextUsedTokens = (finalStepUsage.inputTokens ?? 0) + (finalStepUsage.outputTokens ?? 0);
+      const contextUsedTokens = (finalStepUsage.inputTokens ?? 0) + (finalStepUsage.outputTokens ?? 0);
+      const historyBeforeTurn = session.history.slice();
+      session.history.push(userMessage, ...responseMessages);
+      await this.appendSessionHistory(session.id, userMessage, ...responseMessages);
+      session.contextUsedTokens = contextUsedTokens;
+      const tokenBreakdown = await this.buildTokenBreakdown({
+        systemPrompt,
+        tools: allTools,
+        history: historyBeforeTurn,
+        userMessage,
+        steps
+      });
       const usage = {
         totalTokens: turnUsage.totalTokens ?? 0,
         inputTokens: turnUsage.inputTokens ?? 0,
         outputTokens: turnUsage.outputTokens ?? 0,
         thoughtTokens: turnUsage.outputTokenDetails?.reasoningTokens,
         cachedReadTokens: turnUsage.inputTokenDetails?.cacheReadTokens,
-        cachedWriteTokens: turnUsage.inputTokenDetails?.cacheWriteTokens
+        cachedWriteTokens: turnUsage.inputTokenDetails?.cacheWriteTokens,
+        _meta: { fello: { tokenBreakdown } }
       };
-      if (this.connection) {
-        await this.connection.sessionUpdate({
-          sessionId: params.sessionId,
-          update: {
-            sessionUpdate: "usage_update",
-            used: session.contextUsedTokens,
-            size: this.contextWindowTokens
-          }
-        });
-      }
+      await this.pushUsageUpdate(params.sessionId, {
+        used: session.contextUsedTokens,
+        size: this.contextWindowTokens
+      });
       return {
         stopReason: "end_turn",
         usage
@@ -9246,6 +9578,11 @@ function createSessionModule(ctx, deps) {
     if (!session) throw new Error("Session does not exist");
     return { messages: notif.mergeNotifications(storage.readSessionMessages(sessionId)) };
   }
+  async function getSessionTokenUsage({ sessionId }) {
+    const session = storage.getSession(sessionId);
+    if (!session) throw new Error("Session does not exist");
+    return { records: storage.readTokenUsage(sessionId) };
+  }
   async function sendPrompt({
     sessionId,
     contents
@@ -9356,6 +9693,15 @@ function createSessionModule(ctx, deps) {
         isStreaming: false,
         ...promptResponse?.usage ? { lastTurnUsage: promptResponse.usage } : {}
       });
+      if (promptResponse?.usage?._meta) {
+        try {
+          storage.appendTokenUsage(sessionId, {
+            timestamp: Date.now(),
+            usage: promptResponse.usage
+          });
+        } catch {
+        }
+      }
       const updated2 = storage.getSession(sessionId);
       if (updated2) sendEvent("session-changed", { session: updated2 });
       const bridge = ilinkState.getBridge();
@@ -9629,6 +9975,7 @@ function createSessionModule(ctx, deps) {
     newSession,
     loadSession,
     getSessionHistory,
+    getSessionTokenUsage,
     sendPrompt,
     cancelPrompt,
     updateSession: updateSession2,
@@ -10421,13 +10768,13 @@ function createAutomationModule(ctx, deps) {
       sendEvent("task-update", { scheduleId, task });
       return task;
     } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
+      const errorMessage2 = err instanceof Error ? err.message : String(err);
       task.completedAt = Date.now();
       task.status = "error";
-      task.error = errorMessage;
+      task.error = errorMessage2;
       store.saveTask(scheduleId, task);
       sendEvent("task-update", { scheduleId, task });
-      console.error(`[Automation] Task failed:`, errorMessage);
+      console.error(`[Automation] Task failed:`, errorMessage2);
       return task;
     } finally {
       runningTasks.delete(scheduleId);
@@ -11074,7 +11421,7 @@ async function callOpenAICompatibleApi(provider, request) {
 }
 function createImageGenerationModule(ctx, deps) {
   const { storage } = ctx;
-  function getActiveProvider() {
+  function getActiveProvider2() {
     const settings = storage.getSettings();
     const provider = settings.imageGeneration?.find((p) => p.active);
     if (!provider) {
@@ -11085,7 +11432,7 @@ function createImageGenerationModule(ctx, deps) {
     return provider;
   }
   async function generateImage(sessionId, request) {
-    const provider = getActiveProvider();
+    const provider = getActiveProvider2();
     const apiResult = await callOpenAICompatibleApi(provider, request);
     const shareDir = storage.sessionShareDir(sessionId);
     if (!shareDir) throw new Error(`Session not found: ${sessionId}`);
@@ -11483,6 +11830,178 @@ function createToolboxModule(_ctx) {
   };
 }
 
+// src/backend/speech/manager.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import {
+  createASRClient
+} from "unified-realtime-asr";
+var DEFAULT_DASHSCOPE_MODEL = "fun-asr-flash-8k-realtime";
+var DEFAULT_OPENAI_MODEL = "gpt-4o-transcribe";
+function optionalString(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function required(value, name) {
+  const result = optionalString(value);
+  if (!result) throw new Error(`\u5B9E\u65F6\u8BED\u97F3\u8BC6\u522B\u914D\u7F6E\u7F3A\u5C11 ${name}\u3002`);
+  return result;
+}
+function buildOptions(provider) {
+  return {
+    language: optionalString(provider.language) ?? "zh-CN",
+    sampleRate: 16e3,
+    channels: 1,
+    format: "pcm",
+    interimResults: true,
+    punctuation: true,
+    autoReconnect: false,
+    transcriptionModel: provider.provider === "openai" ? optionalString(provider.model) ?? DEFAULT_OPENAI_MODEL : void 0
+  };
+}
+function buildConfig(provider) {
+  const options = buildOptions(provider);
+  const url = optionalString(provider.baseUrl);
+  switch (provider.provider) {
+    case "volcengine":
+      return {
+        provider: "volcengine",
+        apiKey: required(provider.apiKey, "API Key"),
+        resourceId: optionalString(provider.resourceId),
+        appId: optionalString(provider.appId),
+        url,
+        options
+      };
+    case "dashscope":
+      return {
+        provider: "dashscope",
+        apiKey: required(provider.apiKey, "API Key"),
+        model: optionalString(provider.model) ?? DEFAULT_DASHSCOPE_MODEL,
+        workspaceId: optionalString(provider.workspaceId),
+        region: provider.region,
+        workspace: optionalString(provider.workspace),
+        url,
+        options
+      };
+    case "openai":
+      return {
+        provider: "openai",
+        apiKey: required(provider.apiKey, "API Key"),
+        url,
+        options
+      };
+    case "iflytek":
+      return {
+        provider: "iflytek",
+        appId: required(provider.appId, "App ID"),
+        apiKey: required(provider.apiKey, "API Key"),
+        apiSecret: required(provider.apiSecret, "API Secret"),
+        url,
+        options
+      };
+  }
+}
+function getActiveProvider(ctx) {
+  const provider = ctx.storage.getSettings().speechToText.find((item) => item.active);
+  if (!provider) {
+    throw new Error("\u8BF7\u5148\u5728\u8BBE\u7F6E \u2192 \u8BED\u97F3\u8BC6\u522B\u4E2D\u914D\u7F6E\u5E76\u542F\u7528\u4E00\u4E2A Provider\u3002");
+  }
+  return provider;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createAsrManager(ctx) {
+  const sessions = /* @__PURE__ */ new Map();
+  const keyOf2 = (clientId, asrSessionId) => `${clientId}:${asrSessionId}`;
+  const emitError = (session, error) => {
+    ctx.sendEvent("asr-error", {
+      clientId: session.clientId,
+      asrSessionId: session.asrSessionId,
+      message: errorMessage(error)
+    });
+  };
+  const emitTranscript = (session, transcript) => {
+    ctx.sendEvent("asr-transcript", {
+      clientId: session.clientId,
+      asrSessionId: session.asrSessionId,
+      text: transcript.text,
+      isFinal: transcript.isFinal,
+      id: transcript.id,
+      index: transcript.index,
+      speaker: transcript.speaker
+    });
+  };
+  return {
+    async start(clientId, asrSessionId) {
+      const key = keyOf2(clientId, asrSessionId);
+      if (sessions.has(key)) return { ok: true };
+      const provider = getActiveProvider(ctx);
+      const client2 = createASRClient(buildConfig(provider));
+      const active = { clientId, asrSessionId, client: client2 };
+      sessions.set(key, active);
+      client2.on("transcript", (transcript) => {
+        if (sessions.get(key) === active) emitTranscript(active, transcript);
+      });
+      client2.on("error", (error) => {
+        if (sessions.get(key) === active) emitError(active, error);
+      });
+      client2.on("close", (info) => {
+        if (sessions.get(key) !== active) return;
+        sessions.delete(key);
+        ctx.sendEvent("asr-closed", {
+          clientId,
+          asrSessionId,
+          code: info?.code,
+          reason: info?.reason
+        });
+      });
+      try {
+        await client2.connect();
+        return { ok: true };
+      } catch (error) {
+        sessions.delete(key);
+        client2.removeAllListeners();
+        throw new Error(errorMessage(error));
+      }
+    },
+    frame(clientId, asrSessionId, audioB64) {
+      const active = sessions.get(keyOf2(clientId, asrSessionId));
+      if (!active) return;
+      try {
+        active.client.sendAudio(Buffer2.from(audioB64, "base64"));
+      } catch (error) {
+        emitError(active, error);
+      }
+    },
+    async stop(clientId, asrSessionId) {
+      const key = keyOf2(clientId, asrSessionId);
+      const active = sessions.get(key);
+      if (!active) return;
+      try {
+        await active.client.close();
+      } catch (error) {
+        emitError(active, error);
+      } finally {
+        if (sessions.get(key) === active) sessions.delete(key);
+        active.client.removeAllListeners();
+      }
+    },
+    async closeAll() {
+      await Promise.all(
+        Array.from(sessions.values(), async (active) => {
+          try {
+            await active.client.close();
+          } catch {
+          } finally {
+            active.client.removeAllListeners();
+          }
+        })
+      );
+      sessions.clear();
+    }
+  };
+}
+
 // src/backend/backend.ts
 function initBackend(emitter) {
   const listeners = [];
@@ -11508,6 +12027,7 @@ function initBackend(emitter) {
   const _inference = createInferenceModule(ctx, { skills, search, toolbox });
   const memory = createMemoryModule(ctx, { inference: _inference });
   const imageGeneration = createImageGenerationModule(ctx, { ilink: ilink.state });
+  const asr = createAsrManager(ctx);
   const session = createSessionModule(ctx, {
     bridgeConnect,
     askUser,
@@ -11666,6 +12186,9 @@ function initBackend(emitter) {
     async getSessionHistory(params) {
       return session.getSessionHistory(params);
     },
+    async getSessionTokenUsage(params) {
+      return session.getSessionTokenUsage(params);
+    },
     async sendPrompt(params) {
       return session.sendPrompt(params);
     },
@@ -11892,11 +12415,22 @@ function initBackend(emitter) {
     },
     async getMemorySystemFilePath({ projectId }) {
       return memory.getFilePath(projectId);
+    },
+    // Realtime ASR
+    async startRealtimeAsr({ clientId, asrSessionId }) {
+      return asr.start(clientId, asrSessionId);
+    },
+    async sendRealtimeAsrFrame({ clientId, asrSessionId, audioB64 }) {
+      asr.frame(clientId, asrSessionId, audioB64);
+    },
+    async stopRealtimeAsr({ clientId, asrSessionId }) {
+      await asr.stop(clientId, asrSessionId);
     }
   };
   webui.setHandlers(backendHandlers2);
   async function closeBackend2() {
     automation.stopAllCrons();
+    await asr.closeAll();
     webui.stop();
     await ilink.stopIlink({ logout: false });
     session.clearSession();
@@ -11912,7 +12446,7 @@ function initBackend(emitter) {
 }
 
 // package.json
-var version = "0.1.51";
+var version = "0.1.53";
 
 // src/server/main.ts
 var port;