connectonion 0.0.1

package/dist/examples/comprehensive-test.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * Comprehensive test to verify all ConnectOnion functionality
+ * This tests core logic, error handling, and edge cases
+ */
+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 });
+const src_1 = require("../src");
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+// Test counters
+let testsPassed = 0;
+let testsFailed = 0;
+function assert(condition, message) {
+    if (condition) {
+        console.log(`✅ ${message}`);
+        testsPassed++;
+    }
+    else {
+        console.error(`❌ ${message}`);
+        testsFailed++;
+    }
+}
+async function testBasicToolConversion() {
+    console.log('\n🧪 Testing Basic Tool Conversion...');
+    // Test 1: Simple function conversion
+    function add(a, b) {
+        return a + b;
+    }
+    const tool = (0, src_1.createToolFromFunction)(add);
+    assert(tool.name === 'add', 'Tool name should be "add"');
+    assert(tool.description === 'Execute the add tool.', 'Default description should be set');
+    const result = tool.run({ a: 5, b: 3 });
+    assert(result === 8, 'Tool should calculate 5 + 3 = 8');
+    // Test 2: Function with JSDoc
+    function multiply(x, y) {
+        /** Multiply two numbers */
+        return x * y;
+    }
+    const tool2 = (0, src_1.createToolFromFunction)(multiply);
+    const schema = tool2.toFunctionSchema();
+    assert(schema.name === 'multiply', 'Schema name should match function name');
+    assert(schema.parameters.properties.hasOwnProperty('x'), 'Should have parameter x');
+    assert(schema.parameters.properties.hasOwnProperty('y'), 'Should have parameter y');
+}
+async function testClassTools() {
+    console.log('\n🧪 Testing Class-based Tools...');
+    class Calculator {
+        constructor() {
+            this.state = 0;
+        }
+        add(value) {
+            this.state += value;
+            return this.state;
+        }
+        subtract(value) {
+            this.state -= value;
+            return this.state;
+        }
+        getState() {
+            return this.state;
+        }
+        _reset() {
+            this.state = 0;
+        }
+    }
+    const calc = new Calculator();
+    const tools = (0, src_1.extractMethodsFromInstance)(calc);
+    assert(tools.length === 3, 'Should extract 3 public methods (not private ones)');
+    assert(tools.some(t => t.name === 'add'), 'Should have add method');
+    assert(tools.some(t => t.name === 'subtract'), 'Should have subtract method');
+    assert(!tools.some(t => t.name === '_reset'), 'Should not extract private methods');
+    // Test that methods maintain context
+    const addTool = tools.find(t => t.name === 'add');
+    const stateTool = tools.find(t => t.name === 'getState');
+    if (addTool && stateTool) {
+        addTool.run({ value: 10 });
+        const state = stateTool.run({});
+        assert(state === 10, 'Methods should maintain class instance context');
+    }
+}
+async function testAgentCreation() {
+    console.log('\n🧪 Testing Agent Creation...');
+    try {
+        // Test without API key should throw
+        const originalKey = process.env.OPENAI_API_KEY;
+        delete process.env.OPENAI_API_KEY;
+        let errorThrown = false;
+        try {
+            new src_1.Agent({ name: 'test' });
+        }
+        catch (e) {
+            errorThrown = true;
+        }
+        assert(errorThrown, 'Should throw error when no API key is provided');
+        // Restore key
+        process.env.OPENAI_API_KEY = originalKey;
+        // Test with API key
+        const agent = new src_1.Agent({
+            name: 'test-agent',
+            systemPrompt: 'Test prompt',
+            maxIterations: 5
+        });
+        assert(agent.getTools().length === 0, 'Agent should start with no tools');
+        // Test adding tools
+        function testTool() {
+            return 'test';
+        }
+        agent.addTool(testTool);
+        assert(agent.getTools().length === 1, 'Should have 1 tool after adding');
+        // Test removing tools
+        agent.removeTool('testTool');
+        assert(agent.getTools().length === 0, 'Should have 0 tools after removing');
+    }
+    catch (error) {
+        console.error('Agent creation test error:', error);
+    }
+}
+async function testErrorHandling() {
+    console.log('\n🧪 Testing Error Handling...');
+    // Test tool that throws error
+    function errorTool() {
+        throw new Error('Tool error!');
+    }
+    const agent = new src_1.Agent({
+        name: 'error-test',
+        tools: [errorTool]
+    });
+    // Test that agent handles tool errors gracefully
+    try {
+        // We can't test actual LLM calls without mocking, but we can test tool execution
+        const tool = agent.getTools()[0];
+        let errorCaught = false;
+        try {
+            tool.run({});
+        }
+        catch (e) {
+            errorCaught = true;
+        }
+        assert(errorCaught, 'Tool.run should throw errors for the agent to handle');
+    }
+    catch (error) {
+        console.error('Error handling test failed:', error);
+    }
+}
+async function testProcessTools() {
+    console.log('\n🧪 Testing processTools Utility...');
+    function func1() { return 'func1'; }
+    function func2() { return 'func2'; }
+    class TestClass {
+        method1() { return 'method1'; }
+        method2() { return 'method2'; }
+    }
+    // Test single function
+    let tools = (0, src_1.processTools)(func1);
+    assert(tools.length === 1, 'Single function should produce 1 tool');
+    // Test array of functions
+    tools = (0, src_1.processTools)([func1, func2]);
+    assert(tools.length === 2, 'Array of 2 functions should produce 2 tools');
+    // Test class instance
+    tools = (0, src_1.processTools)(new TestClass());
+    assert(tools.length === 2, 'Class with 2 methods should produce 2 tools');
+    // Test mixed array
+    tools = (0, src_1.processTools)([func1, new TestClass(), func2]);
+    assert(tools.length === 4, 'Mixed array should produce correct number of tools');
+    // Test empty input
+    tools = (0, src_1.processTools)(null);
+    assert(tools.length === 0, 'Null input should produce empty array');
+    tools = (0, src_1.processTools)(undefined);
+    assert(tools.length === 0, 'Undefined input should produce empty array');
+}
+async function testHistoryTracking() {
+    console.log('\n🧪 Testing History Tracking...');
+    const agent = new src_1.Agent({
+        name: 'history-test-' + Date.now() // Unique name to avoid conflicts
+    });
+    // Initially should be empty
+    let history = agent.getHistory();
+    assert(history.length === 0, 'History should start empty');
+    // Clear history
+    agent.clearHistory();
+    history = agent.getHistory();
+    assert(history.length === 0, 'History should be empty after clear');
+}
+async function testToolWithOptionalParams() {
+    console.log('\n🧪 Testing Tools with Optional Parameters...');
+    function greet(name, title) {
+        return title ? `Hello, ${title} ${name}` : `Hello, ${name}`;
+    }
+    const tool = (0, src_1.createToolFromFunction)(greet);
+    const schema = tool.toFunctionSchema();
+    assert(schema.parameters.required?.includes('name'), 'name should be required');
+    assert(!schema.parameters.required?.includes('title'), 'title should not be required');
+    // Test execution with and without optional param
+    const result1 = tool.run({ name: 'Alice' });
+    assert(result1 === 'Hello, Alice', 'Should work without optional param');
+    const result2 = tool.run({ name: 'Alice', title: 'Dr.' });
+    assert(result2 === 'Hello, Dr. Alice', 'Should work with optional param');
+}
+async function testAsyncTools() {
+    console.log('\n🧪 Testing Async Tools...');
+    async function asyncTool(delay) {
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return `Waited ${delay}ms`;
+    }
+    const tool = (0, src_1.createToolFromFunction)(asyncTool);
+    const result = await tool.run({ delay: 10 });
+    assert(result === 'Waited 10ms', 'Async tool should work correctly');
+}
+async function testToolNaming() {
+    console.log('\n🧪 Testing Tool Naming...');
+    // Test regular function
+    function myFunction() { }
+    let tool = (0, src_1.createToolFromFunction)(myFunction);
+    assert(tool.name === 'myFunction', 'Regular function name should be preserved');
+    // Test arrow function with name
+    const namedArrow = function arrowFunc() { };
+    tool = (0, src_1.createToolFromFunction)(namedArrow);
+    assert(tool.name === 'arrowFunc', 'Named arrow function should preserve name');
+    // Test anonymous function
+    tool = (0, src_1.createToolFromFunction)(function () { });
+    assert(tool.name === 'anonymous', 'Anonymous function should be named "anonymous"');
+}
+async function testEdgeCases() {
+    console.log('\n🧪 Testing Edge Cases...');
+    // Test function with no parameters
+    function noParams() {
+        return 'no params';
+    }
+    const tool1 = (0, src_1.createToolFromFunction)(noParams);
+    const result1 = tool1.run({});
+    assert(result1 === 'no params', 'Function with no params should work');
+    // Test function returning different types
+    function returnObject() {
+        return { key: 'value' };
+    }
+    const tool2 = (0, src_1.createToolFromFunction)(returnObject);
+    const result2 = tool2.run({});
+    assert(typeof result2 === 'object' && result2.key === 'value', 'Should handle object return');
+    // Test function returning null
+    function returnNull() {
+        return null;
+    }
+    const tool3 = (0, src_1.createToolFromFunction)(returnNull);
+    const result3 = tool3.run({});
+    assert(result3 === null, 'Should handle null return');
+}
+// Main test runner
+async function runAllTests() {
+    console.log('🚀 Starting Comprehensive ConnectOnion Tests\n');
+    console.log('='.repeat(50));
+    try {
+        await testBasicToolConversion();
+        await testClassTools();
+        await testAgentCreation();
+        await testErrorHandling();
+        await testProcessTools();
+        await testHistoryTracking();
+        await testToolWithOptionalParams();
+        await testAsyncTools();
+        await testToolNaming();
+        await testEdgeCases();
+    }
+    catch (error) {
+        console.error('\n❌ Test suite failed with error:', error);
+        testsFailed++;
+    }
+    console.log('\n' + '='.repeat(50));
+    console.log('📊 Test Results:');
+    console.log(`✅ Passed: ${testsPassed}`);
+    console.log(`❌ Failed: ${testsFailed}`);
+    console.log(`📈 Success Rate: ${((testsPassed / (testsPassed + testsFailed)) * 100).toFixed(1)}%`);
+    if (testsFailed === 0) {
+        console.log('\n🎉 All tests passed! The SDK is working correctly.');
+    }
+    else {
+        console.log('\n⚠️  Some tests failed. Please review the errors above.');
+        process.exit(1);
+    }
+}
+// Run tests
+runAllTests().catch(console.error);

