chittycan
Version:
Your completely autonomous network that grows with you - DNA ownership platform with encrypted vaults, PDX portability, and ChittyFoundation governance
424 lines • 17.5 kB
JavaScript
/**
* ChittyRouter Client - AI-powered email gateway with multi-agent orchestration
*/
class ChittyRouterClient {
baseUrl;
apiToken;
constructor(baseUrl, apiToken) {
this.baseUrl = baseUrl;
this.apiToken = apiToken;
}
async request(endpoint, options = {}) {
const response = await fetch(`${this.baseUrl}${endpoint}`, {
...options,
headers: {
"Authorization": `Bearer ${this.apiToken}`,
"Content-Type": "application/json",
...options.headers,
},
});
if (!response.ok) {
throw new Error(`ChittyRouter API error: ${response.statusText}`);
}
return response.json();
}
// Email Inbox Management
async listInbox(filters) {
const params = new URLSearchParams();
if (filters?.unread !== undefined)
params.append("unread", String(filters.unread));
if (filters?.priority)
params.append("priority", filters.priority);
if (filters?.limit)
params.append("limit", String(filters.limit));
return this.request(`/api/v1/inbox?${params}`);
}
async getEmail(emailId) {
return this.request(`/api/v1/inbox/${emailId}`);
}
async processInbox(dryRun = false) {
return this.request("/api/v1/inbox/process", {
method: "POST",
body: JSON.stringify({ dryRun }),
});
}
async getInboxStats() {
return this.request("/api/v1/inbox/stats");
}
async archiveEmail(emailId) {
return this.request(`/api/v1/inbox/${emailId}/archive`, {
method: "POST",
});
}
async markAsRead(emailId) {
return this.request(`/api/v1/inbox/${emailId}/read`, {
method: "POST",
});
}
// AI Agent Management
async listAgents() {
return this.request("/api/v1/agents");
}
async getAgent(agentName) {
return this.request(`/api/v1/agents/${agentName}`);
}
async invokeAgent(agentName, emailId, options = {}) {
return this.request(`/api/v1/agents/${agentName}/invoke`, {
method: "POST",
body: JSON.stringify({ emailId, ...options }),
});
}
async getAgentHistory(agentName, limit = 50) {
return this.request(`/api/v1/agents/${agentName}/history?limit=${limit}`);
}
// Routing Rules
async listRules() {
return this.request("/api/v1/rules");
}
async getRule(ruleId) {
return this.request(`/api/v1/rules/${ruleId}`);
}
async createRule(rule) {
return this.request("/api/v1/rules", {
method: "POST",
body: JSON.stringify(rule),
});
}
async updateRule(ruleId, updates) {
return this.request(`/api/v1/rules/${ruleId}`, {
method: "PUT",
body: JSON.stringify(updates),
});
}
async deleteRule(ruleId) {
return this.request(`/api/v1/rules/${ruleId}`, {
method: "DELETE",
});
}
async testRule(ruleId, emailSample) {
return this.request(`/api/v1/rules/${ruleId}/test`, {
method: "POST",
body: JSON.stringify({ emailSample }),
});
}
// AI Model Management
async listModels() {
return this.request("/api/v1/models");
}
async testModels() {
return this.request("/api/v1/models/test", {
method: "POST",
});
}
async getFallbackChain() {
return this.request("/api/v1/models/fallback-chain");
}
async updateFallbackChain(chain) {
return this.request("/api/v1/models/fallback-chain", {
method: "PUT",
body: JSON.stringify({ chain }),
});
}
async getModelUsage(modelName) {
const params = modelName ? `?model=${modelName}` : "";
return this.request(`/api/v1/models/usage${params}`);
}
// Response Templates
async listTemplates() {
return this.request("/api/v1/templates");
}
async getTemplate(templateId) {
return this.request(`/api/v1/templates/${templateId}`);
}
async createTemplate(template) {
return this.request("/api/v1/templates", {
method: "POST",
body: JSON.stringify(template),
});
}
async renderTemplate(templateId, variables) {
return this.request(`/api/v1/templates/${templateId}/render`, {
method: "POST",
body: JSON.stringify({ variables }),
});
}
// Draft Management
async listDrafts() {
return this.request("/api/v1/drafts");
}
async getDraft(draftId) {
return this.request(`/api/v1/drafts/${draftId}`);
}
async createDraft(draft) {
return this.request("/api/v1/drafts", {
method: "POST",
body: JSON.stringify(draft),
});
}
async sendDraft(draftId) {
return this.request(`/api/v1/drafts/${draftId}/send`, {
method: "POST",
});
}
// Analytics & Insights
async getRoutingInsights(timeRange = "7d") {
return this.request(`/api/v1/analytics/routing?range=${timeRange}`);
}
async getAgentPerformance(agentName) {
const params = agentName ? `?agent=${agentName}` : "";
return this.request(`/api/v1/analytics/agents${params}`);
}
async getPriorityDistribution() {
return this.request("/api/v1/analytics/priority");
}
// Health & Monitoring
async getHealth() {
return this.request("/health");
}
async getWorkerStatus() {
return this.request("/api/v1/workers/status");
}
}
// Command Handlers
const commands = [
{
name: "router",
description: "ChittyRouter AI email gateway commands",
subcommands: {
// Inbox commands
"inbox list": {
description: "List inbox messages",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const emails = await client.listInbox(args.filters);
console.log(`Inbox (${emails.length} messages):`);
emails.forEach((email) => {
console.log(` [${email.priority}] ${email.from}: ${email.subject}`);
});
},
},
"inbox process": {
description: "Process inbox with AI agents",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const result = await client.processInbox(args.dryRun || false);
console.log(`Processed ${result.processed} messages`);
console.log(`Triaged: ${result.triaged}`);
console.log(`Responded: ${result.responded}`);
},
},
"inbox stats": {
description: "Get inbox statistics",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const stats = await client.getInboxStats();
console.log("Inbox Statistics:");
console.log(` Total: ${stats.total}`);
console.log(` Unread: ${stats.unread}`);
console.log(` High Priority: ${stats.highPriority}`);
console.log(` Pending Response: ${stats.pendingResponse}`);
},
},
// Agent commands
"agents list": {
description: "List available AI agents",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const agents = await client.listAgents();
console.log("Available Agents:");
agents.forEach((agent) => {
console.log(` - ${agent.name}: ${agent.description}`);
console.log(` Status: ${agent.status} | Invocations: ${agent.invocations}`);
});
},
},
"agent invoke": {
description: "Invoke an AI agent",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const result = await client.invokeAgent(args.agent, args.emailId, args.options || {});
console.log("Agent Result:");
console.log(JSON.stringify(result, null, 2));
},
},
"agent history": {
description: "Get agent invocation history",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const history = await client.getAgentHistory(args.agent, args.limit);
console.log(`Recent invocations of ${args.agent}:`);
history.forEach((inv) => {
console.log(` ${inv.timestamp}: ${inv.result.summary}`);
});
},
},
// Rules commands
"rules list": {
description: "List routing rules",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const rules = await client.listRules();
console.log(`Routing Rules (${rules.length}):`);
rules.forEach((rule) => {
const status = rule.enabled ? "✓" : "✗";
console.log(` ${status} ${rule.name}`);
console.log(` Condition: ${rule.condition}`);
console.log(` Action: ${rule.action}`);
});
},
},
"rule create": {
description: "Create routing rule",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const result = await client.createRule({
name: args.name,
condition: args.condition,
action: args.action,
priority: args.priority,
enabled: args.enabled !== false,
});
console.log("✓ Rule created:", result.id);
},
},
"rule test": {
description: "Test routing rule",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const result = await client.testRule(args.ruleId, args.emailSample);
console.log("Test Result:", result.matches ? "✓ Match" : "✗ No match");
},
},
// Model commands
"models list": {
description: "List AI models",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const models = await client.listModels();
console.log("Available Models:");
models.forEach((model) => {
console.log(` - ${model.name} (${model.provider})`);
console.log(` Status: ${model.status} | Latency: ${model.avgLatency}ms`);
});
},
},
"models test": {
description: "Test all AI models",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const results = await client.testModels();
console.log("Model Test Results:");
results.forEach((result) => {
const status = result.success ? "✓" : "✗";
console.log(` ${status} ${result.model}: ${result.latency}ms`);
});
},
},
"models fallback-chain": {
description: "Show AI model fallback chain",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const chain = await client.getFallbackChain();
console.log("AI Model Fallback Chain:");
chain.forEach((model, i) => {
console.log(` ${i + 1}. ${model}`);
});
},
},
// Template commands
"templates list": {
description: "List response templates",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const templates = await client.listTemplates();
console.log(`Response Templates (${templates.length}):`);
templates.forEach((tpl) => {
console.log(` - ${tpl.name} [${tpl.category}]`);
});
},
},
// Analytics commands
"analytics routing": {
description: "Get routing insights",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const insights = await client.getRoutingInsights(args.range || "7d");
console.log("Routing Insights:");
console.log(` Total Routed: ${insights.totalRouted}`);
console.log(` Auto-Responded: ${insights.autoResponded}`);
console.log(` Avg Response Time: ${insights.avgResponseTime}`);
},
},
"analytics agents": {
description: "Get agent performance metrics",
handler: async (args, config) => {
const remote = config.remotes[args.remote || "router"];
const client = new ChittyRouterClient(remote.baseUrl, remote.apiToken);
const performance = await client.getAgentPerformance(args.agent);
console.log("Agent Performance:");
Object.entries(performance).forEach(([agent, metrics]) => {
console.log(` ${agent}:`);
console.log(` Invocations: ${metrics.invocations}`);
console.log(` Success Rate: ${metrics.successRate}%`);
console.log(` Avg Latency: ${metrics.avgLatency}ms`);
});
},
},
},
},
];
// Remote Type Definition
const remoteType = {
type: "chittyrouter",
name: "ChittyRouter",
description: "AI-powered email gateway with multi-agent orchestration",
configFields: [
{
name: "baseUrl",
description: "ChittyRouter API base URL",
required: true,
default: "https://router.chitty.cc",
},
{
name: "apiToken",
description: "ChittyRouter API token",
required: true,
sensitive: true,
},
{
name: "emailDomain",
description: "Email domain for routing",
required: false,
},
],
};
// Plugin Export
export const chittyrouterPlugin = {
metadata: {
name: "chittyrouter",
version: "0.1.0",
description: "ChittyRouter integration - AI email gateway and agent orchestration",
author: "ChittyCan Team",
},
remoteTypes: [remoteType],
commands,
async init(config) {
console.log("✓ ChittyRouter plugin initialized");
},
};
export default chittyrouterPlugin;
//# sourceMappingURL=chittyrouter.js.map