@toolplex/client 0.1.1

package/dist/shared/serverManagerTypes.d.ts

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+export declare const InitializeResultSchema: z.ZodObject<{
+    succeeded: z.ZodArray<z.ZodObject<{
+        server_id: z.ZodString;
+        server_name: z.ZodString;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        server_name: string;
+        description: string;
+        server_id: string;
+    }, {
+        server_name: string;
+        description: string;
+        server_id: string;
+    }>, "many">;
+    failures: z.ZodRecord<z.ZodString, z.ZodObject<{
+        server_id: z.ZodString;
+        server_name: z.ZodString;
+        error: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        error: string;
+        server_name: string;
+        server_id: string;
+    }, {
+        error: string;
+        server_name: string;
+        server_id: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    succeeded: {
+        server_name: string;
+        description: string;
+        server_id: string;
+    }[];
+    failures: Record<string, {
+        error: string;
+        server_name: string;
+        server_id: string;
+    }>;
+}, {
+    succeeded: {
+        server_name: string;
+        description: string;
+        server_id: string;
+    }[];
+    failures: Record<string, {
+        error: string;
+        server_name: string;
+        server_id: string;
+    }>;
+}>;
+export type InitializeResult = z.infer<typeof InitializeResultSchema>;
+export declare const ServerInstallResultSchema: z.ZodObject<{
+    server_id: z.ZodString;
+    server_name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    server_name: string;
+    server_id: string;
+}, {
+    server_name: string;
+    server_id: string;
+}>;
+export type ServerInstallResult = z.infer<typeof ServerInstallResultSchema>;
+export declare const ServerUninstallResultSchema: z.ZodObject<{
+    server_id: z.ZodString;
+    server_name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    server_name: string;
+    server_id: string;
+}, {
+    server_name: string;
+    server_id: string;
+}>;
+export type ServerUninstallResult = z.infer<typeof ServerUninstallResultSchema>;
+export declare const ListServersResultSchema: z.ZodObject<{
+    servers: z.ZodArray<z.ZodObject<{
+        server_id: z.ZodString;
+        server_name: z.ZodString;
+        description: z.ZodString;
+        tool_count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        server_name: string;
+        description: string;
+        server_id: string;
+        tool_count: number;
+    }, {
+        server_name: string;
+        description: string;
+        server_id: string;
+        tool_count: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    servers: {
+        server_name: string;
+        description: string;
+        server_id: string;
+        tool_count: number;
+    }[];
+}, {
+    servers: {
+        server_name: string;
+        description: string;
+        server_id: string;
+        tool_count: number;
+    }[];
+}>;
+export type ListServersResult = z.infer<typeof ListServersResultSchema>;
+export declare const ListToolsResultSchema: z.ZodObject<{
+    server_id: z.ZodString;
+    server_name: z.ZodString;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        inputSchema: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: any;
+    }, {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: any;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    server_name: string;
+    server_id: string;
+    tools: {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: any;
+    }[];
+}, {
+    server_name: string;
+    server_id: string;
+    tools: {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: any;
+    }[];
+}>;
+export type ListToolsResult = z.infer<typeof ListToolsResultSchema>;
+export declare const ListAllToolsResultSchema: z.ZodObject<{
+    tools: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        inputSchema: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: any;
+    }, {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: any;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    tools: Record<string, {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: any;
+    }[]>;
+}, {
+    tools: Record<string, {
+        name: string;
+        description?: string | undefined;
+        inputSchema?: any;
+    }[]>;
+}>;
+export type ListAllToolsResult = z.infer<typeof ListAllToolsResultSchema>;
+export declare const CallToolResultSchema: z.ZodObject<{
+    result: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    result?: any;
+}, {
+    result?: any;
+}>;
+export type CallToolResult = z.infer<typeof CallToolResultSchema>;
+export declare const CleanupResultSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type CleanupResult = z.infer<typeof CleanupResultSchema>;

package/dist/shared/serverManagerTypes.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+// --------------------
+// initialize
+// --------------------
+export const InitializeResultSchema = z.object({
+    succeeded: z.array(z.object({
+        server_id: z.string(),
+        server_name: z.string(),
+        description: z.string(),
+    })),
+    failures: z.record(z.object({
+        server_id: z.string(),
+        server_name: z.string(),
+        error: z.string(),
+    })),
+});
+// --------------------
+// Install
+// --------------------
+export const ServerInstallResultSchema = z.object({
+    server_id: z.string(),
+    server_name: z.string(),
+});
+// --------------------
+// Uninstall
+// --------------------
+export const ServerUninstallResultSchema = z.object({
+    server_id: z.string(),
+    server_name: z.string(),
+});
+// --------------------
+// list_servers
+// --------------------
+export const ListServersResultSchema = z.object({
+    servers: z.array(z.object({
+        server_id: z.string(),
+        server_name: z.string(),
+        description: z.string(),
+        tool_count: z.number(),
+    })),
+});
+// --------------------
+// list_tools
+// --------------------
+export const ListToolsResultSchema = z.object({
+    server_id: z.string(),
+    server_name: z.string(),
+    tools: z.array(z.object({
+        name: z.string(),
+        description: z.string().optional(),
+        inputSchema: z.any(),
+    })),
+});
+// --------------------
+// list_all_tools
+// --------------------
+export const ListAllToolsResultSchema = z.object({
+    tools: z.record(z.array(z.object({
+        name: z.string(),
+        description: z.string().optional(),
+        inputSchema: z.any(),
+    }))),
+});
+// --------------------
+// call_tool
+// --------------------
+export const CallToolResultSchema = z.object({
+    result: z.any(),
+});
+// --------------------
+// cleanup
+// --------------------
+export const CleanupResultSchema = z.object({});

package/dist/shared/stdioServerManagerClient.d.ts

@@ -0,0 +1,12 @@
+export declare class StdioServerManagerClient {
+    private serverProcess;
+    private messageHandlers;
+    private messageBuffer;
+    private command;
+    private args;
+    private env;
+    constructor(command: string, args: string[], env?: NodeJS.ProcessEnv);
+    start(): Promise<void>;
+    sendRequest(method: string, params: any): Promise<any>;
+    stop(): Promise<void>;
+}

package/dist/shared/stdioServerManagerClient.js

@@ -0,0 +1,96 @@
+import { spawn } from 'child_process';
+export class StdioServerManagerClient {
+    constructor(command, args, env) {
+        this.serverProcess = null;
+        this.messageHandlers = new Map();
+        this.messageBuffer = '';
+        this.command = command;
+        this.args = args;
+        this.env = env ? { ...process.env, ...env } : process.env;
+    }
+    async start() {
+        this.serverProcess = spawn(this.command, this.args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: this.env,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.serverProcess.on('error', (err) => {
+            process.stderr.write(`Server process error: ${err}\n`);
+        });
+        if (!this.serverProcess.stderr || !this.serverProcess.stdout || !this.serverProcess.stdin) {
+            throw new Error('Server process streams not available');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.serverProcess.stderr.on('data', (data) => {
+            process.stderr.write(data);
+        });
+        this.serverProcess.stdout.on('data', (data) => {
+            this.messageBuffer += data.toString();
+            const lines = this.messageBuffer.split('\n');
+            this.messageBuffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const message = JSON.parse(line.trim());
+                    const handler = this.messageHandlers.get(message.id);
+                    if (handler) {
+                        handler(message);
+                        this.messageHandlers.delete(message.id);
+                    }
+                }
+                catch (e) {
+                    process.stderr.write(`Raw line: ${line}\n`);
+                    process.stderr.write(`Parse error: ${e}\n`);
+                }
+            }
+        });
+        this.serverProcess.on('exit', () => {
+            for (const [, h] of this.messageHandlers)
+                h({ __error__: { message: 'Subprocess exited' } });
+            this.messageHandlers.clear();
+            this.serverProcess = null;
+            this.messageBuffer = '';
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async sendRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = Date.now();
+            if (!this.serverProcess?.stdin) {
+                reject(Error('Server process not started'));
+            }
+            else {
+                this.messageHandlers.set(id, (frame) => {
+                    if (frame.error || frame.__error__) {
+                        const msg = frame.error?.message ?? frame.__error__?.message ?? 'MCP error';
+                        reject(new Error(msg));
+                    }
+                    else {
+                        resolve(frame.result);
+                    }
+                });
+                this.serverProcess.stdin.write(JSON.stringify({
+                    jsonrpc: '2.0',
+                    method,
+                    params,
+                    id,
+                }) + '\n');
+            }
+            setTimeout(() => {
+                if (this.messageHandlers.has(id)) {
+                    this.messageHandlers.delete(id);
+                    reject(new Error(`Request timed out: ${method}`));
+                }
+            }, 60000);
+        });
+    }
+    async stop() {
+        if (this.serverProcess) {
+            this.serverProcess.kill();
+            this.serverProcess = null;
+            this.messageHandlers.clear();
+            this.messageBuffer = '';
+        }
+    }
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "1.0.8";

package/dist/version.js

@@ -0,0 +1 @@
+export const version = '1.0.8';

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@toolplex/client",
+  "version": "0.1.1",
+  "author": "ToolPlex LLC",
+  "license": "SEE LICENSE IN LICENSE",
+  "description": "The official ToolPlex client for AI agent tool discovery and execution",
+  "type": "module",
+  "main": "dist/mcp-server/index.js",
+  "bin": {
+    "toolplex-client": "./dist/mcp-server/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node scripts/generate-version-file.js && rm -rf dist && tsc && node scripts/add-shebang.js",
+    "start": "node ./dist/mcp-server/index.js",
+    "watch": "tsc --watch",
+    "lint": "eslint 'src/**/*.{ts,js}'",
+    "lint:fix": "eslint 'src/**/*.{ts,js}' --fix",
+    "format": "prettier --write 'src/**/*.{ts,js,json,md}'"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-agent",
+    "ai-tools",
+    "tool-discovery",
+    "agent-automation",
+    "claude",
+    "anthropic",
+    "openai",
+    "toolplex",
+    "workflow-automation",
+    "mcp-server",
+    "ai-integration"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.7.0",
+    "@types/node": "^22.13.11",
+    "@types/node-fetch": "^2.6.12",
+    "@types/which": "^3.0.4",
+    "callsite": "^1.0.0",
+    "command-exists": "^1.2.9",
+    "dotenv": "^16.5.0",
+    "env-paths": "^3.0.0",
+    "glob": "^11.0.1",
+    "node-fetch": "^3.3.2",
+    "typescript": "^5.8.2",
+    "which": "^5.0.0",
+    "winston-daily-rotate-file": "^5.0.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@types/callsite": "^1.0.34",
+    "@types/command-exists": "^1.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.29.0",
+    "@typescript-eslint/parser": "^8.29.0",
+    "eslint": "^9.24.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-prettier": "^5.2.6",
+    "prettier": "^3.5.3",
+    "ts-node": "^10.9.2",
+    "typescript-eslint": "^8.29.0"
+  }
+}