package/dist/examples/simple-test.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Simple Test Example
+ * Tests the agent with actual OpenAI API
+ */
+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 });
+const src_1 = require("../src");
+const dotenv = __importStar(require("dotenv"));
+// Load environment variables
+dotenv.config();
+// Define a simple calculator tool
+function add(a, b) {
+    /** Add two numbers together */
+    return a + b;
+}
+function multiply(a, b) {
+    /** Multiply two numbers */
+    return a * b;
+}
+async function main() {
+    console.log('Creating agent with OpenAI integration...');
+    try {
+        // Create an agent with tools
+        const agent = new src_1.Agent({
+            name: 'calculator',
+            tools: [add, multiply],
+            systemPrompt: 'You are a helpful calculator assistant. Use the provided tools to solve math problems.',
+            model: 'gpt-4o-mini'
+        });
+        console.log('Agent created successfully!');
+        console.log('Available tools:', agent.getTools().map(t => t.name).join(', '));
+        console.log('\nTesting calculation...');
+        // Test a simple calculation
+        const response = await agent.input('What is 15 plus 27, and then multiply the result by 2?');
+        console.log('\nAgent response:', response);
+        // Check history
+        const history = agent.getHistory();
+        console.log('\nNumber of history entries:', history.length);
+        console.log('\n✅ Test completed successfully!');
+    }
+    catch (error) {
+        console.error('❌ Error:', error);
+        process.exit(1);
+    }
+}
+// Run the test
+main().catch(console.error);

