@toolplex/ai-engine 0.1.0

package/LICENSE

@@ -0,0 +1,98 @@
+License text copyright (c) 2025 ToolPlex LLC. All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Parameters
+
+Licensor:             ToolPlex LLC
+Licensed Work:        ToolPlex AI Engine, as published in this repository. The Licensed Work is (c) 2025
+                      ToolPlex LLC.
+Additional Use Grant: You may make production use of the Licensed Work, provided
+                      your use does not involve offering it or derivative works on a
+                      hosted or embedded basis to compete with ToolPlex's paid platform
+                      or services. For purposes of this license:
+
+                      A "competitive offering" is a product or service that is offered
+                      to third parties on a paid basis (including through paid support),
+                      and that significantly overlaps with ToolPlex's platform, including:
+                      tool discovery, tool execution, agent control, or workflow/playbook
+                      reuse.
+
+                      "Product" means software made available to end users or used to
+                      operate hosted services.
+
+                      "Embedded" includes incorporating source or binary components of
+                      the Licensed Work into another product or requiring the Licensed
+                      Work for that product to function.
+
+                      "Internal use" within your organization is permitted, even for
+                      commercial purposes, as long as it is not redistributed or offered
+                      to others.
+
+                      "API Integration Restrictions": Use of the ToolPlex API or services
+                      to build, enhance, or operate a competitive offering is prohibited,
+                      regardless of whether the Licensed Work is directly incorporated.
+
+                      "Derivative Works": Includes any modification, adaptation, or custom
+                      implementation based on the Licensed Work, including but not limited
+                      to custom clients for ToolPlex API interaction. While permitted under
+                      this license, such derivatives may present technical challenges and
+                      are not officially supported.
+
+                      "Research and Academic Use": Non-commercial research, educational,
+                      and academic use is permitted regardless of competitive overlap,
+                      provided results are not used to develop commercial competitive
+                      offerings.
+
+                      "Official Client Recommendation": While custom clients are permitted
+                      under this license, ToolPlex strongly recommends using the official
+                      client to ensure compatibility, security, and optimal performance.
+
+                      Hosting or using the Licensed Work for internal purposes within an
+                      organization is not considered a competitive offering. ToolPlex
+                      considers your organization to include all of your affiliates under
+                      common control.
+
+Change Date:          None
+Change License:       MPL 2.0
+
+For information about alternative licensing arrangements for the Licensed Work,
+please contact support@toolplex.ai.
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.

package/README.md

