@zythum02/fello-server 0.1.51 → 0.1.52

package/out/server/main.js

@@ -913,6 +913,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 +961,9 @@ var storageOps = {
   appendSessionMessage,
   readSessionMessages,
   appendTerminalOutput,
-  readTerminalOutput
+  readTerminalOutput,
+  appendTokenUsage,
+  readTokenUsage
 };
 
 // src/backend/i18n.ts
@@ -5049,6 +5080,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 +5353,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 +5537,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 +5623,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 +5671,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 +5741,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 +5777,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 +5897,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 +5962,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 +9526,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 +9641,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 +9923,7 @@ function createSessionModule(ctx, deps) {
     newSession,
     loadSession,
     getSessionHistory,
+    getSessionTokenUsage,
     sendPrompt,
     cancelPrompt,
     updateSession: updateSession2,
@@ -11666,6 +11961,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);
     },
@@ -11912,7 +12210,7 @@ function initBackend(emitter) {
 }
 
 // package.json
-var version = "0.1.51";
+var version = "0.1.52";
 
 // src/server/main.ts
 var port;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zythum02/fello-server",
-  "version": "0.1.51",
+  "version": "0.1.52",
   "description": "Fello Server — standalone headless AI agent server",
   "type": "module",
   "bin": {
@@ -26,6 +26,7 @@
     "es-toolkit": "^1.50.0",
     "fuse.js": "^7.5.0",
     "globby": "^16.2.3",
+    "gpt-tokenizer": "^4.0.0",
     "i18next": "^26.3.6",
     "launch-editor": "^2.14.1",
     "mime-types": "^3.0.2",