connectonion 0.0.1

package/dist/tools/xray.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @purpose Debugging context injection system for @xray decorated tools (migrated from Python xray.py - simplified version)
+ * @llm-note
+ *   Dependencies: none (leaf node) | imported by [src/core/agent.ts, src/index.ts] | tested by [examples/test-migrations.ts]
+ *   Data flow: receives from Agent → injectXrayContext(agent, userPrompt, messages, iteration, previousTools) → stores in module-scoped xrayContext → tools access via getXrayContext() → clearXrayContext() after execution
+ *   State/Effects: mutates module-scoped xrayContext object | no file I/O | context cleared after tool execution to prevent leakage
+ *   Integration: exposes injectXrayContext(), clearXrayContext(), isXrayEnabled(func), getXrayContext(), trace(), XrayContext interface | used by Agent before/after tool execution | trace() displays visual execution history
+ *   Performance: lightweight in-memory context storage | trace() uses console.error for stderr-style output
+ *   Errors: trace() throws if no active agent context or empty execution history
+ */
+/**
+ * Xray context interface - made available globally during tool execution
+ */
+export interface XrayContext {
+    agent: any | null;
+    task: string | null;
+    userPrompt: string | null;
+    messages: any[];
+    iteration: number | null;
+    previousTools: string[];
+}
+/**
+ * Inject debugging context before tool execution
+ *
+ * Migrated from Python xray.py:430-445
+ *
+ * @param agent - The Agent instance
+ * @param userPrompt - Original user prompt string from agent.input()
+ * @param messages - Conversation history
+ * @param iteration - Current iteration number
+ * @param previousTools - List of previously called tool names
+ */
+export declare function injectXrayContext(agent: any, userPrompt: string, messages: any[], iteration: number, previousTools: string[]): void;
+/**
+ * Clear debugging context after tool execution
+ *
+ * Migrated from Python xray.py:448-454
+ */
+export declare function clearXrayContext(): void;
+/**
+ * Check if a function has the @xray decorator
+ *
+ * Migrated from Python xray.py:457-467
+ *
+ * @param func - Function to check
+ * @returns True if function is decorated with @xray
+ */
+export declare function isXrayEnabled(func: any): boolean;
+/**
+ * Get current xray context (for tools to access)
+ */
+export declare function getXrayContext(): XrayContext;
+/**
+ * Print a visual trace of tool execution using the current xray context.
+ * Throws if no active context is available.
+ */
+export declare function trace(): void;
+//# sourceMappingURL=xray.d.ts.map

package/dist/tools/xray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xray.d.ts","sourceRoot":"","sources":["../../src/tools/xray.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,GAAG,GAAG,IAAI,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,GAAG,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAcD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,GAAG,EACV,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,GAAG,EAAE,EACf,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EAAE,GACtB,IAAI,CAON;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAOvC;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAEhD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,WAAW,CAE5C;AAED;;;GAGG;AACH,wBAAgB,KAAK,IAAI,IAAI,CA4B5B"}

