@toolplex/client
Version:
The official ToolPlex client for AI agent tool discovery and execution
222 lines (221 loc) • 7.72 kB
JavaScript
import fetch from "node-fetch";
import { FileLogger } from "../../shared/fileLogger.js";
import os from "os";
const logger = FileLogger;
export class ToolplexApiService {
constructor(clientContext) {
if (!clientContext.apiKey) {
throw new Error("API key not set in client context");
}
if (!clientContext.clientVersion) {
throw new Error("Client version not set in client context");
}
this.clientContext = clientContext;
this.baseUrl = this.getBaseUrl(clientContext.dev);
this.machineContext = {
os: `${os.platform()} ${os.release()}`,
arch: os.arch(),
memory_gb: Math.round(os.totalmem() / (1024 * 1024 * 1024)),
cpu_cores: os.cpus().length.toString(),
};
}
getBaseUrl(dev) {
return dev ? "http://localhost:8080" : "https://api.toolplex.ai";
}
async handleFetchResponse(response) {
if (!response.ok) {
const error = await response.text();
throw new Error(`HTTP ${response.status}: ${error}`);
}
return response.json();
}
getBaseHeaders() {
return {
"Content-Type": "application/json",
Accept: "application/json",
"x-api-key": this.clientContext.apiKey,
"x-client-mode": this.clientContext.clientMode,
"x-client-name": this.clientContext.clientName,
"x-client-version": this.clientContext.clientVersion,
};
}
getHeadersWithSession() {
return {
...this.getBaseHeaders(),
"x-session-id": this.clientContext.sessionId,
};
}
async init() {
try {
const initRequest = {
llm_context: this.clientContext.llmContext,
};
const response = await fetch(`${this.baseUrl}/init`, {
method: "POST",
headers: this.getBaseHeaders(),
body: JSON.stringify(initRequest),
});
return this.handleFetchResponse(response);
}
catch (err) {
await logger.error(`Error initializing session: ${err}`);
throw err;
}
}
async getTools() {
try {
const response = await fetch(`${this.baseUrl}/tools`, {
method: "POST",
headers: this.getBaseHeaders(),
body: JSON.stringify({}),
});
return this.handleFetchResponse(response);
}
catch (err) {
await logger.error(`Error fetching tool definitions: ${err}`);
throw err;
}
}
async logTelemetryEvents(events) {
try {
const response = await fetch(`${this.baseUrl}/telemetry/log/batch`, {
method: "POST",
headers: this.getHeadersWithSession(),
body: JSON.stringify(events.map((event) => ({
event_type: event.eventType,
...event.data,
}))),
});
return this.handleFetchResponse(response);
}
catch (err) {
await logger.error(`Error batch logging telemetry events: ${err}`);
return { success: false };
}
}
async lookupEntity(entityType, entityId) {
try {
const response = await fetch(`${this.baseUrl}/lookup-entity`, {
method: "POST",
headers: this.getHeadersWithSession(),
body: JSON.stringify({
entity_type: entityType,
entity_id: entityId,
}),
});
return this.handleFetchResponse(response);
}
catch (err) {
await logger.error(`Error looking up entity: ${err}`);
throw err;
}
}
async search(query, expandedKeywords = [], filter = "all", size = 10, scope = "all") {
const requestBody = {
query,
expanded_keywords: expandedKeywords,
filter,
size,
scope,
};
await logger.debug(`Searching API at ${this.baseUrl} with query: ${query}`);
try {
const response = await fetch(`${this.baseUrl}/search`, {
method: "POST",
headers: this.getHeadersWithSession(),
body: JSON.stringify(requestBody),
});
if (!response.ok) {
const errorText = await response.text();
throw new Error(`HTTP ${response.status}: ${errorText}`);
}
return (await response.json());
}
catch (err) {
await logger.error(`Error during search request: ${err}`);
throw err;
}
}
async createPlaybook(playbook_name, description, actions, domain, keywords, requirements, privacy, sourcePlaybookId, forkReason) {
const requestBody = {
playbook_name,
description,
actions,
llm_context: this.clientContext.llmContext,
domain,
keywords,
requirements,
privacy,
source_playbook_id: sourcePlaybookId,
fork_reason: forkReason,
};
try {
const response = await fetch(`${this.baseUrl}/playbooks/create`, {
method: "POST",
headers: this.getHeadersWithSession(),
body: JSON.stringify(requestBody),
});
return this.handleFetchResponse(response);
}
catch (err) {
await logger.error(`Error creating playbook: ${err}`);
throw err;
}
}
async logPlaybookUsage(playbookId, success, errorMessage) {
const requestBody = {
playbook_id: playbookId,
success,
llm_context: this.clientContext.llmContext,
error_message: errorMessage,
};
try {
const response = await fetch(`${this.baseUrl}/playbooks/log-usage`, {
method: "POST",
headers: this.getHeadersWithSession(),
body: JSON.stringify(requestBody),
});
return this.handleFetchResponse(response);
}
catch (err) {
await logger.error(`Error logging playbook usage: ${err}`);
throw err;
}
}
async submitFeedback(targetType, targetId, vote, message, securityAssessment) {
const requestBody = {
target_type: targetType,
target_id: targetId,
vote,
message,
llm_context: this.clientContext.llmContext,
machine_context: this.machineContext,
security_assessment: securityAssessment,
};
try {
const response = await fetch(`${this.baseUrl}/feedback/submit`, {
method: "POST",
headers: this.getHeadersWithSession(),
body: JSON.stringify(requestBody),
});
return this.handleFetchResponse(response);
}
catch (err) {
await logger.error(`Error submitting feedback: ${err}`);
throw err;
}
}
async getFeedbackSummary() {
try {
const response = await fetch(`${this.baseUrl}/feedback/summarize`, {
method: "GET",
headers: this.getHeadersWithSession(),
});
return this.handleFetchResponse(response);
}
catch (err) {
await logger.error(`Error getting feedback summary: ${err}`);
throw err;
}
}
}