@@ -0,0 +1,292 @@
+# @toolplex/ai-engine
+
+The core AI chat engine for [ToolPlex](https://toolplex.ai). A TypeScript SDK that provides a unified interface for building AI-powered applications with tool calling via the Model Context Protocol (MCP).
+
+## Features
+
+- **Multi-provider support** - Anthropic, OpenAI, Google Gemini, OpenRouter
+- **MCP integration** - Connect to ToolPlex's MCP server for powerful tool calling
+- **Transport abstraction** - Works in CLI, desktop (Electron), or cloud environments
+- **AI SDK wrapper** - Built on [Vercel AI SDK](https://sdk.vercel.ai) with ToolPlex-specific enhancements
+
+## Installation
+
+```bash
+npm install @toolplex/ai-engine
+```
+
+## Quick Start
+
+### Basic Chat (No Tools)
+
+```typescript
+import { streamText, createAnthropic } from '@toolplex/ai-engine';
+
+const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+
+const result = await streamText({
+  model: anthropic('claude-sonnet-4-20250514'),
+  messages: [{ role: 'user', content: 'Hello!' }],
+});
+
+for await (const chunk of result.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+### With ToolPlex MCP Tools
+
+```typescript
+import {
+  MCPClient,
+  defaultStdioTransportFactory,
+  streamText,
+  createAnthropic
+} from '@toolplex/ai-engine';
+
+// Create MCP client (connects to @toolplex/client)
+const mcpClient = new MCPClient({
+  transportFactory: defaultStdioTransportFactory,
+});
+
+// Create a session
+await mcpClient.createSession('my-session', process.env.TOOLPLEX_API_KEY);
+
+// List available tools
+const { tools } = await mcpClient.listTools('my-session');
+console.log('Available tools:', tools.map(t => t.name));
+
+// Call a tool
+const result = await mcpClient.callTool('my-session', 'search_servers', {
+  query: 'weather',
+});
+
+// Clean up
+await mcpClient.destroySession('my-session');
+```
+
+## API Reference
+
+### Providers
+
+```typescript
+import {
+  createAnthropic,
+  createOpenAI,
+  createGoogleGenerativeAI,
+  createOpenRouter,
+  getProvider,
+  getModel,
+} from '@toolplex/ai-engine';
+
+// Direct provider creation
+const anthropic = createAnthropic({ apiKey: '...' });
+const openai = createOpenAI({ apiKey: '...' });
+
+// Or use the unified getProvider helper
+const model = getModel('anthropic/claude-sonnet-4-20250514', {
+  anthropicApiKey: '...',
+});
+```
+
+### MCP Client
+
+```typescript
+import { MCPClient, TransportFactory } from '@toolplex/ai-engine';
+
+const client = new MCPClient({
+  transportFactory: myTransportFactory,
+  logger: console, // optional
+});
+
+// Session management
+await client.createSession(sessionId, apiKey, resumeHistory?);
+await client.destroySession(sessionId);
+client.getActiveSessions();
+client.hasSession(sessionId);
+
+// Tool operations
+await client.listTools(sessionId);
+await client.callTool(sessionId, toolName, args);
+```
+
+### Transport Factory
+
+The `TransportFactory` interface allows you to customize how the MCP server is spawned:
+
+```typescript
+import { TransportFactory, MCPSession } from '@toolplex/ai-engine';
+
+class MyCustomTransportFactory implements TransportFactory {
+  async createTransport(apiKey: string, resumeHistory?: string): Promise<MCPSession> {
+    // Spawn @toolplex/client with custom configuration
+    // Return { client, transport }
+  }
+
+  async closeTransport(session: MCPSession): Promise<void> {
+    await session.client.close();
+  }
+}
+```
+
+**Built-in transports:**
+
+- `defaultStdioTransportFactory` - Uses system Node.js (for CLI apps)
+
+### Utilities
+
+```typescript
+import {
+  // Schema utilities
+  deepSanitizeParams,
+  resolveSchemaRefs,
+  sanitizeSchemaForGemini,
+
+  // Model detection
+  isChatGPTModel,
+  isGoogleGeminiModel,
+  isAnthropicModel,
+  parseModelId,
+
+  // Path utilities
+  getToolplexClientPath,
+} from '@toolplex/ai-engine';
+```
+
+### AI SDK Re-exports
+
+For convenience, common AI SDK exports are re-exported:
+
+```typescript
+import {
+  streamText,
+  tool,
+  jsonSchema,
+  stepCountIs,
+  type CoreMessage,
+  type ToolResultPart,
+  type ToolCallPart,
+} from '@toolplex/ai-engine';
+```
+
+## Custom Transport Example (Electron)
+
+For Electron apps with bundled Node.js:
+
+```typescript
+import {
+  MCPClient,
+  MCPSDKClient as Client,
+  StdioClientTransport,
+  getToolplexClientPath,
+  type TransportFactory,
+  type MCPSession,
+} from '@toolplex/ai-engine';
+
+class ElectronTransportFactory implements TransportFactory {
+  async createTransport(apiKey: string): Promise<MCPSession> {
+    const toolplexPath = getToolplexClientPath();
+
+    const transport = new StdioClientTransport({
+      command: '/path/to/bundled/node', // Use bundled Node.js
+      args: [toolplexPath],
+      env: {
+        ...process.env,
+        TOOLPLEX_API_KEY: apiKey,
+      },
+    });
+
+    const client = new Client({ name: 'my-app', version: '1.0.0' });
+    await client.connect(transport);
+
+    return { transport, client };
+  }
+
+  async closeTransport(session: MCPSession): Promise<void> {
+    await session.client.close();
+  }
+}
+
+const mcpClient = new MCPClient({
+  transportFactory: new ElectronTransportFactory(),
+});
+```
+
+## Environment Variables
+
+When using `defaultStdioTransportFactory`, these environment variables are passed to the MCP server:
+
+- `TOOLPLEX_API_KEY` - Your ToolPlex API key (required)
+- `TOOLPLEX_SESSION_RESUME_HISTORY` - JSON string containing historical tool usage for resumed sessions
+
+### Session Resume History
+
+When restoring a chat session from a database, the MCP server needs context about what tools were previously used. This allows the enforcement layer to validate operations like `save_playbook` and `submit_feedback` which depend on historical tool usage.
+
+The `resumeHistory` parameter is a JSON string with the following structure:
+
+```typescript
+interface SessionResumeHistory {
+  tool_calls: Array<{ server_id: string; tool_name: string }>;
+  installs: Array<{ server_id: string }>;
+  uninstalls: Array<{ server_id: string }>;
+}
+```
+
+**Example usage:**
+
+```typescript
+// When creating a session with history (e.g., restoring from database)
+const resumeHistory = JSON.stringify({
+  tool_calls: [
+    { server_id: 'weather-server', tool_name: 'get_forecast' },
+    { server_id: 'calendar-server', tool_name: 'create_event' },
+  ],
+  installs: [
+    { server_id: 'weather-server' },
+  ],
+  uninstalls: [],
+});
+
+await mcpClient.createSession('my-session', apiKey, resumeHistory);
+```
+
+**In a custom transport factory:**
+
+```typescript
+class MyTransportFactory implements TransportFactory {
+  async createTransport(apiKey: string, sessionResumeHistory?: string): Promise<MCPSession> {
+    const transport = new StdioClientTransport({
+      command: 'node',
+      args: [toolplexPath],
+      env: {
+        ...process.env,
+        TOOLPLEX_API_KEY: apiKey,
+        // Pass resume history to the MCP server process
+        ...(sessionResumeHistory && { TOOLPLEX_SESSION_RESUME_HISTORY: sessionResumeHistory }),
+      },
+    });
+
+    const client = new Client({ name: 'my-app', version: '1.0.0' });
+    await client.connect(transport);
+    return { transport, client };
+  }
+}
+```
+
+This is particularly useful in desktop applications where chat sessions are persisted and can be restored later.
+
+## Requirements
+
+- Node.js 18+
+- A ToolPlex API key (get one at [toolplex.ai](https://toolplex.ai))
+
+## License
+
+[BSL 1.1](./LICENSE)
+
+## Links
+
+- [ToolPlex](https://toolplex.ai)
+- [Documentation](https://docs.toolplex.ai)
+- [@toolplex/client](https://github.com/toolplex/client) - The MCP server

package/dist/adapters/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @toolplex/ai-engine - Adapters
+ *
+ * Export adapter types and any shared adapter utilities.
+ * Platform-specific adapters (Electron, HTTP, CLI) are provided
+ * separately to avoid bundling unnecessary dependencies.
+ */
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,YAAY,CAAC"}

package/dist/adapters/index.js

@@ -0,0 +1,9 @@
+/**
+ * @toolplex/ai-engine - Adapters
+ *
+ * Export adapter types and any shared adapter utilities.
+ * Platform-specific adapters (Electron, HTTP, CLI) are provided
+ * separately to avoid bundling unnecessary dependencies.
+ */
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,YAAY,CAAC"}

package/dist/adapters/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * @toolplex/ai-engine - Adapter Interface
+ *
+ * The EngineAdapter interface defines how the AI engine interacts with
+ * the host platform. This abstraction allows the same engine core to
+ * run in Electron, server-side (cloud), or CLI environments.
+ *
+ * Implementations:
+ * - ElectronAdapter: Desktop app with IPC, webContents, confirmations
+ * - HTTPAdapter: Cloud/server with HTTP streaming, no confirmations
+ * - CLIAdapter: CLI with terminal I/O
+ */
+import type { ProviderCredentials, ConfirmationRequest, ConfirmationResult, MCPResult, MCPSessionInfo, MCPTool, MCPToolResult, UsageData, ChatSession, ChatMessage } from "../types/index.js";
+/**
+ * Interface for emitting engine events to the platform
+ */
+export interface EngineEventEmitter {
+    /** Emit a text chunk during streaming */
+    emitChunk(streamId: string, chunk: string): void;
+    /** Emit stream completion */
+    emitComplete(streamId: string, fullText: string, usage?: UsageData): void;
+    /** Emit stream error */
+    emitError(streamId: string, error: string): void;
+    /** Emit tool input start (for streaming tool arguments) */
+    emitToolInputStart(streamId: string, toolCallId: string, toolName: string): void;
+    /** Emit tool input delta (streaming argument chunks) */
+    emitToolInputDelta(streamId: string, toolCallId: string, argsDelta: string): void;
+    /** Emit tool execution result */
+    emitToolResult(streamId: string, toolCallId: string, result: MCPToolResult, toolName: string, args: any): void;
+}
+/**
+ * Interface for handling user confirmations
+ * Desktop: Shows modal dialogs via IPC
+ * Cloud: Auto-approves or uses policy-based decisions
+ * CLI: Prompts in terminal
+ */
+export interface ConfirmationHandler {
+    /**
+     * Request user confirmation for a tool operation
+     * @param streamId - The current stream ID
+     * @param request - The confirmation request details
+     * @returns Confirmation result with allowed/denied and any edits
+     */
+    requestConfirmation(streamId: string, request: ConfirmationRequest): Promise<ConfirmationResult>;
+    /**
+     * Whether this handler supports interactive confirmations
+     * Cloud handlers may return false to auto-approve based on policy
+     */
+    isInteractive(): boolean;
+}
+/**
+ * Interface for MCP transport operations
+ * Abstracts away the transport mechanism (stdio, HTTP, etc.)
+ */
+export interface MCPTransportAdapter {
+    /** Create/connect MCP transport for a session */
+    createTransport(sessionId: string, apiKey: string, sessionResumeHistory?: string): Promise<MCPResult>;
+    /** Get session info */
+    getSessionInfo(sessionId: string): MCPSessionInfo;
+    /** List available tools from MCP server */
+    listTools(sessionId: string): Promise<{
+        tools: MCPTool[];
+    }>;
+    /** Call an MCP tool */
+    callTool(sessionId: string, toolName: string, args: any): Promise<MCPToolResult>;
+    /** Destroy/disconnect MCP transport */
+    destroyTransport(sessionId: string): Promise<MCPResult>;
+}
+/**
+ * Interface for accessing API credentials
+ * Different platforms load credentials differently
+ */
+export interface CredentialsProvider {
+    /** Get provider credentials for AI SDK */
+    getCredentials(): Promise<ProviderCredentials>;
+    /** Get ToolPlex API key specifically */
+    getToolPlexApiKey(): Promise<string>;
+}
+/**
+ * Interface for persisting chat sessions and messages
+ * Optional - cloud may use different storage than desktop
+ */
+export interface PersistenceAdapter {
+    createSession(metadata?: Record<string, any>): Promise<ChatSession>;
+    getSession(sessionId: string): Promise<ChatSession | null>;
+    updateSession(sessionId: string, updates: Partial<ChatSession>): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+    saveMessage(message: Omit<ChatMessage, "id" | "createdAt">): Promise<ChatMessage>;
+    getMessages(sessionId: string): Promise<ChatMessage[]>;
+    updateMessage(messageId: string, updates: Partial<ChatMessage>): Promise<void>;
+    deleteMessage(messageId: string): Promise<void>;
+}
+/**
+ * Interface for logging
+ * Allows different logging implementations per platform
+ */
+export interface LoggerAdapter {
+    debug(message: string, meta?: Record<string, any>): void;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, meta?: Record<string, any>): void;
+}
+/**
+ * The main adapter interface that platforms must implement
+ * This brings together all the sub-interfaces needed by the engine
+ */
+export interface EngineAdapter {
+    /** Event emitter for streaming events */
+    readonly events: EngineEventEmitter;
+    /** Confirmation handler for user approvals */
+    readonly confirmations: ConfirmationHandler;
+    /** MCP transport adapter */
+    readonly mcp: MCPTransportAdapter;
+    /** Credentials provider */
+    readonly credentials: CredentialsProvider;
+    /** Logger */
+    readonly logger: LoggerAdapter;
+    /** Persistence adapter (optional) */
+    readonly persistence?: PersistenceAdapter;
+    /** Client version string (for API headers) */
+    getClientVersion(): string;
+    /**
+     * Initialize the adapter
+     * Called once when engine is created
+     */
+    initialize(): Promise<void>;
+    /**
+     * Cleanup/shutdown the adapter
+     * Called when engine is destroyed
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Factory function type for creating adapters
+ */
+export type AdapterFactory<TConfig = any> = (config: TConfig) => EngineAdapter;
+//# sourceMappingURL=types.d.ts.map

package/dist/adapters/types.d.ts.map

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

package/dist/adapters/types.js

@@ -0,0 +1,14 @@
+/**
+ * @toolplex/ai-engine - Adapter Interface
+ *
+ * The EngineAdapter interface defines how the AI engine interacts with
+ * the host platform. This abstraction allows the same engine core to
+ * run in Electron, server-side (cloud), or CLI environments.
+ *
+ * Implementations:
+ * - ElectronAdapter: Desktop app with IPC, webContents, confirmations
+ * - HTTPAdapter: Cloud/server with HTTP streaming, no confirmations
+ * - CLIAdapter: CLI with terminal I/O
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/adapters/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/adapters/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/core/ChatEngine.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @toolplex/ai-engine - Chat Engine
+ *
+ * Core streaming engine that orchestrates AI chat sessions.
+ * Uses adapters for all platform-specific I/O operations.
+ */
+import type { EngineAdapter } from "../adapters/types.js";
+import type { StreamOptions, StreamResult, EngineConfig } from "../types/index.js";
+export interface ChatEngineOptions {
+    adapter: EngineAdapter;
+    config?: EngineConfig;
+}
+export declare class ChatEngine {
+    private adapter;
+    private config;
+    private initialized;
+    constructor(options: ChatEngineOptions);
+    /**
+     * Initialize the engine
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown the engine
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Initialize MCP for a session
+     */
+    initializeMCP(sessionId: string): Promise<void>;
+    /**
+     * Initialize a session with ToolPlex context
+     */
+    initializeSession(sessionId: string, modelId: string, provider: string): Promise<{
+        success: boolean;
+        context?: string;
+        error?: string;
+    }>;
+    /**
+     * Stream a chat completion
+     */
+    stream(options: StreamOptions): Promise<StreamResult>;
+    /**
+     * Process messages for streaming (handle attachments, filter empty blocks)
+     */
+    private processMessages;
+}
+//# sourceMappingURL=ChatEngine.d.ts.map

package/dist/core/ChatEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatEngine.d.ts","sourceRoot":"","sources":["../../src/core/ChatEngine.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,YAAY,EAGb,MAAM,mBAAmB,CAAC;AAI3B,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,WAAW,CAAkB;gBAEzB,OAAO,EAAE,iBAAiB;IAUtC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAMjC;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAM/B;;OAEG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBrD;;OAEG;IACG,iBAAiB,CACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IA8DlE;;OAEG;IACG,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAkO3D;;OAEG;IACH,OAAO,CAAC,eAAe;CAmFxB"}