opc-agent 0.7.0 → 0.8.0

package/dist/core/orchestrator.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orchestrator = void 0;
+const events_1 = require("events");
+class Orchestrator extends events_1.EventEmitter {
+    agents = new Map();
+    workflows = new Map();
+    defaultWorkflow;
+    maxParallel;
+    constructor(config) {
+        super();
+        this.maxParallel = config.maxParallel ?? 5;
+        this.defaultWorkflow = config.defaultWorkflow;
+        for (const agent of config.agents) {
+            this.agents.set(agent.id, agent);
+        }
+        for (const wf of config.workflows ?? []) {
+            this.workflows.set(wf.name, wf);
+        }
+    }
+    /** Register a new agent node */
+    registerAgent(agent) {
+        this.agents.set(agent.id, agent);
+        this.emit('agent:registered', agent.id);
+    }
+    /** Unregister an agent */
+    unregisterAgent(id) {
+        this.agents.delete(id);
+        this.emit('agent:unregistered', id);
+    }
+    /** Route a message to the best-matching agent */
+    route(message) {
+        const content = message.content.toLowerCase();
+        let bestMatch;
+        let bestPriority = -1;
+        for (const agent of this.agents.values()) {
+            for (const route of agent.routes) {
+                if (content.includes(route.toLowerCase()) || new RegExp(route, 'i').test(content)) {
+                    const priority = agent.priority ?? 0;
+                    if (priority > bestPriority) {
+                        bestMatch = agent;
+                        bestPriority = priority;
+                    }
+                    break;
+                }
+            }
+        }
+        return bestMatch;
+    }
+    /** Execute a single agent */
+    async executeAgent(agentId, context, message) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            throw new Error(`Agent not found: ${agentId}`);
+        this.emit('agent:execute', agentId, message);
+        const result = await agent.handler(context, message);
+        this.emit('agent:complete', agentId, result);
+        return result;
+    }
+    /** Run multiple agents in parallel */
+    async executeParallel(agentIds, context, message) {
+        const results = new Map();
+        const batches = [];
+        // Batch by maxParallel
+        for (let i = 0; i < agentIds.length; i += this.maxParallel) {
+            batches.push(agentIds.slice(i, i + this.maxParallel));
+        }
+        for (const batch of batches) {
+            const promises = batch.map(async (id) => {
+                const result = await this.executeAgent(id, context, message);
+                results.set(id, result);
+            });
+            await Promise.all(promises);
+        }
+        return results;
+    }
+    /** Execute a named workflow */
+    async executeWorkflow(workflowName, context, message) {
+        const wf = this.workflows.get(workflowName);
+        if (!wf)
+            throw new Error(`Workflow not found: ${workflowName}`);
+        const results = [];
+        // Sequential steps
+        if (wf.steps) {
+            let currentMessage = message;
+            for (const agentId of wf.steps) {
+                const result = await this.executeAgent(agentId, context, currentMessage);
+                results.push(result);
+                currentMessage = result; // chain output → next input
+            }
+        }
+        // Parallel execution
+        if (wf.parallel) {
+            const parallelResults = await this.executeParallel(wf.parallel, context, message);
+            results.push(...parallelResults.values());
+        }
+        // Router-based
+        if (wf.router) {
+            const matched = this.route(message);
+            const targetId = matched && wf.router.agents.includes(matched.id)
+                ? matched.id
+                : wf.router.fallback;
+            if (targetId) {
+                const result = await this.executeAgent(targetId, context, message);
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    /** Hand off conversation from one agent to another */
+    async handoff(request) {
+        this.emit('agent:handoff', request);
+        const { toAgent, context } = request;
+        const lastMessage = context.messages[context.messages.length - 1];
+        if (!lastMessage)
+            throw new Error('No message in context for handoff');
+        return this.executeAgent(toAgent, context, lastMessage);
+    }
+    /** Process an incoming message using the default workflow or routing */
+    async process(context, message) {
+        if (this.defaultWorkflow) {
+            return this.executeWorkflow(this.defaultWorkflow, context, message);
+        }
+        // Fallback: route to single agent
+        const agent = this.route(message);
+        if (agent) {
+            const result = await this.executeAgent(agent.id, context, message);
+            return [result];
+        }
+        return [{
+                id: `orch-${Date.now()}`,
+                role: 'assistant',
+                content: 'No agent available to handle this request.',
+                timestamp: Date.now(),
+            }];
+    }
+    getAgents() {
+        return Array.from(this.agents.values());
+    }
+    getWorkflows() {
+        return Array.from(this.workflows.values());
+    }
+}
+exports.Orchestrator = Orchestrator;
+//# sourceMappingURL=orchestrator.js.map

package/dist/index.d.ts

@@ -49,6 +49,20 @@ export { publishAgent, installAgent } from './marketplace';
 export type { AgentManifest, PublishOptions, InstallOptions } from './marketplace';
 export { createAuthMiddleware, getActiveSessions } from './core/auth';
 export type { AuthConfig, AuthSession } from './core/auth';
+export { Orchestrator } from './core/orchestrator';
+export type { AgentNode, OrchestratorWorkflow, OrchestratorConfig, HandoffRequest } from './core/orchestrator';
+export { AgentPipeline, compose } from './core/compose';
+export type { ComposableAgent, ComposeOptions } from './core/compose';
+export { EmailChannel } from './channels/email';
+export type { EmailChannelConfig, EmailMessage } from './channels/email';
+export { SlackChannel } from './channels/slack';
+export type { SlackChannelConfig, SlashCommandConfig, SlashCommandPayload } from './channels/slack';
+export { WeChatChannel } from './channels/wechat';
+export type { WeChatChannelConfig, WeChatMessage, TemplateMessageData } from './channels/wechat';
+export { CalculatorTool } from './tools/calculator';
+export { DateTimeTool } from './tools/datetime';
+export { JsonTransformTool } from './tools/json-transform';
+export { TextAnalysisTool } from './tools/text-analysis';
 export { HttpSkill } from './skills/http';
 export { WebhookTriggerSkill } from './skills/webhook-trigger';
 export type { WebhookTarget } from './skills/webhook-trigger';

package/dist/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentSkill = exports.SchedulerSkill = exports.WebhookTriggerSkill = exports.HttpSkill = exports.getActiveSessions = exports.createAuthMiddleware = exports.installAgent = exports.publishAgent = exports.deployToHermes = exports.KnowledgeBase = exports.addMessages = exports.detectLocale = exports.getLocale = exports.setLocale = exports.t = exports.LazyLoader = exports.RequestBatcher = exports.ConnectionPool = exports.VersionManager = exports.WebhookChannel = exports.VoiceChannel = exports.HITLManager = exports.AgentRegistry = exports.WorkflowEngine = exports.Analytics = exports.Sandbox = exports.PluginManager = exports.createMCPTool = exports.MCPToolRegistry = exports.Room = exports.SUPPORTED_PROVIDERS = exports.createProvider = exports.MRGConfigReader = exports.ValueTracker = exports.TrustManager = exports.DeepBrainMemoryStore = exports.InMemoryStore = exports.SkillRegistry = exports.BaseSkill = exports.WebSocketChannel = exports.TelegramChannel = exports.WebChannel = exports.BaseChannel = exports.OADSchema = exports.validateOAD = exports.loadOAD = exports.Logger = exports.truncateOutput = exports.AgentRuntime = exports.BaseAgent = void 0;
+exports.EmailChannel = exports.compose = exports.AgentPipeline = exports.Orchestrator = exports.getActiveSessions = exports.createAuthMiddleware = exports.installAgent = exports.publishAgent = exports.deployToHermes = exports.KnowledgeBase = exports.addMessages = exports.detectLocale = exports.getLocale = exports.setLocale = exports.t = exports.LazyLoader = exports.RequestBatcher = exports.ConnectionPool = exports.VersionManager = exports.WebhookChannel = exports.VoiceChannel = exports.HITLManager = exports.AgentRegistry = exports.WorkflowEngine = exports.Analytics = exports.Sandbox = exports.PluginManager = exports.createMCPTool = exports.MCPToolRegistry = exports.Room = exports.SUPPORTED_PROVIDERS = exports.createProvider = exports.MRGConfigReader = exports.ValueTracker = exports.TrustManager = exports.DeepBrainMemoryStore = exports.InMemoryStore = exports.SkillRegistry = exports.BaseSkill = exports.WebSocketChannel = exports.TelegramChannel = exports.WebChannel = exports.BaseChannel = exports.OADSchema = exports.validateOAD = exports.loadOAD = exports.Logger = exports.truncateOutput = exports.AgentRuntime = exports.BaseAgent = void 0;
+exports.DocumentSkill = exports.SchedulerSkill = exports.WebhookTriggerSkill = exports.HttpSkill = exports.TextAnalysisTool = exports.JsonTransformTool = exports.DateTimeTool = exports.CalculatorTool = exports.WeChatChannel = exports.SlackChannel = void 0;
 // OPC Agent — Open Agent Framework
 var agent_1 = require("./core/agent");
 Object.defineProperty(exports, "BaseAgent", { enumerable: true, get: function () { return agent_1.BaseAgent; } });
@@ -86,6 +87,26 @@ Object.defineProperty(exports, "installAgent", { enumerable: true, get: function
 var auth_1 = require("./core/auth");
 Object.defineProperty(exports, "createAuthMiddleware", { enumerable: true, get: function () { return auth_1.createAuthMiddleware; } });
 Object.defineProperty(exports, "getActiveSessions", { enumerable: true, get: function () { return auth_1.getActiveSessions; } });
+// v0.8.0 modules
+var orchestrator_1 = require("./core/orchestrator");
+Object.defineProperty(exports, "Orchestrator", { enumerable: true, get: function () { return orchestrator_1.Orchestrator; } });
+var compose_1 = require("./core/compose");
+Object.defineProperty(exports, "AgentPipeline", { enumerable: true, get: function () { return compose_1.AgentPipeline; } });
+Object.defineProperty(exports, "compose", { enumerable: true, get: function () { return compose_1.compose; } });
+var email_1 = require("./channels/email");
+Object.defineProperty(exports, "EmailChannel", { enumerable: true, get: function () { return email_1.EmailChannel; } });
+var slack_1 = require("./channels/slack");
+Object.defineProperty(exports, "SlackChannel", { enumerable: true, get: function () { return slack_1.SlackChannel; } });
+var wechat_1 = require("./channels/wechat");
+Object.defineProperty(exports, "WeChatChannel", { enumerable: true, get: function () { return wechat_1.WeChatChannel; } });
+var calculator_1 = require("./tools/calculator");
+Object.defineProperty(exports, "CalculatorTool", { enumerable: true, get: function () { return calculator_1.CalculatorTool; } });
+var datetime_1 = require("./tools/datetime");
+Object.defineProperty(exports, "DateTimeTool", { enumerable: true, get: function () { return datetime_1.DateTimeTool; } });
+var json_transform_1 = require("./tools/json-transform");
+Object.defineProperty(exports, "JsonTransformTool", { enumerable: true, get: function () { return json_transform_1.JsonTransformTool; } });
+var text_analysis_1 = require("./tools/text-analysis");
+Object.defineProperty(exports, "TextAnalysisTool", { enumerable: true, get: function () { return text_analysis_1.TextAnalysisTool; } });
 var http_1 = require("./skills/http");
 Object.defineProperty(exports, "HttpSkill", { enumerable: true, get: function () { return http_1.HttpSkill; } });
 var webhook_trigger_1 = require("./skills/webhook-trigger");

package/dist/tools/calculator.d.ts

@@ -0,0 +1,7 @@
+import type { MCPTool } from './mcp';
+/**
+ * Calculator Tool — v0.8.0
+ * Safe math expression evaluation as an LLM function tool.
+ */
+export declare const CalculatorTool: MCPTool;
+//# sourceMappingURL=calculator.d.ts.map

package/dist/tools/calculator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculatorTool = void 0;
+/**
+ * Calculator Tool — v0.8.0
+ * Safe math expression evaluation as an LLM function tool.
+ */
+exports.CalculatorTool = {
+    name: 'calculator',
+    description: 'Evaluate a mathematical expression. Supports basic arithmetic, powers, sqrt, abs, min, max, round, ceil, floor, PI, E.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            expression: {
+                type: 'string',
+                description: 'Mathematical expression to evaluate, e.g. "2 + 3 * 4" or "sqrt(144) + PI"',
+            },
+        },
+        required: ['expression'],
+    },
+    async execute(input) {
+        const expr = String(input.expression ?? '');
+        try {
+            const result = safeEval(expr);
+            return { content: String(result) };
+        }
+        catch (err) {
+            return { content: `Error: ${err.message}`, isError: true };
+        }
+    },
+};
+/** Safe math evaluator — no eval(), no arbitrary code */
+function safeEval(expr) {
+    // Whitelist: digits, operators, parens, dots, commas, spaces, and known functions
+    const sanitized = expr.replace(/\s+/g, '');
+    const allowed = /^[0-9+\-*/().,%^a-zA-Z_]+$/;
+    if (!allowed.test(sanitized)) {
+        throw new Error('Invalid characters in expression');
+    }
+    // Replace known math functions/constants
+    const prepared = sanitized
+        .replace(/\bPI\b/gi, String(Math.PI))
+        .replace(/\bE\b/g, String(Math.E))
+        .replace(/\bsqrt\b/gi, 'Math.sqrt')
+        .replace(/\babs\b/gi, 'Math.abs')
+        .replace(/\bmin\b/gi, 'Math.min')
+        .replace(/\bmax\b/gi, 'Math.max')
+        .replace(/\bround\b/gi, 'Math.round')
+        .replace(/\bceil\b/gi, 'Math.ceil')
+        .replace(/\bfloor\b/gi, 'Math.floor')
+        .replace(/\bpow\b/gi, 'Math.pow')
+        .replace(/\blog\b/gi, 'Math.log')
+        .replace(/\blog10\b/gi, 'Math.log10')
+        .replace(/\bsin\b/gi, 'Math.sin')
+        .replace(/\bcos\b/gi, 'Math.cos')
+        .replace(/\btan\b/gi, 'Math.tan')
+        .replace(/\^/g, '**');
+    // Block anything that isn't math
+    if (/[a-zA-Z_]/.test(prepared.replace(/Math\.\w+/g, ''))) {
+        throw new Error('Unsupported function or variable in expression');
+    }
+    // Use Function constructor with restricted scope
+    const fn = new Function('Math', `"use strict"; return (${prepared});`);
+    const result = fn(Math);
+    if (typeof result !== 'number' || !isFinite(result)) {
+        throw new Error('Expression did not evaluate to a finite number');
+    }
+    return result;
+}
+//# sourceMappingURL=calculator.js.map

package/dist/tools/datetime.d.ts

@@ -0,0 +1,7 @@
+import type { MCPTool } from './mcp';
+/**
+ * DateTime Tool — v0.8.0
+ * Date/time operations as an LLM function tool.
+ */
+export declare const DateTimeTool: MCPTool;
+//# sourceMappingURL=datetime.d.ts.map

package/dist/tools/datetime.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTimeTool = void 0;
+/**
+ * DateTime Tool — v0.8.0
+ * Date/time operations as an LLM function tool.
+ */
+exports.DateTimeTool = {
+    name: 'datetime',
+    description: 'Get current date/time, format dates, calculate date differences, or add/subtract time.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            operation: {
+                type: 'string',
+                enum: ['now', 'format', 'diff', 'add', 'parse'],
+                description: 'Operation to perform',
+            },
+            date: {
+                type: 'string',
+                description: 'Date string (ISO 8601 or common format)',
+            },
+            date2: {
+                type: 'string',
+                description: 'Second date for diff operation',
+            },
+            format: {
+                type: 'string',
+                description: 'Output format: iso, date, time, datetime, unix, relative',
+            },
+            amount: {
+                type: 'number',
+                description: 'Amount to add (can be negative)',
+            },
+            unit: {
+                type: 'string',
+                enum: ['milliseconds', 'seconds', 'minutes', 'hours', 'days', 'weeks', 'months', 'years'],
+                description: 'Unit for add operation',
+            },
+            timezone: {
+                type: 'string',
+                description: 'IANA timezone (e.g. Asia/Shanghai, America/New_York)',
+            },
+        },
+        required: ['operation'],
+    },
+    async execute(input) {
+        try {
+            const op = String(input.operation);
+            const tz = input.timezone;
+            switch (op) {
+                case 'now': {
+                    const now = new Date();
+                    const fmt = input.format ?? 'iso';
+                    return { content: formatDate(now, fmt, tz) };
+                }
+                case 'format': {
+                    const d = parseDate(input.date);
+                    const fmt = input.format ?? 'iso';
+                    return { content: formatDate(d, fmt, tz) };
+                }
+                case 'diff': {
+                    const d1 = parseDate(input.date);
+                    const d2 = input.date2 ? parseDate(input.date2) : new Date();
+                    const diffMs = d2.getTime() - d1.getTime();
+                    const days = Math.floor(Math.abs(diffMs) / 86400000);
+                    const hours = Math.floor((Math.abs(diffMs) % 86400000) / 3600000);
+                    const mins = Math.floor((Math.abs(diffMs) % 3600000) / 60000);
+                    const sign = diffMs < 0 ? '-' : '';
+                    return {
+                        content: JSON.stringify({
+                            milliseconds: diffMs,
+                            readable: `${sign}${days}d ${hours}h ${mins}m`,
+                            days: diffMs / 86400000,
+                        }),
+                    };
+                }
+                case 'add': {
+                    const d = input.date ? parseDate(input.date) : new Date();
+                    const amount = Number(input.amount ?? 0);
+                    const unit = String(input.unit ?? 'days');
+                    const result = addTime(d, amount, unit);
+                    const fmt = input.format ?? 'iso';
+                    return { content: formatDate(result, fmt, tz) };
+                }
+                case 'parse': {
+                    const d = parseDate(input.date);
+                    return {
+                        content: JSON.stringify({
+                            iso: d.toISOString(),
+                            unix: d.getTime(),
+                            year: d.getFullYear(),
+                            month: d.getMonth() + 1,
+                            day: d.getDate(),
+                            weekday: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][d.getDay()],
+                        }),
+                    };
+                }
+                default:
+                    return { content: `Unknown operation: ${op}`, isError: true };
+            }
+        }
+        catch (err) {
+            return { content: `Error: ${err.message}`, isError: true };
+        }
+    },
+};
+function parseDate(s) {
+    const d = new Date(s);
+    if (isNaN(d.getTime()))
+        throw new Error(`Invalid date: ${s}`);
+    return d;
+}
+function formatDate(d, fmt, tz) {
+    if (tz) {
+        const localeStr = d.toLocaleString('en-US', { timeZone: tz });
+        d = new Date(localeStr);
+    }
+    switch (fmt) {
+        case 'iso': return d.toISOString();
+        case 'date': return d.toISOString().split('T')[0];
+        case 'time': return d.toTimeString().split(' ')[0];
+        case 'datetime': return d.toISOString().replace('T', ' ').replace(/\.\d+Z$/, '');
+        case 'unix': return String(d.getTime());
+        default: return d.toISOString();
+    }
+}
+function addTime(d, amount, unit) {
+    const result = new Date(d);
+    switch (unit) {
+        case 'milliseconds':
+            result.setTime(result.getTime() + amount);
+            break;
+        case 'seconds':
+            result.setTime(result.getTime() + amount * 1000);
+            break;
+        case 'minutes':
+            result.setTime(result.getTime() + amount * 60000);
+            break;
+        case 'hours':
+            result.setTime(result.getTime() + amount * 3600000);
+            break;
+        case 'days':
+            result.setDate(result.getDate() + amount);
+            break;
+        case 'weeks':
+            result.setDate(result.getDate() + amount * 7);
+            break;
+        case 'months':
+            result.setMonth(result.getMonth() + amount);
+            break;
+        case 'years':
+            result.setFullYear(result.getFullYear() + amount);
+            break;
+        default: throw new Error(`Unknown unit: ${unit}`);
+    }
+    return result;
+}
+//# sourceMappingURL=datetime.js.map

