@inkeep/agents-cli 0.1.5 → 0.1.7

package/dist/__tests__/config-validation.test.js

@@ -1,98 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { validateConfiguration } from '../config.js';
-// Save original env and cwd
-const originalEnv = process.env;
-const originalCwd = process.cwd();
-// Mock the file system to prevent finding actual config files
-vi.mock('node:fs', () => ({
-    existsSync: vi.fn(() => false),
-}));
-// Mock process.cwd to avoid loading the actual config file
-vi.mock('node:process', () => ({
-    cwd: () => '/tmp/test-cli',
-}));
-describe('Configuration Validation', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        process.env = { ...originalEnv };
-        delete process.env.INKEEP_API_URL;
-        delete process.env.INKEEP_AGENTS_MANAGE_API_URL;
-        delete process.env.INKEEP_EXECUTION_API_URL;
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-        vi.restoreAllMocks();
-    });
-    describe('validateConfiguration', () => {
-        describe('Valid Configurations', () => {
-            it('should accept --tenant-id with --management-api-url and --execution-api-url flags', async () => {
-                const config = await validateConfiguration('test-tenant', 'http://localhost:3002', 'http://localhost:3003', undefined);
-                expect(config.tenantId).toBe('test-tenant');
-                expect(config.managementApiUrl).toBe('http://localhost:3002');
-                expect(config.executionApiUrl).toBe('http://localhost:3003');
-                expect(config.sources.tenantId).toBe('command-line flag (--tenant-id)');
-                expect(config.sources.managementApiUrl).toBe('command-line flag (--management-api-url)');
-                expect(config.sources.executionApiUrl).toBe('command-line flag (--execution-api-url)');
-            });
-            it('should use environment variables when no flags provided', async () => {
-                process.env.INKEEP_AGENTS_MANAGE_API_URL = 'http://localhost:9090';
-                process.env.INKEEP_EXECUTION_API_URL = 'http://localhost:9091';
-                const config = await validateConfiguration(undefined, undefined, undefined, undefined);
-                expect(config.tenantId).toBe('env-tenant');
-                expect(config.managementApiUrl).toBe('http://localhost:9090');
-                expect(config.executionApiUrl).toBe('http://localhost:9091');
-                expect(config.sources.managementApiUrl).toBe('environment variable (INKEEP_AGENTS_MANAGE_API_URL)');
-                expect(config.sources.executionApiUrl).toBe('environment variable (INKEEP_EXECUTION_API_URL)');
-            });
-            it('should allow command-line flags to override environment variables', async () => {
-                process.env.INKEEP_AGENTS_MANAGE_API_URL = 'http://localhost:9090';
-                process.env.INKEEP_EXECUTION_API_URL = 'http://localhost:9091';
-                const config = await validateConfiguration('cli-tenant', 'http://cli-management', 'http://cli-execution', undefined);
-                expect(config.tenantId).toBe('cli-tenant');
-                expect(config.managementApiUrl).toBe('http://cli-management');
-                expect(config.executionApiUrl).toBe('http://cli-execution');
-                expect(config.sources.tenantId).toBe('command-line flag (--tenant-id)');
-                expect(config.sources.managementApiUrl).toBe('command-line flag (--management-api-url)');
-                expect(config.sources.executionApiUrl).toBe('command-line flag (--execution-api-url)');
-            });
-        });
-        describe('Invalid Configurations', () => {
-            it('should reject --config-file-path with --tenant-id', async () => {
-                await expect(validateConfiguration('test-tenant', undefined, undefined, '/path/to/config.js')).rejects.toThrow('Invalid configuration combination');
-            });
-            it('should reject --tenant-id without both API URLs', async () => {
-                await expect(validateConfiguration('test-tenant', undefined, undefined, undefined)).rejects.toThrow('--tenant-id requires --management-api-url and --execution-api-url');
-            });
-            it('should reject when no configuration is provided', async () => {
-                await expect(validateConfiguration(undefined, undefined, undefined, undefined)).rejects.toThrow('No configuration found');
-            });
-        });
-        describe('Configuration Source Tracking', () => {
-            it('should correctly identify command-line flag sources', async () => {
-                const config = await validateConfiguration('cli-tenant', 'http://cli-management', 'http://cli-execution', undefined);
-                expect(config.sources.tenantId).toBe('command-line flag (--tenant-id)');
-                expect(config.sources.managementApiUrl).toBe('command-line flag (--management-api-url)');
-                expect(config.sources.executionApiUrl).toBe('command-line flag (--execution-api-url)');
-                expect(config.sources.configFile).toBeUndefined();
-            });
-            it('should correctly identify environment variable sources', async () => {
-                process.env.INKEEP_AGENTS_MANAGE_API_URL = 'http://env-management';
-                process.env.INKEEP_EXECUTION_API_URL = 'http://env-execution';
-                const config = await validateConfiguration(undefined, undefined, undefined, undefined);
-                expect(config.sources.managementApiUrl).toBe('environment variable (INKEEP_AGENTS_MANAGE_API_URL)');
-                expect(config.sources.executionApiUrl).toBe('environment variable (INKEEP_EXECUTION_API_URL)');
-            });
-            it('should correctly identify mixed sources with env and flag', async () => {
-                process.env.INKEEP_AGENTS_MANAGE_API_URL = 'http://env-management';
-                process.env.INKEEP_EXECUTION_API_URL = 'http://env-execution';
-                // Override only the management API URL with a flag
-                const config = await validateConfiguration(undefined, 'http://override-management', undefined, undefined);
-                expect(config.tenantId).toBe('env-tenant');
-                expect(config.managementApiUrl).toBe('http://override-management');
-                expect(config.executionApiUrl).toBe('http://env-execution');
-                expect(config.sources.managementApiUrl).toBe('command-line flag (--management-api-url)');
-                expect(config.sources.executionApiUrl).toBe('environment variable (INKEEP_EXECUTION_API_URL)');
-            });
-        });
-    });
-});