package/dist/tools/xray.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * @purpose Debugging context injection system for @xray decorated tools (migrated from Python xray.py - simplified version)
+ * @llm-note
+ *   Dependencies: none (leaf node) | imported by [src/core/agent.ts, src/index.ts] | tested by [examples/test-migrations.ts]
+ *   Data flow: receives from Agent → injectXrayContext(agent, userPrompt, messages, iteration, previousTools) → stores in module-scoped xrayContext → tools access via getXrayContext() → clearXrayContext() after execution
+ *   State/Effects: mutates module-scoped xrayContext object | no file I/O | context cleared after tool execution to prevent leakage
+ *   Integration: exposes injectXrayContext(), clearXrayContext(), isXrayEnabled(func), getXrayContext(), trace(), XrayContext interface | used by Agent before/after tool execution | trace() displays visual execution history
+ *   Performance: lightweight in-memory context storage | trace() uses console.error for stderr-style output
+ *   Errors: trace() throws if no active agent context or empty execution history
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectXrayContext = injectXrayContext;
+exports.clearXrayContext = clearXrayContext;
+exports.isXrayEnabled = isXrayEnabled;
+exports.getXrayContext = getXrayContext;
+exports.trace = trace;
+/**
+ * Global xray context storage
+ */
+let xrayContext = {
+    agent: null,
+    task: null,
+    userPrompt: null,
+    messages: [],
+    iteration: null,
+    previousTools: []
+};
+/**
+ * Inject debugging context before tool execution
+ *
+ * Migrated from Python xray.py:430-445
+ *
+ * @param agent - The Agent instance
+ * @param userPrompt - Original user prompt string from agent.input()
+ * @param messages - Conversation history
+ * @param iteration - Current iteration number
+ * @param previousTools - List of previously called tool names
+ */
+function injectXrayContext(agent, userPrompt, messages, iteration, previousTools) {
+    xrayContext.agent = agent;
+    xrayContext.task = userPrompt;
+    xrayContext.userPrompt = userPrompt;
+    xrayContext.messages = messages;
+    xrayContext.iteration = iteration;
+    xrayContext.previousTools = previousTools;
+}
+/**
+ * Clear debugging context after tool execution
+ *
+ * Migrated from Python xray.py:448-454
+ */
+function clearXrayContext() {
+    xrayContext.agent = null;
+    xrayContext.task = null;
+    xrayContext.userPrompt = null;
+    xrayContext.messages = [];
+    xrayContext.iteration = null;
+    xrayContext.previousTools = [];
+}
+/**
+ * Check if a function has the @xray decorator
+ *
+ * Migrated from Python xray.py:457-467
+ *
+ * @param func - Function to check
+ * @returns True if function is decorated with @xray
+ */
+function isXrayEnabled(func) {
+    return func.__xray__ === true;
+}
+/**
+ * Get current xray context (for tools to access)
+ */
+function getXrayContext() {
+    return xrayContext;
+}
+/**
+ * Print a visual trace of tool execution using the current xray context.
+ * Throws if no active context is available.
+ */
+function trace() {
+    if (!xrayContext.agent) {
+        throw new Error('xray.trace(): no active agent context');
+    }
+    const agent = xrayContext.agent;
+    const task = xrayContext.task || '';
+    const history = agent.trace || [];
+    if (!Array.isArray(history) || history.length === 0) {
+        throw new Error('xray.trace(): no tool execution history');
+    }
+    const head = `Task: ${task}`;
+    // Emit compact, readable lines similar to Python output
+    const lines = [head, ''];
+    history.forEach((h, idx) => {
+        const ms = typeof h.timing === 'number' ? h.timing : 0;
+        const timeStr = ms < 100 ? `${(ms / 1000).toFixed(4)}s` : `${(ms / 1000).toFixed(1)}s`;
+        const argsPreview = JSON.stringify(h.args ?? {});
+        const shortArgs = argsPreview.length > 120 ? argsPreview.slice(0, 120) + '...' : argsPreview;
+        const resultStr = (h.result === undefined || h.result === null) ? '' : String(h.result);
+        const shortRes = resultStr.length > 120 ? resultStr.slice(0, 120) + '...' : resultStr;
+        const status = h.status === 'error' ? 'ERR ✗' : `• ${timeStr}`;
+        lines.push(`[${idx + 1}] ${status}  ${h.tool_name}(${shortArgs})`);
+        if (shortRes)
+            lines.push(`      OUT ← ${shortRes}`);
+    });
+    lines.push('');
+    // Print to stderr-style to match Console behavior
+    console.error(lines.join('\n'));
+}