package/dist/tools/json-transform.d.ts

@@ -0,0 +1,7 @@
+import type { MCPTool } from './mcp';
+/**
+ * JSON Transform Tool — v0.8.0
+ * Parse, query, and transform JSON data as an LLM function tool.
+ */
+export declare const JsonTransformTool: MCPTool;
+//# sourceMappingURL=json-transform.d.ts.map

package/dist/tools/json-transform.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonTransformTool = void 0;
+/**
+ * JSON Transform Tool — v0.8.0
+ * Parse, query, and transform JSON data as an LLM function tool.
+ */
+exports.JsonTransformTool = {
+    name: 'json_transform',
+    description: 'Parse, query (JSONPath-like), transform, flatten, or merge JSON data.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            operation: {
+                type: 'string',
+                enum: ['parse', 'query', 'flatten', 'unflatten', 'merge', 'pick', 'omit', 'sort', 'filter', 'map_keys'],
+                description: 'Operation to perform on the JSON data',
+            },
+            data: {
+                description: 'JSON string or object to operate on',
+            },
+            data2: {
+                description: 'Second JSON for merge operation',
+            },
+            path: {
+                type: 'string',
+                description: 'Dot-notation path for query (e.g. "users.0.name")',
+            },
+            keys: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Keys for pick/omit operations',
+            },
+            sortBy: {
+                type: 'string',
+                description: 'Key to sort array by',
+            },
+            order: {
+                type: 'string',
+                enum: ['asc', 'desc'],
+            },
+            filterKey: {
+                type: 'string',
+                description: 'Key to filter by',
+            },
+            filterValue: {
+                description: 'Value to match for filter',
+            },
+        },
+        required: ['operation', 'data'],
+    },
+    async execute(input) {
+        try {
+            const op = String(input.operation);
+            const data = typeof input.data === 'string' ? JSON.parse(input.data) : input.data;
+            switch (op) {
+                case 'parse':
+                    return { content: JSON.stringify(data, null, 2) };
+                case 'query': {
+                    const path = String(input.path ?? '');
+                    const result = getByPath(data, path);
+                    return { content: JSON.stringify(result, null, 2) };
+                }
+                case 'flatten':
+                    return { content: JSON.stringify(flatten(data), null, 2) };
+                case 'unflatten':
+                    return { content: JSON.stringify(unflatten(data), null, 2) };
+                case 'merge': {
+                    const data2 = typeof input.data2 === 'string' ? JSON.parse(input.data2) : input.data2;
+                    return { content: JSON.stringify(deepMerge(data, data2), null, 2) };
+                }
+                case 'pick': {
+                    const keys = input.keys ?? [];
+                    const result = {};
+                    for (const k of keys) {
+                        if (k in data)
+                            result[k] = data[k];
+                    }
+                    return { content: JSON.stringify(result, null, 2) };
+                }
+                case 'omit': {
+                    const keys = new Set(input.keys ?? []);
+                    const result = {};
+                    for (const [k, v] of Object.entries(data)) {
+                        if (!keys.has(k))
+                            result[k] = v;
+                    }
+                    return { content: JSON.stringify(result, null, 2) };
+                }
+                case 'sort': {
+                    if (!Array.isArray(data))
+                        return { content: 'Data must be an array for sort', isError: true };
+                    const sortBy = String(input.sortBy ?? '');
+                    const order = input.order === 'desc' ? -1 : 1;
+                    const sorted = [...data].sort((a, b) => {
+                        const va = sortBy ? a[sortBy] : a;
+                        const vb = sortBy ? b[sortBy] : b;
+                        return va < vb ? -order : va > vb ? order : 0;
+                    });
+                    return { content: JSON.stringify(sorted, null, 2) };
+                }
+                case 'filter': {
+                    if (!Array.isArray(data))
+                        return { content: 'Data must be an array for filter', isError: true };
+                    const fk = String(input.filterKey ?? '');
+                    const fv = input.filterValue;
+                    const filtered = data.filter((item) => item[fk] === fv);
+                    return { content: JSON.stringify(filtered, null, 2) };
+                }
+                case 'map_keys': {
+                    // Rename keys: path is "old:new,old2:new2"
+                    const mapping = String(input.path ?? '').split(',').reduce((acc, pair) => {
+                        const [old, nw] = pair.split(':');
+                        if (old && nw)
+                            acc[old.trim()] = nw.trim();
+                        return acc;
+                    }, {});
+                    const result = {};
+                    for (const [k, v] of Object.entries(data)) {
+                        result[mapping[k] ?? k] = v;
+                    }
+                    return { content: JSON.stringify(result, null, 2) };
+                }
+                default:
+                    return { content: `Unknown operation: ${op}`, isError: true };
+            }
+        }
+        catch (err) {
+            return { content: `Error: ${err.message}`, isError: true };
+        }
+    },
+};
+function getByPath(obj, path) {
+    return path.split('.').reduce((curr, key) => {
+        if (curr == null)
+            return undefined;
+        const idx = Number(key);
+        return Number.isInteger(idx) && Array.isArray(curr) ? curr[idx] : curr[key];
+    }, obj);
+}
+function flatten(obj, prefix = '') {
+    const result = {};
+    if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+        for (const [k, v] of Object.entries(obj)) {
+            const key = prefix ? `${prefix}.${k}` : k;
+            if (v && typeof v === 'object' && !Array.isArray(v)) {
+                Object.assign(result, flatten(v, key));
+            }
+            else {
+                result[key] = v;
+            }
+        }
+    }
+    return result;
+}
+function unflatten(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const parts = key.split('.');
+        let curr = result;
+        for (let i = 0; i < parts.length - 1; i++) {
+            if (!(parts[i] in curr))
+                curr[parts[i]] = {};
+            curr = curr[parts[i]];
+        }
+        curr[parts[parts.length - 1]] = value;
+    }
+    return result;
+}
+function deepMerge(a, b) {
+    if (!b)
+        return a;
+    const result = { ...a };
+    for (const [k, v] of Object.entries(b)) {
+        if (v && typeof v === 'object' && !Array.isArray(v) && result[k] && typeof result[k] === 'object') {
+            result[k] = deepMerge(result[k], v);
+        }
+        else {
+            result[k] = v;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=json-transform.js.map

package/dist/tools/text-analysis.d.ts

@@ -0,0 +1,8 @@
+import type { MCPTool } from './mcp';
+/**
+ * Text Analysis Tool — v0.8.0
+ * Summarize, translate (stub), sentiment analysis as an LLM function tool.
+ * Note: For production, connect to actual LLM/NLP APIs. This provides basic built-in analysis.
+ */
+export declare const TextAnalysisTool: MCPTool;
+//# sourceMappingURL=text-analysis.d.ts.map