package/dist/__tests__/package.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/package.test.js

@@ -1,82 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { beforeEach, describe, expect, it } from 'vitest';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-describe('Package Configuration', () => {
-    const packageJsonPath = join(__dirname, '..', '..', 'package.json');
-    const tsConfigTypeCheckPath = join(__dirname, '..', '..', 'tsconfig.typecheck.json');
-    let packageJson;
-    let tsConfigTypeCheck;
-    beforeEach(() => {
-        const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
-        packageJson = JSON.parse(packageJsonContent);
-        const tsConfigTypeCheckContent = readFileSync(tsConfigTypeCheckPath, 'utf-8');
-        tsConfigTypeCheck = JSON.parse(tsConfigTypeCheckContent);
-    });
-    describe('package.json', () => {
-        it('should have correct package name', () => {
-            expect(packageJson.name).toBe('@inkeep/agents-cli');
-        });
-        it('should have a valid version', () => {
-            expect(packageJson.version).toMatch(/^\d+\.\d+\.\d+$/);
-        });
-        it('should have correct bin configuration', () => {
-            expect(packageJson.bin).toEqual({
-                inkeep: './dist/index.js',
-            });
-        });
-        it('should have correct main entry point', () => {
-            expect(packageJson.main).toBe('./dist/exports.js');
-        });
-        it('should be set to module type', () => {
-            expect(packageJson.type).toBe('module');
-        });
-        it('should have required dependencies', () => {
-            expect(packageJson.dependencies).toHaveProperty('commander');
-            expect(packageJson.dependencies).toHaveProperty('chalk');
-        });
-        it('should have required dev dependencies', () => {
-            expect(packageJson.devDependencies).toHaveProperty('typescript');
-            expect(packageJson.devDependencies).toHaveProperty('vitest');
-            expect(packageJson.devDependencies).toHaveProperty('@types/node');
-        });
-        it('should have test scripts', () => {
-            expect(packageJson.scripts).toHaveProperty('test');
-            expect(packageJson.scripts).toHaveProperty('test:watch');
-            expect(packageJson.scripts).toHaveProperty('test:coverage');
-        });
-        it('should have typecheck script', () => {
-            expect(packageJson.scripts).toHaveProperty('typecheck');
-            expect(packageJson.scripts.typecheck).toBe('tsc --noEmit --project tsconfig.typecheck.json');
-        });
-        it('should have correct Node.js engine requirement', () => {
-            expect(packageJson.engines.node).toBe('>=20.x');
-        });
-        it('should have correct author', () => {
-            expect(packageJson.author).toBe('Inkeep <support@inkeep.com>');
-        });
-        it('should have correct license reference', () => {
-            expect(packageJson.license).toBe('SEE LICENSE IN LICENSE.md');
-        });
-    });
-    describe('tsconfig.typecheck.json', () => {
-        it('should extend base tsconfig', () => {
-            expect(tsConfigTypeCheck.extends).toBe('./tsconfig.json');
-        });
-        it('should have correct compiler options', () => {
-            expect(tsConfigTypeCheck.compilerOptions).toHaveProperty('noEmit', true);
-            expect(tsConfigTypeCheck.compilerOptions).toHaveProperty('skipLibCheck', true);
-        });
-        it('should include src files', () => {
-            expect(tsConfigTypeCheck.include).toContain('src/**/*');
-        });
-        it('should exclude test files and build artifacts', () => {
-            expect(tsConfigTypeCheck.exclude).toContain('node_modules');
-            expect(tsConfigTypeCheck.exclude).toContain('dist');
-            expect(tsConfigTypeCheck.exclude).toContain('**/*.test.ts');
-            expect(tsConfigTypeCheck.exclude).toContain('src/__tests__/**/*');
-        });
-    });
-});

