@hybridaione/hybridclaw 0.2.3 → 0.2.7

package/container/src/ipc.ts

@@ -1,5 +1,5 @@
-import fs from 'fs';
-import path from 'path';
+import fs from 'node:fs';
+import path from 'node:path';
 
 import type { ContainerInput, ContainerOutput } from './types.js';
 
@@ -10,7 +10,9 @@ const OUTPUT_PATH = path.join(IPC_DIR, 'output.json');
 /**
  * Poll for input.json. Returns null if idle timeout expires.
  */
-export async function waitForInput(idleTimeoutMs: number): Promise<ContainerInput | null> {
+export async function waitForInput(
+  idleTimeoutMs: number,
+): Promise<ContainerInput | null> {
   const pollInterval = 200;
   const deadline = Date.now() + idleTimeoutMs;
 

package/container/src/token-usage.ts

@@ -1,7 +1,15 @@
-import type { ChatCompletionResponse, ChatMessage, TokenUsageStats } from './types.js';
+import type {
+  ChatCompletionResponse,
+  ChatMessage,
+  TokenUsageStats,
+} from './types.js';
 
 const CHARS_PER_TOKEN = 4;
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 function parseUsageNumber(value: unknown): number {
   if (typeof value === 'number' && Number.isFinite(value)) {
     return Math.max(0, Math.floor(value));
@@ -13,6 +21,24 @@ function parseUsageNumber(value: unknown): number {
   return 0;
 }
 
+function parseOptionalUsageNumber(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return Math.max(0, Math.floor(value));
+  }
+  if (typeof value === 'string' && value.trim()) {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isFinite(parsed)) return Math.max(0, parsed);
+  }
+  return undefined;
+}
+
+function firstDefined(values: unknown[]): unknown {
+  for (const value of values) {
+    if (value !== undefined && value !== null) return value;
+  }
+  return undefined;
+}
+
 export function createTokenUsageStats(): TokenUsageStats {
   return {
     modelCalls: 0,
@@ -20,6 +46,9 @@ export function createTokenUsageStats(): TokenUsageStats {
     apiPromptTokens: 0,
     apiCompletionTokens: 0,
     apiTotalTokens: 0,
+    apiCacheUsageAvailable: false,
+    apiCacheReadTokens: 0,
+    apiCacheWriteTokens: 0,
     estimatedPromptTokens: 0,
     estimatedCompletionTokens: 0,
     estimatedTotalTokens: 0,
@@ -56,7 +85,8 @@ export function estimateMessageTokens(messages: ChatMessage[]): number {
     total += 4;
     total += estimateTextTokens(message.role);
     total += estimateTextTokens(normalizeContentText(message.content));
-    if (message.tool_calls) total += estimateTextTokens(JSON.stringify(message.tool_calls));
+    if (message.tool_calls)
+      total += estimateTextTokens(JSON.stringify(message.tool_calls));
     if (message.tool_call_id) total += estimateTextTokens(message.tool_call_id);
   }
   return total;
@@ -68,30 +98,89 @@ export function accumulateApiUsage(
 ): void {
   const usage = response.usage;
   if (!usage) return;
+  const usageRecord = isRecord(usage) ? (usage as Record<string, unknown>) : {};
+
+  const hasTokenUsageFields =
+    usage.prompt_tokens != null ||
+    usage.completion_tokens != null ||
+    usage.total_tokens != null ||
+    usage.input_tokens != null ||
+    usage.output_tokens != null ||
+    usageRecord.promptTokens != null ||
+    usageRecord.completionTokens != null ||
+    usageRecord.totalTokens != null ||
+    usageRecord.inputTokens != null ||
+    usageRecord.outputTokens != null;
+  const promptTokenDetails = isRecord(usage.prompt_tokens_details)
+    ? usage.prompt_tokens_details
+    : null;
+  const cacheReadTokens = parseOptionalUsageNumber(
+    firstDefined([
+      usageRecord.cacheRead,
+      usageRecord.cache_read,
+      usageRecord.cacheReadTokens,
+      usage.cache_read_tokens,
+      usageRecord.cacheReadInputTokens,
+      usage.cache_read_input_tokens,
+      usageRecord.cached_tokens,
+      usage.cached_tokens,
+      promptTokenDetails?.cached_tokens,
+    ]),
+  );
+  const cacheWriteTokens = parseOptionalUsageNumber(
+    firstDefined([
+      usageRecord.cacheWrite,
+      usageRecord.cache_write,
+      usageRecord.cacheWriteTokens,
+      usage.cache_write_tokens,
+      usageRecord.cacheWriteInputTokens,
+      usage.cache_write_input_tokens,
+      usage.cache_creation_input_tokens,
+    ]),
+  );
+  const hasCacheUsageFields =
+    cacheReadTokens !== undefined || cacheWriteTokens !== undefined;
+  if (!hasTokenUsageFields && !hasCacheUsageFields) return;
 
-  const hasUsageFields =
-    usage.prompt_tokens != null
-    || usage.completion_tokens != null
-    || usage.total_tokens != null
-    || usage.input_tokens != null
-    || usage.output_tokens != null;
-  if (!hasUsageFields) return;
-
-  const promptTokens = parseUsageNumber(usage.prompt_tokens ?? usage.input_tokens);
-  const completionTokens = parseUsageNumber(usage.completion_tokens ?? usage.output_tokens);
-  let totalTokens = parseUsageNumber(usage.total_tokens);
+  const promptTokens = parseUsageNumber(
+    firstDefined([
+      usage.prompt_tokens,
+      usage.input_tokens,
+      usageRecord.promptTokens,
+      usageRecord.inputTokens,
+    ]),
+  );
+  const completionTokens = parseUsageNumber(
+    firstDefined([
+      usage.completion_tokens,
+      usage.output_tokens,
+      usageRecord.completionTokens,
+      usageRecord.outputTokens,
+    ]),
+  );
+  let totalTokens = parseUsageNumber(
+    firstDefined([usage.total_tokens, usageRecord.totalTokens]),
+  );
   if (totalTokens === 0 && (promptTokens > 0 || completionTokens > 0)) {
     totalTokens = promptTokens + completionTokens;
   }
 
-  stats.apiUsageAvailable = true;
-  stats.apiPromptTokens += promptTokens;
-  stats.apiCompletionTokens += completionTokens;
-  stats.apiTotalTokens += totalTokens;
+  if (hasTokenUsageFields) {
+    stats.apiUsageAvailable = true;
+    stats.apiPromptTokens += promptTokens;
+    stats.apiCompletionTokens += completionTokens;
+    stats.apiTotalTokens += totalTokens;
+  }
+  if (hasCacheUsageFields) {
+    stats.apiCacheUsageAvailable = true;
+    stats.apiCacheReadTokens += cacheReadTokens ?? 0;
+    stats.apiCacheWriteTokens += cacheWriteTokens ?? 0;
+  }
 }
 
 export function finalizeTokenUsage(stats: TokenUsageStats): TokenUsageStats {
-  const estimatedTotalTokens = stats.estimatedPromptTokens + stats.estimatedCompletionTokens;
+  const estimatedTotalTokens =
+    stats.estimatedPromptTokens + stats.estimatedCompletionTokens;
   let apiTotalTokens = stats.apiTotalTokens;
   if (stats.apiUsageAvailable && apiTotalTokens === 0) {
     apiTotalTokens = stats.apiPromptTokens + stats.apiCompletionTokens;