@agenthippo-ai/agenthippo 0.1.0

package/out/test/analytics.test.js

@@ -0,0 +1,524 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs_1 = require("fs");
+const base_1 = require("../engines/base");
+const sessionEvents_1 = require("../analytics/sessionEvents");
+async function createUniqueTempDir(prefix) {
+    return fs_1.promises.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+async function removeDirWithRetries(dirPath) {
+    await fs_1.promises.rm(dirPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+}
+// =============================================================================
+// generateRequestId Tests
+// =============================================================================
+suite('Analytics - generateRequestId', () => {
+    test('returns string starting with req- prefix', () => {
+        const id = (0, base_1.generateRequestId)();
+        assert.ok(id.startsWith('req-'), `Expected req- prefix, got: ${id}`);
+    });
+    test('returns correct format: req-<8 hex chars>', () => {
+        const id = (0, base_1.generateRequestId)();
+        assert.match(id, /^req-[0-9a-f]{1,8}$/, `Unexpected format: ${id}`);
+    });
+    test('generates unique IDs', () => {
+        const ids = new Set();
+        for (let i = 0; i < 100; i++) {
+            ids.add((0, base_1.generateRequestId)());
+        }
+        // With 8 hex chars, collisions in 100 attempts are extremely unlikely
+        assert.ok(ids.size > 95, `Expected near-unique IDs, got ${ids.size} unique out of 100`);
+    });
+    test('is distinguishable from session IDs (UUIDs)', () => {
+        const requestId = (0, base_1.generateRequestId)();
+        const sessionId = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890';
+        assert.ok(requestId.startsWith('req-'), 'Request ID should start with req-');
+        assert.ok(!sessionId.startsWith('req-'), 'Session ID should not start with req-');
+    });
+});
+// =============================================================================
+// buildLiteLLMMetadataHeaders Tests
+// =============================================================================
+suite('Analytics - buildLiteLLMMetadataHeaders', () => {
+    test('returns empty array when useLiteLLM is false', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(false, {
+            sessionId: 'session-1',
+            analyticsUserId: 'user-1',
+            agentId: 'my-agent',
+        });
+        assert.deepStrictEqual(headers, []);
+    });
+    test('returns empty array when metadata is empty', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, {});
+        assert.deepStrictEqual(headers, []);
+    });
+    test('includes session_id header', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { sessionId: 'sess-123' });
+        assert.ok(headers.some(h => h === 'x-litellm-metadata-session-id: sess-123'), `Missing session_id header. Headers: ${JSON.stringify(headers)}`);
+    });
+    test('includes user_id header', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { analyticsUserId: 'user-42' });
+        assert.ok(headers.some(h => h === 'x-litellm-metadata-user-id: user-42'), `Missing user_id header. Headers: ${JSON.stringify(headers)}`);
+    });
+    test('includes project_id header', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { analyticsProjectId: 'agentide-vscode' });
+        assert.ok(headers.some(h => h === 'x-litellm-metadata-project-id: agentide-vscode'), `Missing project_id header. Headers: ${JSON.stringify(headers)}`);
+    });
+    test('includes agent_id header', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { agentId: 'code-reviewer' });
+        assert.ok(headers.some(h => h === 'x-litellm-metadata-agent-id: code-reviewer'), `Missing agent_id header. Headers: ${JSON.stringify(headers)}`);
+    });
+    test('includes agent_version header', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { agentVersion: '1.2.0' });
+        assert.ok(headers.some(h => h === 'x-litellm-metadata-agent-version: 1.2.0'), `Missing agent_version header. Headers: ${JSON.stringify(headers)}`);
+    });
+    test('includes source header', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { source: 'langchain' });
+        assert.ok(headers.some(h => h === 'x-litellm-metadata-source: langchain'), `Missing source header. Headers: ${JSON.stringify(headers)}`);
+    });
+    test('includes engine header', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { engine: 'claude' });
+        assert.ok(headers.some(h => h === 'x-litellm-metadata-engine: claude'), `Missing engine header. Headers: ${JSON.stringify(headers)}`);
+    });
+    test('includes request_id header', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { requestId: 'req-abcdef12' });
+        assert.ok(headers.some(h => h === 'x-litellm-metadata-request-id: req-abcdef12'), `Missing request_id header. Headers: ${JSON.stringify(headers)}`);
+    });
+    test('includes langfuse passthrough headers for session_id and user_id', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, {
+            sessionId: 'sess-1',
+            analyticsUserId: 'user-1',
+        });
+        assert.ok(headers.some(h => h === 'langfuse_session_id: sess-1'), 'Should include langfuse_session_id for Langfuse callback compatibility');
+        assert.ok(headers.some(h => h === 'langfuse_trace_user_id: user-1'), 'Should include langfuse_trace_user_id for Langfuse callback compatibility');
+    });
+    // --- Use Case: AgentHippo pack (Mode A) — fully automatic ---
+    test('Mode A: AgentHippo pack produces all 10 headers (8 analytics + 2 langfuse)', () => {
+        const metadata = {
+            sessionId: 'vscode-chat-uuid-1234',
+            analyticsUserId: 'dev@example.com',
+            analyticsProjectId: 'agentide-vscode',
+            agentId: 'code-reviewer',
+            agentVersion: '1.2.0',
+            source: 'agenthippo',
+            engine: 'claude',
+            requestId: 'req-abcdef12',
+        };
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
+        // 8 x-litellm-metadata-* headers + langfuse_session_id + langfuse_trace_user_id
+        assert.strictEqual(headers.length, 10, `Expected 10 headers, got ${headers.length}: ${JSON.stringify(headers)}`);
+    });
+    // --- Use Case: AgentHippo default (Mode B) ---
+    test('Mode B: AgentHippo default agent produces all 10 headers', () => {
+        const metadata = {
+            sessionId: 'vscode-chat-uuid-5678',
+            analyticsUserId: 'dev@example.com',
+            analyticsProjectId: 'agentide-vscode',
+            agentId: 'default',
+            agentVersion: 'workspace',
+            source: 'agenthippo',
+            engine: 'codex',
+            requestId: 'req-11223344',
+        };
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
+        assert.strictEqual(headers.length, 10);
+        assert.ok(headers.some(h => h.includes('agent-id: default')));
+        assert.ok(headers.some(h => h.includes('agent-version: workspace')));
+    });
+    // --- Use Case: LangChain via LiteLLM proxy (Mode C) — developer sets minimum ---
+    test('Mode C: LangChain developer sets minimum viable metadata', () => {
+        const metadata = {
+            sessionId: 'langchain-run-001',
+            agentId: 'my-support-bot',
+        };
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
+        // session-id + agent-id + langfuse_session_id = 3
+        assert.strictEqual(headers.length, 3);
+        assert.ok(headers.some(h => h.includes('session-id: langchain-run-001')));
+        assert.ok(headers.some(h => h.includes('agent-id: my-support-bot')));
+    });
+    // --- Use Case: LangChain developer sets full metadata (Mode C) ---
+    test('Mode C: LangChain developer sets full metadata', () => {
+        const metadata = {
+            sessionId: 'langchain-run-001',
+            agentId: 'my-support-bot',
+            agentVersion: '0.3.1',
+            source: 'langchain',
+        };
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
+        // session-id + agent-id + agent-version + source + langfuse_session_id = 5
+        assert.strictEqual(headers.length, 5);
+        assert.ok(headers.some(h => h.includes('source: langchain')));
+    });
+    // --- Use Case: Direct SDK (Mode D) ---
+    test('Mode D: Anthropic SDK developer sets metadata', () => {
+        const metadata = {
+            sessionId: 'exp-42',
+            agentId: 'my-tool',
+            source: 'anthropic-sdk',
+        };
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, metadata);
+        // session-id + agent-id + source + langfuse_session_id = 4
+        assert.strictEqual(headers.length, 4);
+        assert.ok(headers.some(h => h.includes('source: anthropic-sdk')));
+    });
+    test('trims whitespace from values', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, { sessionId: '  sess-1  ' });
+        assert.ok(headers.some(h => h === 'x-litellm-metadata-session-id: sess-1'));
+    });
+    test('skips empty/whitespace-only values', () => {
+        const headers = (0, base_1.buildLiteLLMMetadataHeaders)(true, {
+            sessionId: '',
+            agentId: '   ',
+            source: 'agenthippo',
+        });
+        // Only source header (sessionId is empty so no langfuse passthrough either)
+        assert.strictEqual(headers.length, 1, `Only non-empty source should produce a header, got: ${JSON.stringify(headers)}`);
+    });
+});
+// =============================================================================
+// SessionEventWriter Tests
+// =============================================================================
+suite('Analytics - SessionEventWriter', () => {
+    let testDir;
+    let writer;
+    setup(async () => {
+        testDir = await createUniqueTempDir('agentide-analytics-test-');
+        writer = new sessionEvents_1.SessionEventWriter(testDir);
+    });
+    teardown(async () => {
+        try {
+            await removeDirWithRetries(testDir);
+        }
+        catch {
+            // ignore
+        }
+    });
+    test('creates sessions directory on first write', async () => {
+        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'Bash' });
+        const stat = await fs_1.promises.stat(testDir);
+        assert.ok(stat.isDirectory());
+    });
+    test('writes JSONL file named by session ID', async () => {
+        await writer.append('sess-abc', 'req-1', 'tool_start', { toolName: 'Read' });
+        const filePath = path.join(testDir, 'sess-abc.jsonl');
+        const stat = await fs_1.promises.stat(filePath);
+        assert.ok(stat.isFile());
+    });
+    test('writes valid JSON per line', async () => {
+        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'Bash' });
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const lines = content.trim().split('\n');
+        assert.strictEqual(lines.length, 1);
+        const event = JSON.parse(lines[0]);
+        assert.strictEqual(event.session_id, 'sess-1');
+        assert.strictEqual(event.request_id, 'req-1');
+        assert.strictEqual(event.event_type, 'tool_start');
+        assert.strictEqual(event.payload.toolName, 'Bash');
+        assert.ok(typeof event.timestamp === 'number');
+    });
+    test('appends multiple events to same session file', async () => {
+        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'Bash', callId: 'c1' });
+        await writer.append('sess-1', 'req-1', 'tool_end', { toolName: 'Bash', callId: 'c1', isError: false });
+        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'Read', callId: 'c2' });
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const lines = content.trim().split('\n');
+        assert.strictEqual(lines.length, 3);
+        const events = lines.map(l => JSON.parse(l));
+        assert.strictEqual(events[0].event_type, 'tool_start');
+        assert.strictEqual(events[0].payload.toolName, 'Bash');
+        assert.strictEqual(events[1].event_type, 'tool_end');
+        assert.strictEqual(events[2].event_type, 'tool_start');
+        assert.strictEqual(events[2].payload.toolName, 'Read');
+    });
+    test('different sessions write to different files', async () => {
+        await writer.append('sess-A', 'req-1', 'turn_start', {});
+        await writer.append('sess-B', 'req-2', 'turn_start', {});
+        const fileA = await fs_1.promises.stat(path.join(testDir, 'sess-A.jsonl'));
+        const fileB = await fs_1.promises.stat(path.join(testDir, 'sess-B.jsonl'));
+        assert.ok(fileA.isFile());
+        assert.ok(fileB.isFile());
+    });
+    test('request_id is preserved in events', async () => {
+        await writer.append('sess-1', 'req-abc', 'tool_start', { toolName: 'Test' });
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const event = JSON.parse(content.trim());
+        assert.strictEqual(event.request_id, 'req-abc');
+    });
+    test('timestamps are monotonically increasing', async () => {
+        await writer.append('sess-1', 'req-1', 'turn_start', {});
+        await writer.append('sess-1', 'req-1', 'tool_start', { toolName: 'A' });
+        await writer.append('sess-1', 'req-1', 'tool_end', { toolName: 'A' });
+        await writer.append('sess-1', 'req-1', 'turn_end', { success: true });
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const events = content.trim().split('\n').map(l => JSON.parse(l));
+        for (let i = 1; i < events.length; i++) {
+            assert.ok(events[i].timestamp >= events[i - 1].timestamp, `Timestamps should be monotonic: ${events[i - 1].timestamp} -> ${events[i].timestamp}`);
+        }
+    });
+    test('getSessionsDir returns the base directory', () => {
+        assert.strictEqual(writer.getSessionsDir(), testDir);
+    });
+});
+// =============================================================================
+// ObservableStreamEmitter Tests
+// =============================================================================
+suite('Analytics - ObservableStreamEmitter', () => {
+    let testDir;
+    let writer;
+    let innerCalls;
+    let innerEmitter;
+    setup(async () => {
+        testDir = await createUniqueTempDir('agentide-emitter-test-');
+        writer = new sessionEvents_1.SessionEventWriter(testDir);
+        innerCalls = [];
+        // Mock inner emitter that records calls
+        innerEmitter = {
+            async thinking(delta) { innerCalls.push({ method: 'thinking', args: [delta] }); },
+            async text(delta) { innerCalls.push({ method: 'text', args: [delta] }); },
+            async toolStart(name, input, id, meta) {
+                innerCalls.push({ method: 'toolStart', args: [name, input, id, meta] });
+            },
+            async toolEnd(name, id, result, isError, meta) {
+                innerCalls.push({ method: 'toolEnd', args: [name, id, result, isError, meta] });
+            },
+            async progress(msg) { innerCalls.push({ method: 'progress', args: [msg] }); },
+            async question(payload) {
+                innerCalls.push({ method: 'question', args: [payload] });
+                return { selected: [], freeText: null };
+            },
+            async error(msg) { innerCalls.push({ method: 'error', args: [msg] }); },
+            async done() { innerCalls.push({ method: 'done', args: [] }); },
+        };
+    });
+    teardown(async () => {
+        try {
+            await removeDirWithRetries(testDir);
+        }
+        catch {
+            // ignore
+        }
+    });
+    test('passes through thinking() to inner emitter', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.thinking('hello');
+        assert.strictEqual(innerCalls.length, 1);
+        assert.strictEqual(innerCalls[0].method, 'thinking');
+        assert.deepStrictEqual(innerCalls[0].args, ['hello']);
+    });
+    test('passes through text() to inner emitter', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.text('world');
+        assert.strictEqual(innerCalls.length, 1);
+        assert.strictEqual(innerCalls[0].method, 'text');
+    });
+    test('passes through progress() to inner emitter', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.progress('Thinking...');
+        assert.strictEqual(innerCalls.length, 1);
+        assert.strictEqual(innerCalls[0].method, 'progress');
+    });
+    test('passes through done() to inner emitter', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.done();
+        assert.strictEqual(innerCalls.length, 1);
+        assert.strictEqual(innerCalls[0].method, 'done');
+    });
+    test('toolStart writes session event AND passes through', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.toolStart('Bash', 'ls -la', 'call-1');
+        // Inner emitter was called
+        assert.strictEqual(innerCalls.length, 1);
+        assert.strictEqual(innerCalls[0].method, 'toolStart');
+        // Session event was written
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const event = JSON.parse(content.trim());
+        assert.strictEqual(event.event_type, 'tool_start');
+        assert.strictEqual(event.payload.toolName, 'Bash');
+        assert.strictEqual(event.payload.callId, 'call-1');
+        assert.strictEqual(event.payload.inputPreview, 'ls -la');
+        assert.strictEqual(event.request_id, 'req-1');
+    });
+    test('toolEnd writes session event AND passes through', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.toolEnd('Bash', 'call-1', 'file1.txt\nfile2.txt', false);
+        // Inner emitter was called
+        assert.strictEqual(innerCalls.length, 1);
+        assert.strictEqual(innerCalls[0].method, 'toolEnd');
+        // Session event was written
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const event = JSON.parse(content.trim());
+        assert.strictEqual(event.event_type, 'tool_end');
+        assert.strictEqual(event.payload.toolName, 'Bash');
+        assert.strictEqual(event.payload.isError, false);
+    });
+    test('toolEnd records errors', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.toolEnd('Bash', 'call-1', 'command not found', true);
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const event = JSON.parse(content.trim());
+        assert.strictEqual(event.payload.isError, true);
+    });
+    test('error() writes session event AND passes through', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.error('Something went wrong');
+        assert.strictEqual(innerCalls.length, 1);
+        assert.strictEqual(innerCalls[0].method, 'error');
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const event = JSON.parse(content.trim());
+        assert.strictEqual(event.event_type, 'error');
+        assert.strictEqual(event.payload.message, 'Something went wrong');
+    });
+    test('emitTurnStart writes turn_start event', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.emitTurnStart();
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const event = JSON.parse(content.trim());
+        assert.strictEqual(event.event_type, 'turn_start');
+        assert.strictEqual(event.session_id, 'sess-1');
+        assert.strictEqual(event.request_id, 'req-1');
+    });
+    test('emitTurnEnd writes turn_end event with success flag', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        await emitter.emitTurnEnd(true);
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const event = JSON.parse(content.trim());
+        assert.strictEqual(event.event_type, 'turn_end');
+        assert.strictEqual(event.payload.success, true);
+    });
+    test('truncates long tool input to 500 chars', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        const longInput = 'x'.repeat(1000);
+        await emitter.toolStart('Read', longInput, 'call-1');
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const event = JSON.parse(content.trim());
+        assert.strictEqual(event.payload.inputPreview.length, 500);
+    });
+    test('truncates long tool result to 500 chars', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-1', 'req-1');
+        const longResult = 'y'.repeat(1000);
+        await emitter.toolEnd('Read', 'call-1', longResult, false);
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-1.jsonl'), 'utf8');
+        const event = JSON.parse(content.trim());
+        assert.strictEqual(event.payload.resultPreview.length, 500);
+    });
+    // --- Use Case: Full agent request lifecycle ---
+    test('Use Case: full request lifecycle produces correct event sequence', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-debug', 'req-42');
+        // Simulate a full agent request lifecycle
+        await emitter.emitTurnStart();
+        await emitter.progress('Thinking...');
+        await emitter.thinking('Let me analyze this...');
+        await emitter.toolStart('Read', '/path/to/file.ts', 'tool-1');
+        await emitter.toolEnd('Read', 'tool-1', 'file contents here', false);
+        await emitter.toolStart('Bash', 'npm test', 'tool-2');
+        await emitter.toolEnd('Bash', 'tool-2', 'All tests passed', false);
+        await emitter.text('I analyzed the code and ran the tests.');
+        await emitter.done();
+        await emitter.emitTurnEnd(true);
+        // Verify inner emitter got all pass-through calls
+        const methods = innerCalls.map(c => c.method);
+        assert.deepStrictEqual(methods, [
+            'progress', 'thinking', 'toolStart', 'toolEnd',
+            'toolStart', 'toolEnd', 'text', 'done',
+        ]);
+        // Verify session events (only tool/turn events, not thinking/text/progress)
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-debug.jsonl'), 'utf8');
+        const events = content.trim().split('\n').map(l => JSON.parse(l));
+        const eventTypes = events.map((e) => e.event_type);
+        assert.deepStrictEqual(eventTypes, [
+            'turn_start', 'tool_start', 'tool_end', 'tool_start', 'tool_end', 'turn_end',
+        ]);
+        // All events have correct session_id and request_id
+        for (const event of events) {
+            assert.strictEqual(event.session_id, 'sess-debug');
+            assert.strictEqual(event.request_id, 'req-42');
+        }
+    });
+    // --- Use Case: Detect tool loop from events ---
+    test('Use Case: tool loop detection — 6 calls to same tool', async () => {
+        const emitter = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-loop', 'req-1');
+        await emitter.emitTurnStart();
+        // Simulate an agent calling read_file 6 times (possible loop)
+        for (let i = 0; i < 6; i++) {
+            await emitter.toolStart('read_file', `/path/file${i}.ts`, `call-${i}`);
+            await emitter.toolEnd('read_file', `call-${i}`, 'contents', false);
+        }
+        await emitter.emitTurnEnd(true);
+        // Read events and count tool_start for read_file
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-loop.jsonl'), 'utf8');
+        const events = content.trim().split('\n').map(l => JSON.parse(l));
+        const readFileStarts = events.filter((e) => e.event_type === 'tool_start' && e.payload.toolName === 'read_file');
+        assert.strictEqual(readFileStarts.length, 6, 'Should detect 6 read_file calls');
+        // This is what --tool-loops query would flag as "POSSIBLE LOOP" (>5 calls)
+    });
+    // --- Use Case: Multiple requests in same session ---
+    test('Use Case: multiple requests in same session have different request_ids', async () => {
+        const reqId1 = (0, base_1.generateRequestId)();
+        const reqId2 = (0, base_1.generateRequestId)();
+        const emitter1 = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-multi', reqId1);
+        await emitter1.emitTurnStart();
+        await emitter1.toolStart('Bash', 'echo hello', 'c1');
+        await emitter1.toolEnd('Bash', 'c1', 'hello', false);
+        await emitter1.emitTurnEnd(true);
+        const emitter2 = (0, sessionEvents_1.wrapEmitterWithObservability)(innerEmitter, writer, 'sess-multi', reqId2);
+        await emitter2.emitTurnStart();
+        await emitter2.toolStart('Read', '/file.ts', 'c2');
+        await emitter2.toolEnd('Read', 'c2', 'contents', false);
+        await emitter2.emitTurnEnd(true);
+        // All events in same session file
+        const content = await fs_1.promises.readFile(path.join(testDir, 'sess-multi.jsonl'), 'utf8');
+        const events = content.trim().split('\n').map(l => JSON.parse(l));
+        assert.strictEqual(events.length, 8); // 2 x (turn_start, tool_start, tool_end, turn_end)
+        // First 4 events have reqId1, last 4 have reqId2
+        const firstFour = events.slice(0, 4);
+        const lastFour = events.slice(4);
+        for (const e of firstFour) {
+            assert.strictEqual(e.request_id, reqId1);
+        }
+        for (const e of lastFour) {
+            assert.strictEqual(e.request_id, reqId2);
+        }
+        assert.notStrictEqual(reqId1, reqId2, 'Request IDs should be different');
+    });
+});