package/dist/__tests__/utils/json-comparator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/utils/json-comparator.test.js

@@ -1,174 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { compareJsonObjects, getDifferenceSummary, normalizeJsonObject, } from '../../utils/json-comparator.js';
-describe('json-comparator', () => {
-    describe('compareJsonObjects', () => {
-        it('should return true for identical objects', () => {
-            const obj1 = { a: 1, b: 'test', c: [1, 2, 3] };
-            const obj2 = { a: 1, b: 'test', c: [1, 2, 3] };
-            const result = compareJsonObjects(obj1, obj2);
-            expect(result.isEqual).toBe(true);
-            expect(result.differences).toHaveLength(0);
-        });
-        it('should return false for different objects', () => {
-            const obj1 = { a: 1, b: 'test' };
-            const obj2 = { a: 2, b: 'test' };
-            const result = compareJsonObjects(obj1, obj2);
-            expect(result.isEqual).toBe(false);
-            expect(result.differences).toHaveLength(1);
-            expect(result.differences[0].path).toBe('a');
-            expect(result.differences[0].type).toBe('different');
-        });
-        it('should handle arrays with different order when ignoreArrayOrder is true', () => {
-            const obj1 = { items: [1, 2, 3] };
-            const obj2 = { items: [3, 1, 2] };
-            const result = compareJsonObjects(obj1, obj2, { ignoreArrayOrder: true });
-            expect(result.isEqual).toBe(true);
-        });
-        it('should detect arrays with different order when ignoreArrayOrder is false', () => {
-            const obj1 = { items: [1, 2, 3] };
-            const obj2 = { items: [3, 1, 2] };
-            const result = compareJsonObjects(obj1, obj2, { ignoreArrayOrder: false });
-            expect(result.isEqual).toBe(false);
-        });
-        it('should handle missing keys', () => {
-            const obj1 = { a: 1, b: 2 };
-            const obj2 = { a: 1 };
-            const result = compareJsonObjects(obj1, obj2);
-            expect(result.isEqual).toBe(false);
-            expect(result.differences).toHaveLength(1);
-            expect(result.differences[0].type).toBe('extra');
-            expect(result.differences[0].path).toBe('b');
-        });
-        it('should handle extra keys', () => {
-            const obj1 = { a: 1 };
-            const obj2 = { a: 1, b: 2 };
-            const result = compareJsonObjects(obj1, obj2);
-            expect(result.isEqual).toBe(false);
-            expect(result.differences).toHaveLength(1);
-            expect(result.differences[0].type).toBe('missing');
-            expect(result.differences[0].path).toBe('b');
-        });
-        it('should handle nested objects', () => {
-            const obj1 = { user: { name: 'John', age: 30 } };
-            const obj2 = { user: { name: 'John', age: 31 } };
-            const result = compareJsonObjects(obj1, obj2);
-            expect(result.isEqual).toBe(false);
-            expect(result.differences).toHaveLength(1);
-            expect(result.differences[0].path).toBe('user.age');
-        });
-        it('should handle type mismatches', () => {
-            const obj1 = { value: '123' };
-            const obj2 = { value: 123 };
-            const result = compareJsonObjects(obj1, obj2);
-            expect(result.isEqual).toBe(false);
-            expect(result.differences).toHaveLength(1);
-            expect(result.differences[0].type).toBe('type_mismatch');
-        });
-        it('should ignore specified paths', () => {
-            const obj1 = { a: 1, b: 2, c: 3 };
-            const obj2 = { a: 1, b: 999, c: 3 };
-            const result = compareJsonObjects(obj1, obj2, { ignorePaths: ['b'] });
-            expect(result.isEqual).toBe(true);
-        });
-        it('should ignore paths with wildcards', () => {
-            const obj1 = { user: { name: 'John', age: 30 }, meta: { created: '2023-01-01' } };
-            const obj2 = { user: { name: 'John', age: 30 }, meta: { created: '2023-01-02' } };
-            const result = compareJsonObjects(obj1, obj2, { ignorePaths: ['meta.*'] });
-            expect(result.isEqual).toBe(true);
-        });
-        it('should handle case insensitive comparison', () => {
-            const obj1 = { name: 'John' };
-            const obj2 = { name: 'JOHN' };
-            const result = compareJsonObjects(obj1, obj2, { ignoreCase: true });
-            expect(result.isEqual).toBe(true);
-        });
-        it('should handle whitespace insensitive comparison', () => {
-            const obj1 = { description: 'Hello world' };
-            const obj2 = { description: '  Hello   world  ' };
-            const result = compareJsonObjects(obj1, obj2, { ignoreWhitespace: true });
-            expect(result.isEqual).toBe(true);
-        });
-        it('should provide accurate statistics', () => {
-            const obj1 = { a: 1, b: 2, c: 3 };
-            const obj2 = { a: 1, b: 999, d: 4 };
-            const result = compareJsonObjects(obj1, obj2);
-            expect(result.stats.totalKeys).toBe(4);
-            expect(result.stats.differentKeys).toBe(1); // 'b' has different values
-            expect(result.stats.missingKeys).toBe(1); // 'd' is missing in obj1
-            expect(result.stats.extraKeys).toBe(1); // 'c' is extra in obj1
-        });
-    });
-    describe('normalizeJsonObject', () => {
-        it('should normalize strings with case and whitespace options', () => {
-            const obj = { name: '  John DOE  ', items: ['A', 'B', 'C'] };
-            const normalized = normalizeJsonObject(obj, {
-                ignoreCase: true,
-                ignoreWhitespace: true,
-                ignoreArrayOrder: true,
-            });
-            expect(normalized.name).toBe('john doe');
-            expect(normalized.items).toEqual(['a', 'b', 'c']); // Sorted alphabetically and case normalized
-        });
-        it('should sort object keys', () => {
-            const obj = { c: 3, a: 1, b: 2 };
-            const normalized = normalizeJsonObject(obj);
-            expect(Object.keys(normalized)).toEqual(['a', 'b', 'c']);
-        });
-        it('should handle nested objects', () => {
-            const obj = { user: { name: 'John', age: 30 }, meta: { version: '1.0' } };
-            const normalized = normalizeJsonObject(obj);
-            expect(Object.keys(normalized)).toEqual(['meta', 'user']);
-            expect(Object.keys(normalized.user)).toEqual(['age', 'name']);
-        });
-    });
-    describe('getDifferenceSummary', () => {
-        it('should return success message for equal objects', () => {
-            const result = {
-                isEqual: true,
-                differences: [],
-                stats: { totalKeys: 0, differentKeys: 0, missingKeys: 0, extraKeys: 0 },
-            };
-            const summary = getDifferenceSummary(result);
-            expect(summary).toBe('✅ Objects are equivalent');
-        });
-        it('should return detailed summary for different objects', () => {
-            const result = {
-                isEqual: false,
-                differences: [
-                    {
-                        path: 'a',
-                        type: 'different',
-                        value1: 1,
-                        value2: 2,
-                        description: 'Value mismatch',
-                    },
-                    { path: 'b', type: 'missing', value2: 3, description: 'Missing key' },
-                ],
-                stats: { totalKeys: 2, differentKeys: 1, missingKeys: 1, extraKeys: 0 },
-            };
-            const summary = getDifferenceSummary(result);
-            expect(summary).toContain('❌ Objects differ');
-            expect(summary).toContain('Total keys: 2');
-            expect(summary).toContain('Different values: 1');
-            expect(summary).toContain('Missing keys: 1');
-            expect(summary).toContain('a: Value mismatch');
-            expect(summary).toContain('b: Missing key');
-        });
-        it('should limit displayed differences to 10', () => {
-            const differences = Array.from({ length: 15 }, (_, i) => ({
-                path: `key${i}`,
-                type: 'different',
-                value1: i,
-                value2: i + 1,
-                description: `Difference ${i}`,
-            }));
-            const result = {
-                isEqual: false,
-                differences,
-                stats: { totalKeys: 15, differentKeys: 15, missingKeys: 0, extraKeys: 0 },
-            };
-            const summary = getDifferenceSummary(result);
-            expect(summary).toContain('... and 5 more differences');
-        });
-    });
-});