package/dist/trust/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @purpose Trust-level configuration system (open/careful/strict) with environment-based defaults and prompt templates for future trust agent integration
+ * @llm-note
+ *   Dependencies: no imports (leaf node) | imported by [src/core/agent.ts] | no tests yet (configuration layer)
+ *   Data flow: receives trust level string or object → returns trust config with level + prompt → used by Agent constructor
+ *   State/Effects: reads env CONNECTONION_TRUST | no state mutations | pure functions
+ *   Integration: exposes createTrustAgent(trust, apiKey, model), getDefaultTrustLevel(), getTrustPrompt(level), TrustLevel type | default level: 'careful' | prompts define trust agent behavior for future policy evaluation
+ *   ⚠️ Trust agent not yet implemented - returns config object only | future: could return Agent instance for runtime policy checks
+ */
+export type TrustLevel = 'open' | 'careful' | 'strict';
+export declare function getDefaultTrustLevel(): TrustLevel;
+export declare function getTrustPrompt(level: TrustLevel): string;
+/**
+ * Create a trust agent or configuration object.
+ * For now, return a lightweight object with level and prompt.
+ * Future: could return an Agent instance for policy evaluation.
+ */
+export declare function createTrustAgent(trust?: TrustLevel | {
+    level: TrustLevel;
+    prompt?: string;
+}, _apiKey?: string, _model?: string): {
+    level: TrustLevel;
+    prompt: string;
+    name: string;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trust/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;AAevD,wBAAgB,oBAAoB,IAAI,UAAU,CAIjD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAExD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,CAAC,EAAE,UAAU,GAAG;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EAC3D,OAAO,CAAC,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM;;;;EAMhB"}

package/dist/trust/index.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * @purpose Trust-level configuration system (open/careful/strict) with environment-based defaults and prompt templates for future trust agent integration
+ * @llm-note
+ *   Dependencies: no imports (leaf node) | imported by [src/core/agent.ts] | no tests yet (configuration layer)
+ *   Data flow: receives trust level string or object → returns trust config with level + prompt → used by Agent constructor
+ *   State/Effects: reads env CONNECTONION_TRUST | no state mutations | pure functions
+ *   Integration: exposes createTrustAgent(trust, apiKey, model), getDefaultTrustLevel(), getTrustPrompt(level), TrustLevel type | default level: 'careful' | prompts define trust agent behavior for future policy evaluation
+ *   ⚠️ Trust agent not yet implemented - returns config object only | future: could return Agent instance for runtime policy checks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultTrustLevel = getDefaultTrustLevel;
+exports.getTrustPrompt = getTrustPrompt;
+exports.createTrustAgent = createTrustAgent;
+const TRUST_PROMPTS = {
+    open: `You are an open trust agent for development environments.
+You trust agents to enable rapid iteration and testing.
+Use best effort checks but prioritize developer velocity.`,
+    careful: `You are a careful trust agent for staging/testing.
+Verify agent identity and intent before approval:
+1) Require clear purpose, 2) Sanity-check tools, 3) Review consent.
+Reject risky actions without context.`,
+    strict: `You are a strict trust agent for production.
+Only approve actions for pre-approved agents and tools.
+Enforce least privilege and strong provenance.`
+};
+function getDefaultTrustLevel() {
+    const env = (process.env.CONNECTONION_TRUST || '').toLowerCase();
+    if (env === 'open' || env === 'careful' || env === 'strict')
+        return env;
+    return 'careful';
+}
+function getTrustPrompt(level) {
+    return TRUST_PROMPTS[level];
+}
+/**
+ * Create a trust agent or configuration object.
+ * For now, return a lightweight object with level and prompt.
+ * Future: could return an Agent instance for policy evaluation.
+ */
+function createTrustAgent(trust, _apiKey, _model) {
+    if (!trust)
+        trust = getDefaultTrustLevel();
+    const level = typeof trust === 'string' ? trust : trust.level;
+    const prompt = typeof trust === 'string' ? getTrustPrompt(trust) : trust.prompt || getTrustPrompt(trust.level);
+    return { level, prompt, name: `trust_agent_${level}` };
+}

package/dist/trust/tools.d.ts

@@ -0,0 +1,4 @@
+export declare function checkWhitelist(agentId: string): string;
+export declare function testCapability(agentId: string, test: string, expected: string): string;
+export declare function verifyAgent(agentId: string, agentInfo?: string): string;
+//# sourceMappingURL=tools.d.ts.map

package/dist/trust/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/trust/tools.ts"],"names":[],"mappings":"AAcA,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAUtD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEtF;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,MAAW,GAAG,MAAM,CAG3E"}

package/dist/trust/tools.js

@@ -0,0 +1,71 @@
+"use strict";
+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.checkWhitelist = checkWhitelist;
+exports.testCapability = testCapability;
+exports.verifyAgent = verifyAgent;
+/**
+ * @purpose Trust verification tools for whitelist checks and capability testing (minimal Python parity)
+ * @llm-note
+ *   Dependencies: imports from [fs, os, path (Node.js built-ins)] | imported by [src/index.ts] | tested manually
+ *   Data flow: checkWhitelist(agentId) → reads ~/.connectonion/trusted.txt → matches agentId against patterns (* wildcard, prefix*) → returns allow/deny string | testCapability(agentId, test, expected) → verifies expected behavior
+ *   State/Effects: reads ~/.connectonion/trusted.txt synchronously | throws on missing file | no writes
+ *   Integration: exposes checkWhitelist(agentId), testCapability(agentId, test, expected) | can be added as tools to trust agents | supports '*' for all and 'prefix*' for wildcards
+ *   Performance: reads entire trusted.txt file per check | no caching | synchronous fs.readFileSync
+ *   Errors: throws if ~/.connectonion/trusted.txt missing | pattern matching via string operations
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+function checkWhitelist(agentId) {
+    const file = path.join(os.homedir(), '.connectonion', 'trusted.txt');
+    const data = fs.readFileSync(file, 'utf-8');
+    const lines = data.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+    const ok = lines.some(line => {
+        if (line === '*')
+            return true;
+        if (line.endsWith('*'))
+            return agentId.startsWith(line.slice(0, -1));
+        return line === agentId;
+    });
+    return ok ? `Whitelist: allowed (${agentId})` : `Whitelist: not found (${agentId})`;
+}
+function testCapability(agentId, test, expected) {
+    return `Capability test for ${agentId}: ${test} → expected ${expected}`;
+}
+function verifyAgent(agentId, agentInfo = '') {
+    const info = agentInfo ? ` info=${agentInfo}` : '';
+    return `Verification request for ${agentId}.${info}`;
+}

package/dist/types.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @purpose Core type definitions that provide compile-time safety and IDE support across the entire SDK
+ * @llm-note
+ *   Dependencies: none (leaf node) | imported by [src/core/agent.ts, src/llm/*.ts, src/tools/tool-utils.ts, src/index.ts] | tested by [tests/agent.test.ts]
+ *   Data flow: defines interfaces → used throughout codebase for type checking → no runtime data processing
+ *   State/Effects: pure type definitions, no side effects or state
+ *   Integration: exports all core interfaces (Tool, LLM, Agent, Message, FunctionSchema) | consumed by all modules | OpenAI-compatible message format
+ */
+/**
+ * Represents a tool call request from the LLM
+ * @interface ToolCall
+ */
+export interface ToolCall {
+    /** The name of the tool to call */
+    name: string;
+    /** Arguments to pass to the tool function */
+    arguments: Record<string, any>;
+    /** Unique identifier for this tool call */
+    id: string;
+}
+/**
+ * Response from an LLM completion request
+ * @interface LLMResponse
+ */
+export interface LLMResponse {
+    /** Text content from the LLM (null if only tool calls) */
+    content: string | null;
+    /** Array of tool calls the LLM wants to make */
+    toolCalls: ToolCall[];
+    /** Raw response from the underlying API */
+    rawResponse: any;
+}
+/**
+ * Represents a message in the conversation history
+ * @interface Message
+ */
+export interface Message {
+    /** The role of the message sender */
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    /** The message content */
+    content: string;
+    /** Optional name for the message sender */
+    name?: string;
+    /** Tool calls made by the assistant */
+    tool_calls?: ToolCall[];
+    /** ID linking this message to a specific tool call */
+    tool_call_id?: string;
+}
+/**
+ * OpenAI-compatible function schema for tool definitions
+ * @interface FunctionSchema
+ */
+export interface FunctionSchema {
+    /** The function name */
+    name: string;
+    /** Description of what the function does */
+    description: string;
+    /** JSON Schema for the function parameters */
+    parameters: {
+        /** Always 'object' for function parameters */
+        type: 'object';
+        /** Properties schema for each parameter */
+        properties: Record<string, any>;
+        /** List of required parameter names */
+        required?: string[];
+    };
+}
+/**
+ * Represents a tool that can be used by an agent
+ * @interface Tool
+ */
+export interface Tool {
+    /** Unique name for the tool */
+    name: string;
+    /** Description of what the tool does (shown to LLM) */
+    description: string;
+    /** Function to execute the tool with given arguments */
+    run: (args: Record<string, any>) => Promise<any> | any;
+    /** Converts the tool to an OpenAI function schema */
+    toFunctionSchema: () => FunctionSchema;
+    /** Optional: mark as @xray to pause in debugger */
+    xray?: boolean;
+}
+/**
+ * Result from executing a tool
+ * @interface ToolResult
+ */
+export interface ToolResult {
+    /** Status of the tool execution */
+    status: 'success' | 'error' | 'not_found';
+    /** The result value if successful */
+    result?: any;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Configuration options for creating an Agent
+ * @interface AgentConfig
+ */
+export interface AgentConfig {
+    /** Unique name for the agent (used for behavior tracking) */
+    name: string;
+    /** Custom LLM instance (optional, defaults to OpenAI) */
+    llm?: LLM;
+    /** Array of tools available to the agent */
+    tools?: Tool[] | Function[] | any[];
+    /** System prompt defining agent behavior */
+    systemPrompt?: string;
+    /** API key for the LLM provider */
+    apiKey?: string;
+    /** Model to use (e.g., 'gpt-4o-mini') */
+    model?: string;
+    /** Maximum iterations for tool calling (default: 10) */
+    maxIterations?: number;
+    /** Trust configuration for the agent */
+    trust?: string | any;
+    /** Logging: true=./{name}.log, false=off, undefined=~/.co/logs/{name}.log, or string path */
+    log?: boolean | string;
+}
+/**
+ * Interface for Language Model providers
+ * @interface LLM
+ */
+export interface LLM {
+    /**
+     * Complete a conversation with optional tool support
+     * @param messages - Conversation history
+     * @param tools - Available tools as function schemas
+     * @returns Promise resolving to the LLM response
+     */
+    complete(messages: Message[], tools?: FunctionSchema[]): Promise<LLMResponse>;
+    /**
+     * Generate structured output matching a schema.
+     * Provider implementations may use native structured APIs if available,
+     * otherwise they will prompt the model to return strict JSON and parse it.
+     * @param messages - Conversation history
+     * @param schema - JSON Schema-like object describing expected output
+     */
+    structuredComplete<T = any>(messages: Message[], schema: any): Promise<T>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @purpose Core type definitions that provide compile-time safety and IDE support across the entire SDK
+ * @llm-note
+ *   Dependencies: none (leaf node) | imported by [src/core/agent.ts, src/llm/*.ts, src/tools/tool-utils.ts, src/index.ts] | tested by [tests/agent.test.ts]
+ *   Data flow: defines interfaces → used throughout codebase for type checking → no runtime data processing
+ *   State/Effects: pure type definitions, no side effects or state
+ *   Integration: exports all core interfaces (Tool, LLM, Agent, Message, FunctionSchema) | consumed by all modules | OpenAI-compatible message format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "connectonion",
+  "version": "0.0.1",
+  "description": "TypeScript SDK for ConnectOnion - A framework for creating AI agents with behavior tracking",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "build:examples": "tsc -p tsconfig.examples.json",
+    "watch": "tsc -w",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:examples": "npm run build:examples && node dist/examples/examples/test-tools.js",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "llm",
+    "openai",
+    "tools",
+    "automation",
+    "typescript"
+  ],
+  "author": "ConnectOnion Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wu-changxing/connectonion-ts"
+  },
+  "bugs": {
+    "url": "https://github.com/wu-changxing/connectonion-ts/issues"
+  },
+  "homepage": "https://github.com/wu-changxing/connectonion-ts#readme",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.67.0",
+    "@google/generative-ai": "^0.24.1",
+    "dotenv": "^16.0.0",
+    "openai": "^4.0.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0",
+    "prettier": "^3.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}