@cloudcli-ai/cloudcli 1.36.2 → 1.37.0

package/server/modules/providers/services/provider-models.service.ts

@@ -2,27 +2,32 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
+import { sessionsDb } from '@/modules/database/index.js';
 import { providerRegistry } from '@/modules/providers/provider.registry.js';
 import type { IProvider } from '@/shared/interfaces.js';
 import type {
   LLMProvider,
-  ProviderChangeActiveModelInput,
   ProviderCurrentActiveModel,
   ProviderModelsCacheInfo,
   ProviderModelsDefinition,
   ProviderModelsResult,
-  ProviderSessionActiveModelChange,
+  ProviderSessionModel,
 } from '@/shared/types.js';
-import { readProviderSessionActiveModelChange } from '@/shared/utils.js';
 
 export const PROVIDER_MODELS_CACHE_TTL_MS = 3 * 24 * 60 * 60 * 1000;
 const PROVIDER_MODELS_CACHE_VERSION = 2;
 const UNCACHED_PROVIDERS = new Set<LLMProvider>(['claude']);
 
+/** Session-row access the service needs, narrowed so tests can stub it. */
+type ProviderModelsSessionStore = {
+  getSessionById(sessionId: string): { model: string | null } | null;
+  setSessionModel(sessionId: string, model: string): void;
+};
+
 type ProviderModelsServiceDependencies = {
   resolveProvider?: (provider: LLMProvider) => Pick<IProvider, 'models'>;
   cachePath?: string;
-  activeModelChangesPath?: string;
+  sessions?: ProviderModelsSessionStore;
   now?: () => number;
 };
 