package/dist/__tests__/utils/ts-loader.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/utils/ts-loader.test.js

@@ -1,232 +0,0 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { loadTypeScriptModule } from '../../utils/ts-loader.js';
-describe('TypeScript Loader', () => {
-    let testDir;
-    let testGraphFile;
-    beforeEach(() => {
-        // Create a unique test directory with process ID to avoid conflicts
-        const uniqueId = `${process.pid}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-        testDir = join(tmpdir(), 'ts-loader-test', uniqueId);
-        mkdirSync(testDir, { recursive: true });
-        testGraphFile = join(testDir, 'test-graph.ts');
-    });
-    afterEach(async () => {
-        // Small delay to ensure file handles are released
-        await new Promise(resolve => setTimeout(resolve, 50));
-        // Clean up test directory with retries
-        if (existsSync(testDir)) {
-            rmSync(testDir, { recursive: true, force: true, maxRetries: 3 });
-        }
-    });
-    describe('loadTypeScriptModule', () => {
-        it('should load a simple TypeScript module with exports', async () => {
-            // Create a simple test module
-            const moduleContent = `
-export const simpleValue = 'test-value';
-export const numberValue = 42;
-export const booleanValue = true;
-
-export function testFunction() {
-    return 'hello world';
-}
-
-export const testObject = {
-    id: 'test-id',
-    name: 'Test Object',
-    description: 'A test object for testing',
-    port: 3000,
-};
-`;
-            writeFileSync(testGraphFile, moduleContent);
-            const result = await loadTypeScriptModule(testGraphFile);
-            expect(result.simpleValue).toBe('test-value');
-            expect(result.numberValue).toBe(42);
-            expect(result.booleanValue).toBe(true);
-            expect(result.testFunction).toEqual({
-                __type: 'function',
-                name: 'testFunction',
-            });
-            expect(result.testObject).toEqual({
-                __type: 'object',
-                id: 'test-id',
-                name: 'Test Object',
-                description: 'A test object for testing',
-                port: 3000,
-            });
-        });
-        it('should handle array exports', async () => {
-            const moduleContent = `
-export const servers = [
-    {
-        id: 'server1',
-        name: 'Test Server 1',
-        port: 3001,
-        deployment: 'local'
-    },
-    {
-        id: 'server2', 
-        name: 'Test Server 2',
-        serverUrl: 'http://localhost:3002',
-        deployment: 'remote'
-    }
-];
-
-export const simpleArray = ['item1', 'item2', 'item3'];
-`;
-            writeFileSync(testGraphFile, moduleContent);
-            const result = await loadTypeScriptModule(testGraphFile);
-            expect(result.servers.__type).toBe('array');
-            expect(result.servers.items).toHaveLength(2);
-            expect(result.servers.items[0]).toEqual({
-                id: 'server1',
-                name: 'Test Server 1',
-                port: 3001,
-                deployment: 'local',
-            });
-            expect(result.servers.items[1]).toEqual({
-                id: 'server2',
-                name: 'Test Server 2',
-                serverUrl: 'http://localhost:3002',
-                deployment: 'remote',
-            });
-            expect(result.simpleArray.__type).toBe('array');
-            expect(result.simpleArray.items).toEqual(['item1', 'item2', 'item3']);
-        });
-        it('should handle objects with methods', async () => {
-            const moduleContent = `
-export const toolWithMethods = {
-    id: 'tool-with-methods',
-    name: 'Tool With Methods',
-    
-    execute() {
-        return 'executed';
-    },
-    
-    init() {
-        return 'initialized';
-    },
-    
-    getServerUrl() {
-        return 'http://localhost:3000';
-    }
-};
-
-export const graphObject = {
-    getId() {
-        return 'test-graph-id';
-    }
-};
-`;
-            writeFileSync(testGraphFile, moduleContent);
-            const result = await loadTypeScriptModule(testGraphFile);
-            expect(result.toolWithMethods).toEqual({
-                __type: 'object',
-                id: 'tool-with-methods',
-                name: 'Tool With Methods',
-                hasExecute: true,
-                hasInit: true,
-                hasGetServerUrl: true,
-            });
-            expect(result.graphObject).toEqual({
-                __type: 'object',
-                graphId: 'test-graph-id',
-            });
-        });
-        it('should handle module loading errors gracefully', async () => {
-            // Create a module with syntax errors
-            const moduleContent = `
-export const badSyntax = {
-    // Missing closing brace
-    id: 'test'
-`;
-            writeFileSync(testGraphFile, moduleContent);
-            await expect(loadTypeScriptModule(testGraphFile)).rejects.toThrow();
-        });
-        it('should handle non-existent files', async () => {
-            const nonExistentFile = join(testDir, 'non-existent.ts');
-            await expect(loadTypeScriptModule(nonExistentFile)).rejects.toThrow();
-        });
-        it('should handle empty modules', async () => {
-            writeFileSync(testGraphFile, '');
-            const result = await loadTypeScriptModule(testGraphFile);
-            // Empty modules may have a default export object
-            expect(result).toEqual(expect.objectContaining({
-                default: expect.objectContaining({
-                    __type: 'object',
-                }),
-            }));
-        });
-        it('should handle complex nested objects', async () => {
-            const moduleContent = `
-export const complexConfig = {
-    servers: [
-        {
-            id: 'nested-server',
-            name: 'Nested Server',
-            transport: 'http',
-            deployment: 'local'
-        }
-    ],
-    metadata: {
-        version: '1.0.0',
-        author: 'test'
-    }
-};
-`;
-            writeFileSync(testGraphFile, moduleContent);
-            const result = await loadTypeScriptModule(testGraphFile);
-            expect(result.complexConfig.__type).toBe('object');
-            // Note: The loader has specific handling for certain property names
-            // It may not serialize arbitrary nested structures completely
-        });
-        it('should use test environment defaults when no environment is set', async () => {
-            // Clear environment variables that might affect the test
-            const originalEnv = process.env.ENVIRONMENT;
-            delete process.env.ENVIRONMENT;
-            const moduleContent = `
-export const envValue = process.env.ENVIRONMENT;
-export const dbFileName = process.env.DB_FILE_NAME;
-`;
-            writeFileSync(testGraphFile, moduleContent);
-            try {
-                const result = await loadTypeScriptModule(testGraphFile);
-                // The loader should set test defaults
-                expect(result.envValue).toBe('test');
-                expect(result.dbFileName).toBe(':memory:');
-                expect(result.tenantId).toBe('test-tenant');
-            }
-            finally {
-                if (originalEnv !== undefined) {
-                    process.env.ENVIRONMENT = originalEnv;
-                }
-            }
-        });
-        it('should preserve existing environment variables', async () => {
-            const originalEnv = process.env.ENVIRONMENT;
-            process.env.ENVIRONMENT = 'production';
-            process.env.CUSTOM_VAR = 'custom-value';
-            const moduleContent = `
-export const envValue = process.env.ENVIRONMENT;
-export const customVar = process.env.CUSTOM_VAR;
-`;
-            writeFileSync(testGraphFile, moduleContent);
-            try {
-                const result = await loadTypeScriptModule(testGraphFile);
-                expect(result.envValue).toBe('production');
-                expect(result.customVar).toBe('custom-value');
-            }
-            finally {
-                if (originalEnv !== undefined) {
-                    process.env.ENVIRONMENT = originalEnv;
-                }
-                else {
-                    delete process.env.ENVIRONMENT;
-                }
-                delete process.env.CUSTOM_VAR;
-            }
-        });
-    });
-});

package/dist/api.d.ts

@@ -1,23 +0,0 @@
-declare abstract class BaseApiClient {
-    protected apiUrl: string;
-    protected tenantId: string | undefined;
-    protected projectId: string;
-    protected constructor(apiUrl: string, tenantId: string | undefined, projectId: string);
-    protected checkTenantId(): string;
-    getTenantId(): string | undefined;
-    getProjectId(): string;
-    getApiUrl(): string;
-}
-export declare class ManagementApiClient extends BaseApiClient {
-    private constructor();
-    static create(apiUrl?: string, configPath?: string, tenantIdOverride?: string, projectIdOverride?: string): Promise<ManagementApiClient>;
-    listGraphs(): Promise<any[]>;
-    getGraph(graphId: string): Promise<any>;
-    pushGraph(graphDefinition: any): Promise<any>;
-}
-export declare class ExecutionApiClient extends BaseApiClient {
-    private constructor();
-    static create(apiUrl?: string, configPath?: string, tenantIdOverride?: string, projectIdOverride?: string): Promise<ExecutionApiClient>;
-    chatCompletion(graphId: string, messages: any[], conversationId?: string): Promise<ReadableStream<Uint8Array> | string>;
-}
-export {};