wind-agent-cli 1.37.2 → 1.37.3

package/server/modules/providers/tests/provider-runtime.service.test.ts

@@ -1,138 +1,138 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { providerRegistry } from '@/modules/providers/provider.registry.js';
-import { createProviderRuntimeService } from '@/modules/providers/services/provider-runtime.service.js';
-import type { IProvider, IProviderRuntime } from '@/shared/interfaces.js';
-import type { LLMProvider } from '@/shared/types.js';
-
-function createRuntime(overrides: Partial<IProviderRuntime> = {}): IProviderRuntime {
-  return {
-    async run() {
-      return undefined;
-    },
-    abort() {
-      return false;
-    },
-    ...overrides,
-  };
-}
-
-function createProvider(id: LLMProvider, runtime: IProviderRuntime): IProvider {
-  return {
-    id,
-    runtime,
-    auth: {
-      async getStatus() {
-        return {
-          provider: id,
-          installed: true,
-          authenticated: true,
-          method: 'test',
-          details: {},
-        };
-      },
-    },
-    sessions: {
-      normalizeMessage(raw: unknown, sessionId: string | null) {
-        return [{ kind: 'assistant', content: String(raw), sessionId, provider: id }];
-      },
-      async fetchHistory() {
-        return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
-      },
-    },
-  } as unknown as IProvider;
-}
-
-function createService(providers: IProvider[]) {
-  const providerMap = new Map(providers.map((provider) => [provider.id, provider]));
-  return createProviderRuntimeService({
-    listProviders: () => providers,
-    resolveProvider(providerName) {
-      const provider = providerMap.get(providerName as LLMProvider);
-      if (!provider) {
-        throw new Error(`Missing provider: ${providerName}`);
-      }
-      return provider;
-    },
-    resolveProviderSessionId: (sessionId) => sessionId ? `native-${sessionId}` : null,
-    async resolveResumeModel(_provider, _sessionId, requestedModel) {
-      return requestedModel?.trim() || undefined;
-    },
-    async getProviderModels() {
-      return {
-        OPTIONS: [],
-        DEFAULT: 'default-model',
-      };
-    },
-  });
-}
-
-test('providerRegistry owns one runtime for every registered provider', () => {
-  const providers = providerRegistry.listProviders();
-
-  assert.deepEqual(providers.map((provider) => provider.id), [
-    'claude',
-    'codex',
-    'cursor',
-    'opencode',
-  ]);
-  assert.equal(providers.every((provider) => typeof provider.runtime.run === 'function'), true);
-  assert.equal(providers.every((provider) => typeof provider.runtime.abort === 'function'), true);
-});
-
-test('dispatches runs and aborts through the runtime owned by providerRegistry', async () => {
-  const calls: unknown[][] = [];
-  const runtime = createRuntime({
-    async run(command, options, writer, context) {
-      calls.push(['run', command, options, writer]);
-      assert.equal(context.resolveProviderSessionId('session-1'), 'native-session-1');
-      assert.equal(await context.resolveResumeModel('session-1', 'sonnet'), 'sonnet');
-      assert.deepEqual(await context.getProviderModels(), { OPTIONS: [], DEFAULT: 'default-model' });
-      assert.equal(context.normalizeMessage('hello', 'session-1')[0]?.provider, 'claude');
-      assert.equal(await context.isProviderInstalled(), true);
-      return 'complete';
-    },
-    async abort(sessionId) {
-      calls.push(['abort', sessionId]);
-      return true;
-    },
-  });
-  const service = createService([createProvider('claude', runtime)]);
-  const writer = { send() {} };
-
-  assert.equal(service.hasRuntime('claude'), true);
-  assert.equal(service.hasRuntime('unknown'), false);
-  assert.equal(await service.getRunner('claude')('hello', { model: 'sonnet' }, writer), 'complete');
-  assert.equal(await service.abort('claude', 'session-1'), true);
-  assert.deepEqual(calls, [
-    ['run', 'hello', { model: 'sonnet' }, writer],
-    ['abort', 'session-1'],
-  ]);
-});
-
-test('routes permission decisions through provider-owned runtime capabilities', () => {
-  const decisions: unknown[][] = [];
-  const claudeRuntime = createRuntime({
-    permissions: {
-      resolve(requestId, decision) {
-        decisions.push([requestId, decision]);
-      },
-      listPending(sessionId) {
-        return [{ requestId: 'request-1', sessionId }];
-      },
-    },
-  });
-  const service = createService([
-    createProvider('claude', claudeRuntime),
-    createProvider('cursor', createRuntime()),
-  ]);
-  const decision = { allow: true, message: 'approved' };
-
-  service.resolveToolApproval('request-1', decision);
-
-  assert.deepEqual(decisions, [['request-1', decision]]);
-  assert.deepEqual(service.getPendingApprovalsForSession('session-1'), [
-    { requestId: 'request-1', sessionId: 'session-1' },
-  ]);
-});
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import { createProviderRuntimeService } from '@/modules/providers/services/provider-runtime.service.js';
+import type { IProvider, IProviderRuntime } from '@/shared/interfaces.js';
+import type { LLMProvider } from '@/shared/types.js';
+
+function createRuntime(overrides: Partial<IProviderRuntime> = {}): IProviderRuntime {
+  return {
+    async run() {
+      return undefined;
+    },
+    abort() {
+      return false;
+    },
+    ...overrides,
+  };
+}
+
+function createProvider(id: LLMProvider, runtime: IProviderRuntime): IProvider {
+  return {
+    id,
+    runtime,
+    auth: {
+      async getStatus() {
+        return {
+          provider: id,
+          installed: true,
+          authenticated: true,
+          method: 'test',
+          details: {},
+        };
+      },
+    },
+    sessions: {
+      normalizeMessage(raw: unknown, sessionId: string | null) {
+        return [{ kind: 'assistant', content: String(raw), sessionId, provider: id }];
+      },
+      async fetchHistory() {
+        return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+      },
+    },
+  } as unknown as IProvider;
+}
+
+function createService(providers: IProvider[]) {
+  const providerMap = new Map(providers.map((provider) => [provider.id, provider]));
+  return createProviderRuntimeService({
+    listProviders: () => providers,
+    resolveProvider(providerName) {
+      const provider = providerMap.get(providerName as LLMProvider);
+      if (!provider) {
+        throw new Error(`Missing provider: ${providerName}`);
+      }
+      return provider;
+    },
+    resolveProviderSessionId: (sessionId) => sessionId ? `native-${sessionId}` : null,
+    async resolveResumeModel(_provider, _sessionId, requestedModel) {
+      return requestedModel?.trim() || undefined;
+    },
+    async getProviderModels() {
+      return {
+        OPTIONS: [],
+        DEFAULT: 'default-model',
+      };
+    },
+  });
+}
+
+test('providerRegistry owns one runtime for every registered provider', () => {
+  const providers = providerRegistry.listProviders();
+
+  assert.deepEqual(providers.map((provider) => provider.id), [
+    'claude',
+    'codex',
+    'cursor',
+    'opencode',
+  ]);
+  assert.equal(providers.every((provider) => typeof provider.runtime.run === 'function'), true);
+  assert.equal(providers.every((provider) => typeof provider.runtime.abort === 'function'), true);
+});
+
+test('dispatches runs and aborts through the runtime owned by providerRegistry', async () => {
+  const calls: unknown[][] = [];
+  const runtime = createRuntime({
+    async run(command, options, writer, context) {
+      calls.push(['run', command, options, writer]);
+      assert.equal(context.resolveProviderSessionId('session-1'), 'native-session-1');
+      assert.equal(await context.resolveResumeModel('session-1', 'sonnet'), 'sonnet');
+      assert.deepEqual(await context.getProviderModels(), { OPTIONS: [], DEFAULT: 'default-model' });
+      assert.equal(context.normalizeMessage('hello', 'session-1')[0]?.provider, 'claude');
+      assert.equal(await context.isProviderInstalled(), true);
+      return 'complete';
+    },
+    async abort(sessionId) {
+      calls.push(['abort', sessionId]);
+      return true;
+    },
+  });
+  const service = createService([createProvider('claude', runtime)]);
+  const writer = { send() {} };
+
+  assert.equal(service.hasRuntime('claude'), true);
+  assert.equal(service.hasRuntime('unknown'), false);
+  assert.equal(await service.getRunner('claude')('hello', { model: 'sonnet' }, writer), 'complete');
+  assert.equal(await service.abort('claude', 'session-1'), true);
+  assert.deepEqual(calls, [
+    ['run', 'hello', { model: 'sonnet' }, writer],
+    ['abort', 'session-1'],
+  ]);
+});
+
+test('routes permission decisions through provider-owned runtime capabilities', () => {
+  const decisions: unknown[][] = [];
+  const claudeRuntime = createRuntime({
+    permissions: {
+      resolve(requestId, decision) {
+        decisions.push([requestId, decision]);
+      },
+      listPending(sessionId) {
+        return [{ requestId: 'request-1', sessionId }];
+      },
+    },
+  });
+  const service = createService([
+    createProvider('claude', claudeRuntime),
+    createProvider('cursor', createRuntime()),
+  ]);
+  const decision = { allow: true, message: 'approved' };
+
+  service.resolveToolApproval('request-1', decision);
+
+  assert.deepEqual(decisions, [['request-1', decision]]);
+  assert.deepEqual(service.getPendingApprovalsForSession('session-1'), [
+    { requestId: 'request-1', sessionId: 'session-1' },
+  ]);
+});

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