@@ -137,7 +142,7 @@ const writeProviderModelsCacheFile = async (
 export const createProviderModelsService = (dependencies: ProviderModelsServiceDependencies = {}) => {
   const resolveProvider = dependencies.resolveProvider ?? providerRegistry.resolveProvider;
   const cachePath = dependencies.cachePath ?? getProviderModelsCachePath();
-  const activeModelChangesPath = dependencies.activeModelChangesPath;
+  const sessions = dependencies.sessions ?? sessionsDb;
   const now = dependencies.now ?? (() => Date.now());
   const memoryCache = new Map<LLMProvider, ProviderModelsCacheEntry>();
   const pendingRequests = new Map<LLMProvider, Promise<ProviderModelsResult>>();
@@ -308,34 +313,138 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
     sessionId?: string,
   ): Promise<ProviderCurrentActiveModel> => resolveProvider(provider).models.getCurrentActiveModel(sessionId);
 
-  const changeActiveModel = async (
-    provider: LLMProvider,
-    input: ProviderChangeActiveModelInput,
-  ): Promise<ProviderSessionActiveModelChange> => resolveProvider(provider).models.changeActiveModel(input);
+  const readRecordedSessionModel = (sessionId: string): string | null => {
+    const session = sessions.getSessionById(sessionId);
+    return session?.model?.trim() || null;
+  };
 
-  const getChangedActiveModel = async (
+  /**
+   * Records the model one session runs with.
+   *
+   * Called from the active-model route when the user picks a model and from
+   * `chat.send` on every turn, so the row always matches what the session last
+   * ran with. Sessions the app has not created yet (no row) are ignored rather
+   * than treated as an error: the client keeps its own pending selection and
+   * the value lands on the row with the first send.
+   */
+  const setSessionModel = (
     provider: LLMProvider,
     sessionId: string,
-  ): Promise<ProviderSessionActiveModelChange> => readProviderSessionActiveModelChange(provider, sessionId, {
-    filePath: activeModelChangesPath,
-  });
+    model: string,
+  ): ProviderSessionModel | null => {
+    const normalizedSessionId = sessionId.trim();
+    const normalizedModel = model.trim();
+    if (!normalizedSessionId || !normalizedModel) {
+      return null;
+    }
+
+    if (!sessions.getSessionById(normalizedSessionId)) {
+      return null;
+    }
+
+    sessions.setSessionModel(normalizedSessionId, normalizedModel);
+    return {
+      provider,
+      sessionId: normalizedSessionId,
+      model: normalizedModel,
+      source: 'session',
+    };
+  };
+
+  /**
+   * Answers "which model is this session using?" for every display surface.
+   *
+   * Precedence, highest first:
+   *   1. the model recorded on the session row — the user's pick, or whatever
+   *      the last send used;
+   *   2. the provider's own session state, for sessions started outside the app
+   *      that we have never recorded a model for;
+   *   3. `requestedModel`, the client's current default, for a chat that has no
+   *      session yet;
+   *   4. the provider catalog default.
+   */
+  const resolveSessionModel = async (
+    provider: LLMProvider,
+    options: { sessionId?: string | null; requestedModel?: string | null } = {},
+  ): Promise<ProviderSessionModel> => {
+    const normalizedSessionId = typeof options.sessionId === 'string' ? options.sessionId.trim() : '';
+    const normalizedRequestedModel = typeof options.requestedModel === 'string'
+      ? options.requestedModel.trim()
+      : '';
+
+    if (normalizedSessionId) {
+      const recordedModel = readRecordedSessionModel(normalizedSessionId);
+      if (recordedModel) {
+        return {
+          provider,
+          sessionId: normalizedSessionId,
+          model: recordedModel,
+          source: 'session',
+        };
+      }
 
+      // Never sent on through the app. Ask the provider what its own session
+      // state says before falling back to anything client-supplied.
+      const catalog = (await getProviderModels(provider)).models;
+      const providerModel = await getCurrentActiveModel(provider, normalizedSessionId);
+      const resolvedProviderModel = providerModel.model?.trim();
+      if (resolvedProviderModel && resolvedProviderModel !== catalog.DEFAULT) {
+        return {
+          provider,
+          sessionId: normalizedSessionId,
+          model: resolvedProviderModel,
+          source: 'provider',
+        };
+      }
+
+      return {
+        provider,
+        sessionId: normalizedSessionId,
+        model: normalizedRequestedModel || catalog.DEFAULT,
+        source: normalizedRequestedModel ? 'session' : 'default',
+      };
+    }
+
+    if (normalizedRequestedModel) {
+      return {
+        provider,
+        sessionId: null,
+        model: normalizedRequestedModel,
+        source: 'session',
+      };
+    }
+
+    const catalog = (await getProviderModels(provider)).models;
+    return {
+      provider,
+      sessionId: null,
+      model: catalog.DEFAULT,
+      source: 'default',
+    };
+  };
+
+  /**
+   * Picks the model one run should use, for provider runtime adapters.
+   *
+   * Deliberately narrower than `resolveSessionModel`: the provider's own
+   * session state is not consulted here. Codex reports a global config value
+   * from `getCurrentActiveModel`, which would silently override the model the
+   * user picked in the composer on every single run.
+   */
   const resolveResumeModel = async (
     provider: LLMProvider,
     sessionId: string | undefined,
     requestedModel?: string | null,
   ): Promise<string | undefined> => {
+    void provider;
     const normalizedRequestedModel = typeof requestedModel === 'string' ? requestedModel.trim() : '';
-    if (!sessionId?.trim()) {
+    const normalizedSessionId = sessionId?.trim();
+    if (!normalizedSessionId) {
       return normalizedRequestedModel || undefined;
     }
 
-    const changedModel = await getChangedActiveModel(provider, sessionId);
-    if (changedModel.supported && changedModel.changed && changedModel.model?.trim()) {
-      return changedModel.model.trim();
-    }
-
-    return normalizedRequestedModel || undefined;
+    const recordedModel = readRecordedSessionModel(normalizedSessionId);
+    return recordedModel || normalizedRequestedModel || undefined;
   };
 
   const clearCache = (): void => {
@@ -347,9 +456,8 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
 
   return {
     getProviderModels,
-    getCurrentActiveModel,
-    getChangedActiveModel,
-    changeActiveModel,
+    setSessionModel,
+    resolveSessionModel,
     resolveResumeModel,
     clearCache,
   };

package/server/modules/providers/services/provider-runtime.service.ts

@@ -0,0 +1,109 @@
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import { providerModelsService } from '@/modules/providers/services/provider-models.service.js';
+import { sessionsService } from '@/modules/providers/services/sessions.service.js';
+import type { IProvider } from '@/shared/interfaces.js';
+import type {
+  AnyRecord,
+  LLMProvider,
+  ProviderPermissionDecision,
+  ProviderRunFunction,
+  ProviderRuntimeContext,
+  ProviderRuntimeWriter,
+} from '@/shared/types.js';
+
+type ProviderRuntimeServiceDependencies = {
+  listProviders(): IProvider[];
+  resolveProvider(provider: string): IProvider;
+  resolveProviderSessionId(sessionId: string | null | undefined): string | null;
+  resolveResumeModel(
+    provider: LLMProvider,
+    sessionId: string | undefined,
+    requestedModel?: string | null,
+  ): Promise<string | undefined>;
+  getProviderModels: typeof providerModelsService.getProviderModels;
+};
+
+const defaultDependencies: ProviderRuntimeServiceDependencies = {
+  listProviders: () => providerRegistry.listProviders(),
+  resolveProvider: (provider) => providerRegistry.resolveProvider(provider),
+  resolveProviderSessionId: (sessionId) => sessionsService.resolveProviderSessionId(sessionId),
+  resolveResumeModel: (provider, sessionId, requestedModel) =>
+    providerModelsService.resolveResumeModel(provider, sessionId, requestedModel),
+  getProviderModels: (provider, options) => providerModelsService.getProviderModels(provider, options),
+};
+
+/**
+ * Creates the application-facing provider runtime dispatcher.
+ *
+ * The provider registry owns each concrete runtime. This service supplies the
+ * registry-backed model/session lookups at execution time so runtime adapters
+ * never import services that resolve back through the registry.
+ */
+export function createProviderRuntimeService(
+  dependencyOverrides: Partial<ProviderRuntimeServiceDependencies> = {},
+) {
+  const dependencies = { ...defaultDependencies, ...dependencyOverrides };
+
+  const createRuntimeContext = (
+    provider: IProvider,
+  ): ProviderRuntimeContext => ({
+    resolveProviderSessionId: dependencies.resolveProviderSessionId,
+    resolveResumeModel: (sessionId, requestedModel) =>
+      dependencies.resolveResumeModel(provider.id, sessionId, requestedModel),
+    getProviderModels: async () =>
+      (await dependencies.getProviderModels(provider.id)).models,
+    normalizeMessage: (raw, sessionId) => provider.sessions.normalizeMessage(raw, sessionId),
+    async isProviderInstalled() {
+      try {
+        return (await provider.auth.getStatus()).installed;
+      } catch {
+        // Preserve the runtime's original error when installation probing fails.
+        return true;
+      }
+    },
+  });
+
+  const run = (
+    providerName: LLMProvider,
+    command: string,
+    options: AnyRecord,
+    writer: ProviderRuntimeWriter,
+  ): Promise<unknown> => {
+    const provider = dependencies.resolveProvider(providerName);
+    return provider.runtime.run(command, options, writer, createRuntimeContext(provider));
+  };
+
+  return {
+    run,
+
+    hasRuntime(providerName: string): boolean {
+      try {
+        return Boolean(dependencies.resolveProvider(providerName).runtime);
+      } catch {
+        return false;
+      }
+    },
+
+    getRunner(provider: LLMProvider): ProviderRunFunction {
+      return (command, options, writer) => run(provider, command, options, writer);
+    },
+
+    async abort(providerName: LLMProvider, sessionId: string): Promise<boolean> {
+      return Boolean(await dependencies.resolveProvider(providerName).runtime.abort(sessionId));
+    },
+
+    resolveToolApproval(requestId: string, decision: ProviderPermissionDecision): void {
+      for (const provider of dependencies.listProviders()) {
+        provider.runtime.permissions?.resolve(requestId, decision);
+      }
+    },
+
+    getPendingApprovalsForSession(sessionId: string): unknown[] {
+      return dependencies.listProviders().flatMap(
+        (provider) => provider.runtime.permissions?.listPending(sessionId) ?? [],
+      );
+    },
+  };
+}
+
+export const providerRuntimeService = createProviderRuntimeService();

package/server/modules/providers/services/provider-token-usage.service.ts

@@ -0,0 +1,357 @@
+import fsSync, { type Dirent } from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import Database from 'better-sqlite3';
+
+import { sessionsDb } from '@/modules/database/index.js';
+import type { AnyRecord } from '@/shared/types.js';
+import { AppError, getOpenCodeDatabasePath } from '@/shared/utils.js';
+
+type SessionRow = NonNullable<ReturnType<typeof sessionsDb.getSessionById>>;
+
+type ProviderTokenUsageServiceDependencies = {
+  getSessionById: (sessionId: string) => SessionRow | null | undefined;
+  getHomeDirectory: () => string;
+  getOpenCodeDatabasePath: () => string;
+  fileExists: (filePath: string) => boolean;
+  readDirectory: (directoryPath: string) => Promise<Dirent[]>;
+  readTextFile: (filePath: string) => Promise<string>;
+  getClaudeContextWindow: () => string | undefined;
+};
+
+type TokenUsageResult = {
+  used: number;
+  total?: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens?: number;
+  cacheCreationTokens?: number;
+  cacheTokens?: number;
+  breakdown: {
+    input: number;
+    output: number;
+  };
+  unsupported?: boolean;
+  message?: string;
+};
+
+type OpenCodeTokenRow = {
+  inputTokens: number | null;
+  outputTokens: number | null;
+  reasoningTokens: number | null;
+  cacheReadTokens: number | null;
+  cacheWriteTokens: number | null;
+};
+
+const defaultDependencies: ProviderTokenUsageServiceDependencies = {
+  getSessionById: (sessionId) => sessionsDb.getSessionById(sessionId),
+  getHomeDirectory: () => os.homedir(),
+  getOpenCodeDatabasePath,
+  fileExists: (filePath) => fsSync.existsSync(filePath),
+  readDirectory: (directoryPath) => fsp.readdir(directoryPath, { withFileTypes: true }),
+  readTextFile: (filePath) => fsp.readFile(filePath, 'utf8'),
+  getClaudeContextWindow: () => process.env.CONTEXT_WINDOW,
+};
+
+function readUsageNumber(value: unknown): number {
+  const parsedValue = Number(value);
+  return Number.isFinite(parsedValue) ? parsedValue : 0;
+}
+
+async function findCodexSessionFile(
+  directoryPath: string,
+  providerSessionId: string,
+  dependencies: ProviderTokenUsageServiceDependencies,
+): Promise<string | null> {
+  let entries: Dirent[];
+  try {
+    entries = await dependencies.readDirectory(directoryPath);
+  } catch {
+    // Codex session folders are date-partitioned and can disappear while a
+    // cleanup is running. An unreadable branch is simply not a match.
+    return null;
+  }
+
+  for (const entry of entries) {
+    const entryPath = path.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      const nestedMatch = await findCodexSessionFile(entryPath, providerSessionId, dependencies);
+      if (nestedMatch) {
+        return nestedMatch;
+      }
+      continue;
+    }
+
+    if (entry.name.includes(providerSessionId) && entry.name.endsWith('.jsonl')) {
+      return entryPath;
+    }
+  }
+
+  return null;
+}
+
+function readCodexTokenUsage(fileContent: string): TokenUsageResult {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let totalTokens = 0;
+  let contextWindow = 200_000;
+  const lines = fileContent.trim().split('\n');
+
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const entry = JSON.parse(lines[index]) as AnyRecord;
+      const tokenInfo = entry.type === 'event_msg' && entry.payload?.type === 'token_count'
+        ? entry.payload.info
+        : null;
+      if (!tokenInfo) {
+        continue;
+      }
+
+      if (tokenInfo.total_token_usage) {
+        inputTokens = readUsageNumber(tokenInfo.total_token_usage.input_tokens);
+        outputTokens = readUsageNumber(tokenInfo.total_token_usage.output_tokens);
+        totalTokens = readUsageNumber(tokenInfo.total_token_usage.total_tokens)
+          || inputTokens + outputTokens;
+      }
+      contextWindow = readUsageNumber(tokenInfo.model_context_window) || contextWindow;
+      break;
+    } catch {
+      // A provider may be writing the last JSONL line while this read happens.
+    }
+  }
+
+  return {
+    used: totalTokens,
+    total: contextWindow,
+    inputTokens,
+    outputTokens,
+    breakdown: { input: inputTokens, output: outputTokens },
+  };
+}
+
+function readClaudeTokenUsage(fileContent: string, configuredContextWindow: string | undefined): TokenUsageResult {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheCreationTokens = 0;
+  const lines = fileContent.trim().split('\n');
+
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const entry = JSON.parse(lines[index]) as AnyRecord;
+      const usage = entry.type === 'assistant' ? entry.message?.usage : null;
+      if (!usage) {
+        continue;
+      }
+
+      const directInputTokens = readUsageNumber(usage.input_tokens ?? usage.inputTokens);
+      cacheReadTokens = readUsageNumber(
+        usage.cache_read_input_tokens ?? usage.cacheReadInputTokens ?? usage.cacheReadTokens,
+      );
+      cacheCreationTokens = readUsageNumber(
+        usage.cache_creation_input_tokens
+          ?? usage.cacheCreationInputTokens
+          ?? usage.cacheCreationTokens,
+      );
+      inputTokens = directInputTokens + cacheReadTokens + cacheCreationTokens;
+      outputTokens = readUsageNumber(usage.output_tokens ?? usage.outputTokens);
+      break;
+    } catch {
+      // Skip malformed lines without discarding usage from earlier messages.
+    }
+  }
+
+  const parsedContextWindow = Number.parseInt(configuredContextWindow ?? '', 10);
+  const contextWindow = Number.isFinite(parsedContextWindow) ? parsedContextWindow : 160_000;
+  const cacheTokens = cacheReadTokens + cacheCreationTokens;
+
+  return {
+    used: inputTokens + outputTokens,
+    total: contextWindow,
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheCreationTokens,
+    cacheTokens,
+    breakdown: { input: inputTokens, output: outputTokens },
+  };
+}
+
+function readOpenCodeTokenUsage(databasePath: string, providerSessionId: string): TokenUsageResult {
+  const database = new Database(databasePath, { readonly: true, fileMustExist: true });
+  try {
+    const columns = database.prepare('PRAGMA table_info(session)').all() as Array<{ name: string }>;
+    const columnNames = new Set(columns.map((column) => column.name));
+    const requiredColumns = [
+      'tokens_input',
+      'tokens_output',
+      'tokens_reasoning',
+      'tokens_cache_read',
+      'tokens_cache_write',
+    ];
+
+    if (!requiredColumns.every((column) => columnNames.has(column))) {
+      return {
+        used: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        breakdown: { input: 0, output: 0 },
+        unsupported: true,
+        message: 'Token usage tracking is not available in this OpenCode database schema',
+      };
+    }
+
+    const row = database.prepare(`
+      SELECT
+        tokens_input AS inputTokens,
+        tokens_output AS outputTokens,
+        tokens_reasoning AS reasoningTokens,
+        tokens_cache_read AS cacheReadTokens,
+        tokens_cache_write AS cacheWriteTokens
+      FROM session
+      WHERE id = ?
+    `).get(providerSessionId) as OpenCodeTokenRow | undefined;
+
+    if (!row) {
+      throw new AppError('OpenCode session was not found.', {
+        code: 'OPENCODE_SESSION_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    const inputTokens = readUsageNumber(row.inputTokens) + readUsageNumber(row.cacheReadTokens);
+    const outputTokens = readUsageNumber(row.outputTokens);
+    const used = readUsageNumber(row.inputTokens)
+      + outputTokens
+      + readUsageNumber(row.reasoningTokens)
+      + readUsageNumber(row.cacheReadTokens)
+      + readUsageNumber(row.cacheWriteTokens);
+
+    return {
+      used,
+      inputTokens,
+      outputTokens,
+      breakdown: { input: inputTokens, output: outputTokens },
+    };
+  } finally {
+    database.close();
+  }
+}
+
+/**
+ * Creates the provider token-usage service used by the provider routes. The
+ * provider test suite supplies isolated filesystem and session dependencies so
+ * every calculator can be exercised without touching a developer's real data.
+ */
+export function createProviderTokenUsageService(
+  dependencyOverrides: Partial<ProviderTokenUsageServiceDependencies> = {},
+) {
+  const dependencies = { ...defaultDependencies, ...dependencyOverrides };
+
+  return {
+    /**
+     * Resolves all provider-specific storage details from one app-facing
+     * session id, then returns the latest usage snapshot for that provider.
+     */
+    async getSessionTokenUsage(sessionId: string): Promise<TokenUsageResult> {
+      const session = dependencies.getSessionById(sessionId);
+      if (!session) {
+        throw new AppError(`Session "${sessionId}" was not found.`, {
+          code: 'SESSION_NOT_FOUND',
+          statusCode: 404,
+        });
+      }
+
+      const providerSessionId = session.provider_session_id || sessionId;
+
+      if (session.provider === 'cursor') {
+        return {
+          used: 0,
+          total: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          breakdown: { input: 0, output: 0 },
+          unsupported: true,
+          message: 'Token usage tracking not available for Cursor sessions',
+        };
+      }
+
+      if (session.provider === 'opencode') {
+        const databasePath = dependencies.getOpenCodeDatabasePath();
+        if (!dependencies.fileExists(databasePath)) {
+          throw new AppError('OpenCode database was not found.', {
+            code: 'OPENCODE_DATABASE_NOT_FOUND',
+            statusCode: 404,
+          });
+        }
+
+        return readOpenCodeTokenUsage(databasePath, providerSessionId);
+      }
+
+      if (session.provider === 'codex') {
+        const indexedFilePath = session.jsonl_path && dependencies.fileExists(session.jsonl_path)
+          ? session.jsonl_path
+          : null;
+        const sessionFilePath = indexedFilePath ?? await findCodexSessionFile(
+          path.join(dependencies.getHomeDirectory(), '.codex', 'sessions'),
+          providerSessionId,
+          dependencies,
+        );
+
+        if (!sessionFilePath) {
+          throw new AppError(`Codex session file for "${sessionId}" was not found.`, {
+            code: 'CODEX_SESSION_FILE_NOT_FOUND',
+            statusCode: 404,
+          });
+        }
+
+        const fileContent = await dependencies.readTextFile(sessionFilePath);
+        return readCodexTokenUsage(fileContent);
+      }
+
+      let sessionFilePath = session.jsonl_path;
+      if (!sessionFilePath) {
+        if (!session.project_path) {
+          throw new AppError(`Session file for "${sessionId}" was not found.`, {
+            code: 'SESSION_FILE_NOT_FOUND',
+            statusCode: 404,
+          });
+        }
+
+        const encodedProjectPath = session.project_path.replace(/[^a-zA-Z0-9-]/g, '-');
+        const projectDirectory = path.join(
+          dependencies.getHomeDirectory(),
+          '.claude',
+          'projects',
+          encodedProjectPath,
+        );
+        sessionFilePath = path.join(projectDirectory, `${providerSessionId}.jsonl`);
+
+        const relativePath = path.relative(path.resolve(projectDirectory), path.resolve(sessionFilePath));
+        if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+          throw new AppError('Resolved session path is invalid.', {
+            code: 'INVALID_SESSION_PATH',
+            statusCode: 400,
+          });
+        }
+      }
+
+      if (!dependencies.fileExists(sessionFilePath)) {
+        throw new AppError(`Session file for "${sessionId}" was not found.`, {
+          code: 'SESSION_FILE_NOT_FOUND',
+          statusCode: 404,
+        });
+      }
+
+      const fileContent = await dependencies.readTextFile(sessionFilePath);
+      return readClaudeTokenUsage(fileContent, dependencies.getClaudeContextWindow());
+    },
+  };
+}
+
+/**
+ * Used by the provider routes to serve token usage from only an app session id.
+ */
+export const providerTokenUsageService = createProviderTokenUsageService();

package/server/modules/providers/services/sessions-watcher.service.ts

@@ -36,6 +36,8 @@ const WATCHER_IGNORED_PATTERNS = [
   '**/.git/**',
   '**/dist/**',
   '**/build/**',
+  '**/subagents/**',
+  '**/tool-results/**',
   '**/*.tmp',
   '**/*.swp',
   '**/.DS_Store',