package/dist/history/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * History tracking for ConnectOnion TypeScript SDK
+ */
+import { BehaviorEntry } from '../types';
+export declare class History {
+    private behaviorPath;
+    private behaviors;
+    constructor(name: string);
+    /**
+     * Add an entry to the behavior history
+     */
+    add(type: BehaviorEntry['type'], data: any): void;
+    /**
+     * Add input to history
+     */
+    addInput(prompt: string): void;
+    /**
+     * Add LLM response to history
+     */
+    addLLMResponse(response: any): void;
+    /**
+     * Add tool call to history
+     */
+    addToolCall(name: string, args: any, result: any, callId: string): void;
+    /**
+     * Add output to history
+     */
+    addOutput(output: string): void;
+    /**
+     * Get all behaviors
+     */
+    getBehaviors(): BehaviorEntry[];
+    /**
+     * Clear history
+     */
+    clear(): void;
+    /**
+     * Save behaviors to file
+     */
+    private save;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/history/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/history/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,qBAAa,OAAO;IAClB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,SAAS,CAAuB;gBAE5B,IAAI,EAAE,MAAM;IAgCxB;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAWjD;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI9B;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;IAInC;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IASvE;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B;;OAEG;IACH,YAAY,IAAI,aAAa,EAAE;IAI/B;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,OAAO,CAAC,IAAI;CAWb"}

package/dist/history/index.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * History tracking for ConnectOnion TypeScript SDK
+ */
+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 });
+exports.History = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class History {
+    constructor(name) {
+        this.behaviors = [];
+        // Set up behavior tracking directory
+        const homeDir = os.homedir();
+        const connectonionDir = path.join(homeDir, '.connectonion', 'agents', name);
+        // Create directory if it doesn't exist
+        if (!fs.existsSync(connectonionDir)) {
+            fs.mkdirSync(connectonionDir, { recursive: true });
+        }
+        this.behaviorPath = path.join(connectonionDir, 'behavior.json');
+        // Load existing behaviors if file exists
+        if (fs.existsSync(this.behaviorPath)) {
+            try {
+                const data = fs.readFileSync(this.behaviorPath, 'utf-8');
+                const parsed = JSON.parse(data);
+                // Ensure behaviors is always an array
+                if (Array.isArray(parsed)) {
+                    this.behaviors = parsed;
+                }
+                else {
+                    console.warn('Behavior file does not contain an array, initializing empty');
+                    this.behaviors = [];
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to load existing behaviors: ${error}`);
+                this.behaviors = [];
+            }
+        }
+    }
+    /**
+     * Add an entry to the behavior history
+     */
+    add(type, data) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            type,
+            data,
+        };
+        this.behaviors.push(entry);
+        this.save();
+    }
+    /**
+     * Add input to history
+     */
+    addInput(prompt) {
+        this.add('input', { prompt });
+    }
+    /**
+     * Add LLM response to history
+     */
+    addLLMResponse(response) {
+        this.add('llm_response', response);
+    }
+    /**
+     * Add tool call to history
+     */
+    addToolCall(name, args, result, callId) {
+        this.add('tool_call', {
+            name,
+            arguments: args,
+            result,
+            call_id: callId,
+        });
+    }
+    /**
+     * Add output to history
+     */
+    addOutput(output) {
+        this.add('output', { output });
+    }
+    /**
+     * Get all behaviors
+     */
+    getBehaviors() {
+        return this.behaviors;
+    }
+    /**
+     * Clear history
+     */
+    clear() {
+        this.behaviors = [];
+        this.save();
+    }
+    /**
+     * Save behaviors to file
+     */
+    save() {
+        try {
+            fs.writeFileSync(this.behaviorPath, JSON.stringify(this.behaviors, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error(`Failed to save behaviors: ${error}`);
+        }
+    }
+}
+exports.History = History;

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @purpose Public API entry point that exports all SDK components (Agent, LLM providers, tool utilities, trust system, types)
+ * @llm-note
+ *   Dependencies: imports from [src/core/agent, src/llm/*, src/tools/*, src/trust/*, src/types] | imported by external consumers | tested by all test files
+ *   Data flow: no runtime logic, pure re-exports → external code imports from here → provides unified API surface
+ *   State/Effects: no state or side effects | static exports only
+ *   Integration: exposes Agent, createLLM, all LLM providers (OpenAILLM, AnthropicLLM, GeminiLLM), tool utils (xray, processTools, etc), trust system, all types | single source of truth for SDK imports
+ */
+export { Agent } from './core/agent';
+export { createLLM, OpenAILLM, AnthropicLLM, GeminiLLM } from './llm';
+export { createToolFromFunction, isClassInstance, extractMethodsFromInstance, processTools, xray, } from './tools/tool-utils';
+export { trace as xrayTrace } from './tools/xray';
+export { withReplay, xrayReplay, replay } from './tools/replay';
+export * from './tools/email';
+export * from './trust';
+export * from './trust/tools';
+export * from './types';
+export { llmDo } from './llm/llm-do';
+export { connect, RemoteAgent } from './connect';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACtE,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,0BAA0B,EAC1B,YAAY,EACZ,IAAI,GACL,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAChE,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAE9B,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * @purpose Public API entry point that exports all SDK components (Agent, LLM providers, tool utilities, trust system, types)
+ * @llm-note
+ *   Dependencies: imports from [src/core/agent, src/llm/*, src/tools/*, src/trust/*, src/types] | imported by external consumers | tested by all test files
+ *   Data flow: no runtime logic, pure re-exports → external code imports from here → provides unified API surface
+ *   State/Effects: no state or side effects | static exports only
+ *   Integration: exposes Agent, createLLM, all LLM providers (OpenAILLM, AnthropicLLM, GeminiLLM), tool utils (xray, processTools, etc), trust system, all types | single source of truth for SDK imports
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteAgent = exports.connect = exports.llmDo = exports.replay = exports.xrayReplay = exports.withReplay = exports.xrayTrace = exports.xray = exports.processTools = exports.extractMethodsFromInstance = exports.isClassInstance = exports.createToolFromFunction = exports.GeminiLLM = exports.AnthropicLLM = exports.OpenAILLM = exports.createLLM = exports.Agent = void 0;
+var agent_1 = require("./core/agent");
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });
+var llm_1 = require("./llm");
+Object.defineProperty(exports, "createLLM", { enumerable: true, get: function () { return llm_1.createLLM; } });
+Object.defineProperty(exports, "OpenAILLM", { enumerable: true, get: function () { return llm_1.OpenAILLM; } });
+Object.defineProperty(exports, "AnthropicLLM", { enumerable: true, get: function () { return llm_1.AnthropicLLM; } });
+Object.defineProperty(exports, "GeminiLLM", { enumerable: true, get: function () { return llm_1.GeminiLLM; } });
+var tool_utils_1 = require("./tools/tool-utils");
+Object.defineProperty(exports, "createToolFromFunction", { enumerable: true, get: function () { return tool_utils_1.createToolFromFunction; } });
+Object.defineProperty(exports, "isClassInstance", { enumerable: true, get: function () { return tool_utils_1.isClassInstance; } });
+Object.defineProperty(exports, "extractMethodsFromInstance", { enumerable: true, get: function () { return tool_utils_1.extractMethodsFromInstance; } });
+Object.defineProperty(exports, "processTools", { enumerable: true, get: function () { return tool_utils_1.processTools; } });
+Object.defineProperty(exports, "xray", { enumerable: true, get: function () { return tool_utils_1.xray; } });
+var xray_1 = require("./tools/xray");
+Object.defineProperty(exports, "xrayTrace", { enumerable: true, get: function () { return xray_1.trace; } });
+var replay_1 = require("./tools/replay");
+Object.defineProperty(exports, "withReplay", { enumerable: true, get: function () { return replay_1.withReplay; } });
+Object.defineProperty(exports, "xrayReplay", { enumerable: true, get: function () { return replay_1.xrayReplay; } });
+Object.defineProperty(exports, "replay", { enumerable: true, get: function () { return replay_1.replay; } });
+__exportStar(require("./tools/email"), exports);
+__exportStar(require("./trust"), exports);
+__exportStar(require("./trust/tools"), exports);
+__exportStar(require("./types"), exports);
+var llm_do_1 = require("./llm/llm-do");
+Object.defineProperty(exports, "llmDo", { enumerable: true, get: function () { return llm_do_1.llmDo; } });
+var connect_1 = require("./connect");
+Object.defineProperty(exports, "connect", { enumerable: true, get: function () { return connect_1.connect; } });
+Object.defineProperty(exports, "RemoteAgent", { enumerable: true, get: function () { return connect_1.RemoteAgent; } });