@@ -1,186 +1,186 @@
-import assert from 'node:assert/strict';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-
-import Database from 'better-sqlite3';
-
-import { createProviderTokenUsageService } from '@/modules/providers/services/provider-token-usage.service.js';
-import { AppError } from '@/shared/utils.js';
-
-function createSessionRow(overrides: Record<string, unknown> = {}) {
-  return {
-    session_id: 'app-session',
-    provider: 'claude',
-    provider_session_id: 'provider-session',
-    project_path: null,
-    jsonl_path: null,
-    custom_name: null,
-    model: null,
-    effort: null,
-    isArchived: 0,
-    created_at: '2026-01-01T00:00:00.000Z',
-    updated_at: '2026-01-01T00:00:00.000Z',
-    ...overrides,
-  };
-}
-
-test('token usage lookup requires only the app-facing session id for Claude', async () => {
-  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-claude-'));
-  const sessionFilePath = path.join(tempDirectory, 'provider-session.jsonl');
-
-  try {
-    await writeFile(sessionFilePath, [
-      JSON.stringify({
-        type: 'assistant',
-        message: {
-          usage: {
-            input_tokens: 100,
-            cache_read_input_tokens: 20,
-            cache_creation_input_tokens: 5,
-            output_tokens: 30,
-          },
-        },
-      }),
-      '{incomplete',
-    ].join('\n'));
-
-    const service = createProviderTokenUsageService({
-      getSessionById: () => createSessionRow({ jsonl_path: sessionFilePath }),
-      getClaudeContextWindow: () => '180000',
-    });
-
-    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
-      used: 155,
-      total: 180_000,
-      inputTokens: 125,
-      outputTokens: 30,
-      cacheReadTokens: 20,
-      cacheCreationTokens: 5,
-      cacheTokens: 25,
-      breakdown: { input: 125, output: 30 },
-    });
-  } finally {
-    await rm(tempDirectory, { recursive: true, force: true });
-  }
-});
-
-test('Codex token usage uses the latest token_count snapshot', async () => {
-  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-codex-'));
-  const sessionFilePath = path.join(tempDirectory, 'rollout-provider-session.jsonl');
-
-  try {
-    await writeFile(sessionFilePath, [
-      JSON.stringify({
-        type: 'event_msg',
-        payload: {
-          type: 'token_count',
-          info: {
-            total_token_usage: { input_tokens: 10, output_tokens: 4, total_tokens: 14 },
-            model_context_window: 100_000,
-          },
-        },
-      }),
-      JSON.stringify({
-        type: 'event_msg',
-        payload: {
-          type: 'token_count',
-          info: {
-            total_token_usage: { input_tokens: 40, output_tokens: 9, total_tokens: 49 },
-            model_context_window: 250_000,
-          },
-        },
-      }),
-    ].join('\n'));
-
-    const service = createProviderTokenUsageService({
-      getSessionById: () => createSessionRow({
-        provider: 'codex',
-        jsonl_path: sessionFilePath,
-      }),
-    });
-
-    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
-      used: 49,
-      total: 250_000,
-      inputTokens: 40,
-      outputTokens: 9,
-      breakdown: { input: 40, output: 9 },
-    });
-  } finally {
-    await rm(tempDirectory, { recursive: true, force: true });
-  }
-});
-
-test('OpenCode token usage resolves its provider-native id from the session row', async () => {
-  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-opencode-'));
-  const databasePath = path.join(tempDirectory, 'opencode.db');
-  const database = new Database(databasePath);
-
-  try {
-    database.exec(`
-      CREATE TABLE session (
-        id TEXT PRIMARY KEY,
-        tokens_input INTEGER,
-        tokens_output INTEGER,
-        tokens_reasoning INTEGER,
-        tokens_cache_read INTEGER,
-        tokens_cache_write INTEGER
-      )
-    `);
-    database.prepare(`
-      INSERT INTO session (
-        id,
-        tokens_input,
-        tokens_output,
-        tokens_reasoning,
-        tokens_cache_read,
-        tokens_cache_write
-      ) VALUES (?, ?, ?, ?, ?, ?)
-    `).run('provider-session', 12, 7, 3, 5, 2);
-  } finally {
-    database.close();
-  }
-
-  try {
-    const service = createProviderTokenUsageService({
-      getSessionById: () => createSessionRow({ provider: 'opencode' }),
-      getOpenCodeDatabasePath: () => databasePath,
-    });
-
-    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
-      used: 29,
-      inputTokens: 17,
-      outputTokens: 7,
-      breakdown: { input: 17, output: 7 },
-    });
-  } finally {
-    await rm(tempDirectory, { recursive: true, force: true });
-  }
-});
-
-test('Cursor returns an explicit unsupported token usage result', async () => {
-  const service = createProviderTokenUsageService({
-    getSessionById: () => createSessionRow({ provider: 'cursor' }),
-  });
-
-  const result = await service.getSessionTokenUsage('app-session');
-
-  assert.equal(result.unsupported, true);
-  assert.equal(result.used, 0);
-  assert.equal(result.total, 0);
-});
-
-test('token usage reports SESSION_NOT_FOUND for an unknown app session id', async () => {
-  const service = createProviderTokenUsageService({ getSessionById: () => null });
-
-  await assert.rejects(
-    () => service.getSessionTokenUsage('missing-session'),
-    (error: unknown) => (
-      error instanceof AppError
-      && error.code === 'SESSION_NOT_FOUND'
-      && error.statusCode === 404
-    ),
-  );
-});
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import Database from 'better-sqlite3';
+
+import { createProviderTokenUsageService } from '@/modules/providers/services/provider-token-usage.service.js';
+import { AppError } from '@/shared/utils.js';
+
+function createSessionRow(overrides: Record<string, unknown> = {}) {
+  return {
+    session_id: 'app-session',
+    provider: 'claude',
+    provider_session_id: 'provider-session',
+    project_path: null,
+    jsonl_path: null,
+    custom_name: null,
+    model: null,
+    effort: null,
+    isArchived: 0,
+    created_at: '2026-01-01T00:00:00.000Z',
+    updated_at: '2026-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+test('token usage lookup requires only the app-facing session id for Claude', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-claude-'));
+  const sessionFilePath = path.join(tempDirectory, 'provider-session.jsonl');
+
+  try {
+    await writeFile(sessionFilePath, [
+      JSON.stringify({
+        type: 'assistant',
+        message: {
+          usage: {
+            input_tokens: 100,
+            cache_read_input_tokens: 20,
+            cache_creation_input_tokens: 5,
+            output_tokens: 30,
+          },
+        },
+      }),
+      '{incomplete',
+    ].join('\n'));
+
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({ jsonl_path: sessionFilePath }),
+      getClaudeContextWindow: () => '180000',
+    });
+
+    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
+      used: 155,
+      total: 180_000,
+      inputTokens: 125,
+      outputTokens: 30,
+      cacheReadTokens: 20,
+      cacheCreationTokens: 5,
+      cacheTokens: 25,
+      breakdown: { input: 125, output: 30 },
+    });
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('Codex token usage uses the latest token_count snapshot', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-codex-'));
+  const sessionFilePath = path.join(tempDirectory, 'rollout-provider-session.jsonl');
+
+  try {
+    await writeFile(sessionFilePath, [
+      JSON.stringify({
+        type: 'event_msg',
+        payload: {
+          type: 'token_count',
+          info: {
+            total_token_usage: { input_tokens: 10, output_tokens: 4, total_tokens: 14 },
+            model_context_window: 100_000,
+          },
+        },
+      }),
+      JSON.stringify({
+        type: 'event_msg',
+        payload: {
+          type: 'token_count',
+          info: {
+            total_token_usage: { input_tokens: 40, output_tokens: 9, total_tokens: 49 },
+            model_context_window: 250_000,
+          },
+        },
+      }),
+    ].join('\n'));
+
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({
+        provider: 'codex',
+        jsonl_path: sessionFilePath,
+      }),
+    });
+
+    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
+      used: 49,
+      total: 250_000,
+      inputTokens: 40,
+      outputTokens: 9,
+      breakdown: { input: 40, output: 9 },
+    });
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('OpenCode token usage resolves its provider-native id from the session row', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-opencode-'));
+  const databasePath = path.join(tempDirectory, 'opencode.db');
+  const database = new Database(databasePath);
+
+  try {
+    database.exec(`
+      CREATE TABLE session (
+        id TEXT PRIMARY KEY,
+        tokens_input INTEGER,
+        tokens_output INTEGER,
+        tokens_reasoning INTEGER,
+        tokens_cache_read INTEGER,
+        tokens_cache_write INTEGER
+      )
+    `);
+    database.prepare(`
+      INSERT INTO session (
+        id,
+        tokens_input,
+        tokens_output,
+        tokens_reasoning,
+        tokens_cache_read,
+        tokens_cache_write
+      ) VALUES (?, ?, ?, ?, ?, ?)
+    `).run('provider-session', 12, 7, 3, 5, 2);
+  } finally {
+    database.close();
+  }
+
+  try {
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({ provider: 'opencode' }),
+      getOpenCodeDatabasePath: () => databasePath,
+    });
+
+    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
+      used: 29,
+      inputTokens: 17,
+      outputTokens: 7,
+      breakdown: { input: 17, output: 7 },
+    });
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('Cursor returns an explicit unsupported token usage result', async () => {
+  const service = createProviderTokenUsageService({
+    getSessionById: () => createSessionRow({ provider: 'cursor' }),
+  });
+
+  const result = await service.getSessionTokenUsage('app-session');
+
+  assert.equal(result.unsupported, true);
+  assert.equal(result.used, 0);
+  assert.equal(result.total, 0);
+});
+
+test('token usage reports SESSION_NOT_FOUND for an unknown app session id', async () => {
+  const service = createProviderTokenUsageService({ getSessionById: () => null });
+
+  await assert.rejects(
+    () => service.getSessionTokenUsage('missing-session'),
+    (error: unknown) => (
+      error instanceof AppError
+      && error.code === 'SESSION_NOT_FOUND'
+      && error.statusCode === 404
+    ),
+  );
+});