package/out/test/auth-bootstrapApply.test.js

@@ -0,0 +1,102 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const bootstrapApply_js_1 = require("../auth/bootstrapApply.js");
+function createMockTarget() {
+    const global = new Map();
+    const settings = new Map();
+    let apiKeyCalls = 0;
+    const target = {
+        getConfiguration(section) {
+            return {
+                get(key, defaultValue) {
+                    const full = `${section}.${key}`;
+                    return (settings.has(full) ? settings.get(full) : defaultValue);
+                },
+                async update(key, value) {
+                    settings.set(`${section}.${key}`, value);
+                },
+            };
+        },
+        ConfigurationTarget: { Global: 1 },
+        async setParticipantApiKey() {
+            apiKeyCalls++;
+        },
+        async globalStateUpdate(key, value) {
+            if (value === undefined) {
+                global.delete(key);
+            }
+            else {
+                global.set(key, value);
+            }
+        },
+        globalStateGet(key) {
+            return global.get(key);
+        },
+    };
+    return { target, settings, global, getApiKeyCalls: () => apiKeyCalls };
+}
+const sampleBootstrap = {
+    version: 1,
+    user: { id: 'usr_1', email: 'you@acme.com', displayName: 'You' },
+    team: { id: 'team_acme', name: 'Acme', role: 'member' },
+    store: { repo: 'acme/store', indexUrl: 'https://acme.github.io/store', githubOrg: 'acme' },
+    routing: { litellmBaseUrl: 'http://llm.acme', litellmApiKey: 'ahk_123' },
+    policy: { byokAllowed: true, teamManagedSettings: ['store', 'routing'] },
+};
+suite('BootstrapApply', () => {
+    test('applyIdeBootstrap writes store and routing settings', async () => {
+        const { target, settings, global, getApiKeyCalls } = createMockTarget();
+        const result = await (0, bootstrapApply_js_1.applyIdeBootstrap)(sampleBootstrap, target);
+        assert.deepStrictEqual(result.applied, ['store', 'routing']);
+        assert.strictEqual(settings.get('agentide.storeRepo'), 'acme/store');
+        assert.strictEqual(settings.get('agentide.providers.litellm.baseUrl'), 'http://llm.acme');
+        assert.strictEqual(getApiKeyCalls(), 1);
+        assert.strictEqual(global.get('agentide.team.id'), 'team_acme');
+    });
+    test('revertTeamManagedBootstrap restores defaults', async () => {
+        const { target, settings, global } = createMockTarget();
+        await (0, bootstrapApply_js_1.applyIdeBootstrap)(sampleBootstrap, target);
+        await (0, bootstrapApply_js_1.revertTeamManagedBootstrap)(target);
+        assert.strictEqual(settings.get('agentide.storeRepo'), 'agenthippoai/agenthippo-store');
+        assert.strictEqual(settings.get('agentide.providers.litellm.baseUrl'), '');
+        assert.strictEqual(global.get('agentide.team.id'), undefined);
+    });
+});