panteao-ts 1.0.0

package/dist/cjs/index.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from 'events';
+export interface BdiClientOptions {
+    host?: string;
+    port?: number;
+    autoReconnect?: boolean;
+    reconnectInterval?: number;
+    project?: string;
+    binPath?: string;
+}
+export type ActionCallback = (args: string[], respond: (success: boolean) => void) => void;
+export declare class BdiClient extends EventEmitter {
+    private socket;
+    private host;
+    private port;
+    private buffer;
+    private autoReconnect;
+    private reconnectInterval;
+    private actionHandlers;
+    private project?;
+    private binPath;
+    private process;
+    constructor(options?: BdiClientOptions);
+    connect(): Promise<void>;
+    private setupSocketEvents;
+    private handleIncomingLine;
+    private parseAction;
+    private cleanArg;
+    sendMsg(performative: string, sender: string, receiver: string, content: string): void;
+    sendPerception(action: 'add' | 'remove', perception: string): void;
+    registerAction(actionName: string, callback: ActionCallback): void;
+    private sendActionResult;
+    close(): void;
+}
+export { BdiClient as Panteao, BdiClient as Panteão };

package/dist/cjs/index.js

@@ -0,0 +1,323 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Panteão = exports.Panteao = exports.BdiClient = void 0;
+const net = __importStar(require("net"));
+const events_1 = require("events");
+const child_process = __importStar(require("child_process"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'string' ? 0 : address?.port;
+            server.close(() => {
+                if (port)
+                    resolve(port);
+                else
+                    reject(new Error('Failed to allocate port'));
+            });
+        });
+        server.on('error', reject);
+    });
+}
+class BdiClient extends events_1.EventEmitter {
+    socket;
+    host;
+    port;
+    buffer = '';
+    autoReconnect;
+    reconnectInterval;
+    actionHandlers = new Map();
+    project;
+    binPath;
+    process = null;
+    constructor(options = {}) {
+        super();
+        this.host = options.host || '127.0.0.1';
+        this.port = options.port || 0;
+        this.project = options.project;
+        this.autoReconnect = options.project ? false : (options.autoReconnect ?? true);
+        this.reconnectInterval = options.reconnectInterval || 2000;
+        this.socket = new net.Socket();
+        let binPath = options.binPath;
+        if (!binPath) {
+            const isWin = process.platform === 'win32';
+            const binName = isWin ? 'panteao-engine.exe' : 'panteao-engine';
+            // Try to resolve from platform-specific package first
+            const platformPkg = `@panteao/engine-${process.platform}-${process.arch}`;
+            let resolvedPath = null;
+            try {
+                const pkgPath = require.resolve(path.join(platformPkg, 'package.json'));
+                const pkgDir = path.dirname(pkgPath);
+                const candidate = path.join(pkgDir, 'bin', binName);
+                const candidateFallback = path.join(pkgDir, binName);
+                if (fs.existsSync(candidate)) {
+                    resolvedPath = candidate;
+                }
+                else if (fs.existsSync(candidateFallback)) {
+                    resolvedPath = candidateFallback;
+                }
+            }
+            catch (e) {
+                // Platform package not installed or resolved
+            }
+            if (resolvedPath) {
+                binPath = resolvedPath;
+            }
+            else {
+                // Fallback to local paths
+                const candidate1 = path.join(__dirname, binName);
+                const candidate2 = path.join(__dirname, 'bin', binName);
+                if (fs.existsSync(candidate1)) {
+                    binPath = candidate1;
+                }
+                else if (fs.existsSync(candidate2)) {
+                    binPath = candidate2;
+                }
+                else {
+                    binPath = binName;
+                }
+            }
+        }
+        this.binPath = binPath;
+    }
+    async connect() {
+        if (this.project) {
+            if (this.port === 0) {
+                this.port = await getFreePort();
+            }
+            const args = [this.project, '--port', String(this.port)];
+            this.process = child_process.spawn(this.binPath, args, { stdio: 'ignore' });
+            await new Promise((resolve) => setTimeout(resolve, 800));
+        }
+        else if (this.port === 0) {
+            this.port = 44444;
+        }
+        return new Promise((resolve, reject) => {
+            let handshakeBuffer = '';
+            const onConnect = () => {
+                const onData = (data) => {
+                    handshakeBuffer += data.toString('utf8');
+                    const lines = handshakeBuffer.split('\n');
+                    handshakeBuffer = lines.pop() || '';
+                    for (const line of lines) {
+                        try {
+                            if (!line.trim())
+                                continue;
+                            const msg = JSON.parse(line);
+                            if (msg.type === 'mas_ready') {
+                                this.socket.off('data', onData);
+                                this.socket.off('error', onError);
+                                this.setupSocketEvents();
+                                this.emit('connect');
+                                resolve();
+                                return;
+                            }
+                        }
+                        catch (e) { }
+                    }
+                };
+                const onError = (err) => {
+                    this.socket.off('data', onData);
+                    if (this.process) {
+                        this.process.kill();
+                        this.process = null;
+                    }
+                    reject(err);
+                };
+                this.socket.on('data', onData);
+                this.socket.once('error', onError);
+            };
+            const onInitialError = (err) => {
+                if (this.process) {
+                    this.process.kill();
+                    this.process = null;
+                }
+                reject(err);
+            };
+            this.socket.once('error', onInitialError);
+            this.socket.connect(this.port, this.host, () => {
+                this.socket.off('error', onInitialError);
+                onConnect();
+            });
+        });
+    }
+    setupSocketEvents() {
+        this.socket.on('data', (data) => {
+            this.buffer += data.toString('utf8');
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.trim().length === 0)
+                    continue;
+                this.handleIncomingLine(line);
+            }
+        });
+        this.socket.on('close', () => {
+            this.emit('disconnect');
+            if (this.autoReconnect) {
+                setTimeout(() => {
+                    this.connect().catch(() => { });
+                }, this.reconnectInterval);
+            }
+        });
+        this.socket.on('error', (err) => {
+            this.emit('error', err);
+        });
+    }
+    handleIncomingLine(line) {
+        try {
+            const msg = JSON.parse(line);
+            if (msg.type === 'action') {
+                const rawAction = msg.action;
+                const { name, args } = this.parseAction(rawAction);
+                const handler = this.actionHandlers.get(name);
+                if (handler) {
+                    const respond = (success) => {
+                        this.sendActionResult(msg.id, success);
+                    };
+                    handler(args, respond);
+                }
+                else {
+                    this.sendActionResult(msg.id, true);
+                }
+                this.emit('action', { name, args, agent: msg.agent, id: msg.id });
+            }
+            else if (msg.type === 'message') {
+                const { performative, sender, receiver, content } = msg;
+                this.emit('message', performative, sender, receiver, content);
+                this.emit(performative, sender, receiver, content);
+                // Compatibility: parse message content as an action
+                if (content && typeof content === 'string') {
+                    const parsed = this.parseAction(content);
+                    if (parsed && parsed.name) {
+                        const handler = this.actionHandlers.get(parsed.name);
+                        if (handler) {
+                            const dummyRespond = () => { };
+                            handler(parsed.args, dummyRespond);
+                        }
+                        this.emit('action', { name: parsed.name, args: parsed.args, agent: sender, id: null });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    parseAction(actionStr) {
+        const parenIdx = actionStr.indexOf('(');
+        if (parenIdx === -1) {
+            return { name: actionStr.trim(), args: [] };
+        }
+        const name = actionStr.substring(0, parenIdx).trim();
+        const argsStr = actionStr.substring(parenIdx + 1, actionStr.lastIndexOf(')'));
+        const args = [];
+        let current = '';
+        let insideQuotes = false;
+        let depthBrackets = 0;
+        let depthParens = 0;
+        for (let i = 0; i < argsStr.length; i++) {
+            const char = argsStr[i];
+            if (char === '"') {
+                insideQuotes = !insideQuotes;
+                current += char;
+            }
+            else if (!insideQuotes && char === '[') {
+                depthBrackets++;
+                current += char;
+            }
+            else if (!insideQuotes && char === ']') {
+                depthBrackets--;
+                current += char;
+            }
+            else if (!insideQuotes && char === '(') {
+                depthParens++;
+                current += char;
+            }
+            else if (!insideQuotes && char === ')') {
+                depthParens--;
+                current += char;
+            }
+            else if (char === ',' && !insideQuotes && depthBrackets === 0 && depthParens === 0) {
+                args.push(this.cleanArg(current));
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim().length > 0) {
+            args.push(this.cleanArg(current));
+        }
+        return { name, args };
+    }
+    cleanArg(arg) {
+        const s = arg.trim();
+        if (s.startsWith('"') && s.endsWith('"') && s.length >= 2) {
+            return s.substring(1, s.length - 1);
+        }
+        return s;
+    }
+    sendMsg(performative, sender, receiver, content) {
+        const payload = JSON.stringify({ type: 'message', performative, sender, receiver, content }) + '\n';
+        this.socket.write(payload);
+    }
+    sendPerception(action, perception) {
+        const payload = JSON.stringify({ type: 'perception', action, perception }) + '\n';
+        this.socket.write(payload);
+    }
+    registerAction(actionName, callback) {
+        this.actionHandlers.set(actionName, callback);
+    }
+    sendActionResult(id, success) {
+        const payload = JSON.stringify({ type: 'action_result', id, success }) + '\n';
+        this.socket.write(payload);
+    }
+    close() {
+        this.autoReconnect = false;
+        this.socket.destroy();
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+    }
+}
+exports.BdiClient = BdiClient;
+exports.Panteao = BdiClient;
+exports.Panteão = BdiClient;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/esm/index.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from 'events';
+export interface BdiClientOptions {
+    host?: string;
+    port?: number;
+    autoReconnect?: boolean;
+    reconnectInterval?: number;
+    project?: string;
+    binPath?: string;
+}
+export type ActionCallback = (args: string[], respond: (success: boolean) => void) => void;
+export declare class BdiClient extends EventEmitter {
+    private socket;
+    private host;
+    private port;
+    private buffer;
+    private autoReconnect;
+    private reconnectInterval;
+    private actionHandlers;
+    private project?;
+    private binPath;
+    private process;
+    constructor(options?: BdiClientOptions);
+    connect(): Promise<void>;
+    private setupSocketEvents;
+    private handleIncomingLine;
+    private parseAction;
+    private cleanArg;
+    sendMsg(performative: string, sender: string, receiver: string, content: string): void;
+    sendPerception(action: 'add' | 'remove', perception: string): void;
+    registerAction(actionName: string, callback: ActionCallback): void;
+    private sendActionResult;
+    close(): void;
+}
+export { BdiClient as Panteao, BdiClient as Panteão };

package/dist/esm/index.js

@@ -0,0 +1,323 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Panteão = exports.Panteao = exports.BdiClient = void 0;
+const net = __importStar(require("net"));
+const events_1 = require("events");
+const child_process = __importStar(require("child_process"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'string' ? 0 : address?.port;
+            server.close(() => {
+                if (port)
+                    resolve(port);
+                else
+                    reject(new Error('Failed to allocate port'));
+            });
+        });
+        server.on('error', reject);
+    });
+}
+class BdiClient extends events_1.EventEmitter {
+    socket;
+    host;
+    port;
+    buffer = '';
+    autoReconnect;
+    reconnectInterval;
+    actionHandlers = new Map();
+    project;
+    binPath;
+    process = null;
+    constructor(options = {}) {
+        super();
+        this.host = options.host || '127.0.0.1';
+        this.port = options.port || 0;
+        this.project = options.project;
+        this.autoReconnect = options.project ? false : (options.autoReconnect ?? true);
+        this.reconnectInterval = options.reconnectInterval || 2000;
+        this.socket = new net.Socket();
+        let binPath = options.binPath;
+        if (!binPath) {
+            const isWin = process.platform === 'win32';
+            const binName = isWin ? 'panteao-engine.exe' : 'panteao-engine';
+            // Try to resolve from platform-specific package first
+            const platformPkg = `@panteao/engine-${process.platform}-${process.arch}`;
+            let resolvedPath = null;
+            try {
+                const pkgPath = require.resolve(path.join(platformPkg, 'package.json'));
+                const pkgDir = path.dirname(pkgPath);
+                const candidate = path.join(pkgDir, 'bin', binName);
+                const candidateFallback = path.join(pkgDir, binName);
+                if (fs.existsSync(candidate)) {
+                    resolvedPath = candidate;
+                }
+                else if (fs.existsSync(candidateFallback)) {
+                    resolvedPath = candidateFallback;
+                }
+            }
+            catch (e) {
+                // Platform package not installed or resolved
+            }
+            if (resolvedPath) {
+                binPath = resolvedPath;
+            }
+            else {
+                // Fallback to local paths
+                const candidate1 = path.join(__dirname, binName);
+                const candidate2 = path.join(__dirname, 'bin', binName);
+                if (fs.existsSync(candidate1)) {
+                    binPath = candidate1;
+                }
+                else if (fs.existsSync(candidate2)) {
+                    binPath = candidate2;
+                }
+                else {
+                    binPath = binName;
+                }
+            }
+        }
+        this.binPath = binPath;
+    }
+    async connect() {
+        if (this.project) {
+            if (this.port === 0) {
+                this.port = await getFreePort();
+            }
+            const args = [this.project, '--port', String(this.port)];
+            this.process = child_process.spawn(this.binPath, args, { stdio: 'ignore' });
+            await new Promise((resolve) => setTimeout(resolve, 800));
+        }
+        else if (this.port === 0) {
+            this.port = 44444;
+        }
+        return new Promise((resolve, reject) => {
+            let handshakeBuffer = '';
+            const onConnect = () => {
+                const onData = (data) => {
+                    handshakeBuffer += data.toString('utf8');
+                    const lines = handshakeBuffer.split('\n');
+                    handshakeBuffer = lines.pop() || '';
+                    for (const line of lines) {
+                        try {
+                            if (!line.trim())
+                                continue;
+                            const msg = JSON.parse(line);
+                            if (msg.type === 'mas_ready') {
+                                this.socket.off('data', onData);
+                                this.socket.off('error', onError);
+                                this.setupSocketEvents();
+                                this.emit('connect');
+                                resolve();
+                                return;
+                            }
+                        }
+                        catch (e) { }
+                    }
+                };
+                const onError = (err) => {
+                    this.socket.off('data', onData);
+                    if (this.process) {
+                        this.process.kill();
+                        this.process = null;
+                    }
+                    reject(err);
+                };
+                this.socket.on('data', onData);
+                this.socket.once('error', onError);
+            };
+            const onInitialError = (err) => {
+                if (this.process) {
+                    this.process.kill();
+                    this.process = null;
+                }
+                reject(err);
+            };
+            this.socket.once('error', onInitialError);
+            this.socket.connect(this.port, this.host, () => {
+                this.socket.off('error', onInitialError);
+                onConnect();
+            });
+        });
+    }
+    setupSocketEvents() {
+        this.socket.on('data', (data) => {
+            this.buffer += data.toString('utf8');
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.trim().length === 0)
+                    continue;
+                this.handleIncomingLine(line);
+            }
+        });
+        this.socket.on('close', () => {
+            this.emit('disconnect');
+            if (this.autoReconnect) {
+                setTimeout(() => {
+                    this.connect().catch(() => { });
+                }, this.reconnectInterval);
+            }
+        });
+        this.socket.on('error', (err) => {
+            this.emit('error', err);
+        });
+    }
+    handleIncomingLine(line) {
+        try {
+            const msg = JSON.parse(line);
+            if (msg.type === 'action') {
+                const rawAction = msg.action;
+                const { name, args } = this.parseAction(rawAction);
+                const handler = this.actionHandlers.get(name);
+                if (handler) {
+                    const respond = (success) => {
+                        this.sendActionResult(msg.id, success);
+                    };
+                    handler(args, respond);
+                }
+                else {
+                    this.sendActionResult(msg.id, true);
+                }
+                this.emit('action', { name, args, agent: msg.agent, id: msg.id });
+            }
+            else if (msg.type === 'message') {
+                const { performative, sender, receiver, content } = msg;
+                this.emit('message', performative, sender, receiver, content);
+                this.emit(performative, sender, receiver, content);
+                // Compatibility: parse message content as an action
+                if (content && typeof content === 'string') {
+                    const parsed = this.parseAction(content);
+                    if (parsed && parsed.name) {
+                        const handler = this.actionHandlers.get(parsed.name);
+                        if (handler) {
+                            const dummyRespond = () => { };
+                            handler(parsed.args, dummyRespond);
+                        }
+                        this.emit('action', { name: parsed.name, args: parsed.args, agent: sender, id: null });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    parseAction(actionStr) {
+        const parenIdx = actionStr.indexOf('(');
+        if (parenIdx === -1) {
+            return { name: actionStr.trim(), args: [] };
+        }
+        const name = actionStr.substring(0, parenIdx).trim();
+        const argsStr = actionStr.substring(parenIdx + 1, actionStr.lastIndexOf(')'));
+        const args = [];
+        let current = '';
+        let insideQuotes = false;
+        let depthBrackets = 0;
+        let depthParens = 0;
+        for (let i = 0; i < argsStr.length; i++) {
+            const char = argsStr[i];
+            if (char === '"') {
+                insideQuotes = !insideQuotes;
+                current += char;
+            }
+            else if (!insideQuotes && char === '[') {
+                depthBrackets++;
+                current += char;
+            }
+            else if (!insideQuotes && char === ']') {
+                depthBrackets--;
+                current += char;
+            }
+            else if (!insideQuotes && char === '(') {
+                depthParens++;
+                current += char;
+            }
+            else if (!insideQuotes && char === ')') {
+                depthParens--;
+                current += char;
+            }
+            else if (char === ',' && !insideQuotes && depthBrackets === 0 && depthParens === 0) {
+                args.push(this.cleanArg(current));
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim().length > 0) {
+            args.push(this.cleanArg(current));
+        }
+        return { name, args };
+    }
+    cleanArg(arg) {
+        const s = arg.trim();
+        if (s.startsWith('"') && s.endsWith('"') && s.length >= 2) {
+            return s.substring(1, s.length - 1);
+        }
+        return s;
+    }
+    sendMsg(performative, sender, receiver, content) {
+        const payload = JSON.stringify({ type: 'message', performative, sender, receiver, content }) + '\n';
+        this.socket.write(payload);
+    }
+    sendPerception(action, perception) {
+        const payload = JSON.stringify({ type: 'perception', action, perception }) + '\n';
+        this.socket.write(payload);
+    }
+    registerAction(actionName, callback) {
+        this.actionHandlers.set(actionName, callback);
+    }
+    sendActionResult(id, success) {
+        const payload = JSON.stringify({ type: 'action_result', id, success }) + '\n';
+        this.socket.write(payload);
+    }
+    close() {
+        this.autoReconnect = false;
+        this.socket.destroy();
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+    }
+}
+exports.BdiClient = BdiClient;
+exports.Panteao = BdiClient;
+exports.Panteão = BdiClient;

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "panteao-ts",
+  "version": "1.0.0",
+  "description": "TypeScript client for the Panteao BDI agent engine",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/cjs/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./types": {
+      "types": "./dist/cjs/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.cjs.json && echo '{\"type\": \"module\"}' > dist/esm/package.json && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json"
+  },
+  "keywords": ["bdi", "agents", "jason", "ai", "multi-agent", "typescript"],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "optionalDependencies": {
+    "@panteao/engine-win32-x64": "^1.0.0",
+    "@panteao/engine-linux-x64": "^1.0.0",
+    "@panteao/engine-darwin-arm64": "^1.0.0",
+    "@panteao/engine-darwin-x64": "^1.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,306 @@
+import * as net from 'net';
+import { EventEmitter } from 'events';
+import * as child_process from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+
+export interface BdiClientOptions {
+    host?: string;
+    port?: number;
+    autoReconnect?: boolean;
+    reconnectInterval?: number;
+    project?: string;
+    binPath?: string;
+}
+
+export type ActionCallback = (args: string[], respond: (success: boolean) => void) => void;
+
+function getFreePort(): Promise<number> {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'string' ? 0 : address?.port;
+            server.close(() => {
+                if (port) resolve(port);
+                else reject(new Error('Failed to allocate port'));
+            });
+        });
+        server.on('error', reject);
+    });
+}
+
+export class BdiClient extends EventEmitter {
+    private socket: net.Socket;
+    private host: string;
+    private port: number;
+    private buffer: string = '';
+    private autoReconnect: boolean;
+    private reconnectInterval: number;
+    private actionHandlers: Map<string, ActionCallback> = new Map();
+    private project?: string;
+    private binPath: string;
+    private process: child_process.ChildProcess | null = null;
+
+    constructor(options: BdiClientOptions = {}) {
+        super();
+        this.host = options.host || '127.0.0.1';
+        this.port = options.port || 0;
+        this.project = options.project;
+        this.autoReconnect = options.project ? false : (options.autoReconnect ?? true);
+        this.reconnectInterval = options.reconnectInterval || 2000;
+        this.socket = new net.Socket();
+
+        let binPath = options.binPath;
+        if (!binPath) {
+            const isWin = process.platform === 'win32';
+            const binName = isWin ? 'panteao-engine.exe' : 'panteao-engine';
+            
+            // Try to resolve from platform-specific package first
+            const platformPkg = `@panteao/engine-${process.platform}-${process.arch}`;
+            let resolvedPath: string | null = null;
+            try {
+                const pkgPath = require.resolve(path.join(platformPkg, 'package.json'));
+                const pkgDir = path.dirname(pkgPath);
+                const candidate = path.join(pkgDir, 'bin', binName);
+                const candidateFallback = path.join(pkgDir, binName);
+                if (fs.existsSync(candidate)) {
+                    resolvedPath = candidate;
+                } else if (fs.existsSync(candidateFallback)) {
+                    resolvedPath = candidateFallback;
+                }
+            } catch (e) {
+                // Platform package not installed or resolved
+            }
+
+            if (resolvedPath) {
+                binPath = resolvedPath;
+            } else {
+                // Fallback to local paths
+                const candidate1 = path.join(__dirname, binName);
+                const candidate2 = path.join(__dirname, 'bin', binName);
+                if (fs.existsSync(candidate1)) {
+                    binPath = candidate1;
+                } else if (fs.existsSync(candidate2)) {
+                    binPath = candidate2;
+                } else {
+                    binPath = binName;
+                }
+            }
+        }
+        this.binPath = binPath;
+    }
+
+    public async connect(): Promise<void> {
+        if (this.project) {
+            if (this.port === 0) {
+                this.port = await getFreePort();
+            }
+            const args = [this.project, '--port', String(this.port)];
+            this.process = child_process.spawn(this.binPath, args, { stdio: 'ignore' });
+            await new Promise((resolve) => setTimeout(resolve, 800));
+        } else if (this.port === 0) {
+            this.port = 44444;
+        }
+
+        return new Promise((resolve, reject) => {
+            let handshakeBuffer = '';
+            const onConnect = () => {
+                const onData = (data: Buffer) => {
+                    handshakeBuffer += data.toString('utf8');
+                    const lines = handshakeBuffer.split('\n');
+                    handshakeBuffer = lines.pop() || '';
+                    for (const line of lines) {
+                        try {
+                            if (!line.trim()) continue;
+                            const msg = JSON.parse(line);
+                            if (msg.type === 'mas_ready') {
+                                this.socket.off('data', onData);
+                                this.socket.off('error', onError);
+                                this.setupSocketEvents();
+                                this.emit('connect');
+                                resolve();
+                                return;
+                            }
+                        } catch (e) {}
+                    }
+                };
+                const onError = (err: Error) => {
+                    this.socket.off('data', onData);
+                    if (this.process) {
+                        this.process.kill();
+                        this.process = null;
+                    }
+                    reject(err);
+                };
+                this.socket.on('data', onData);
+                this.socket.once('error', onError);
+            };
+
+            const onInitialError = (err: Error) => {
+                if (this.process) {
+                    this.process.kill();
+                    this.process = null;
+                }
+                reject(err);
+            };
+
+            this.socket.once('error', onInitialError);
+            this.socket.connect(this.port, this.host, () => {
+                this.socket.off('error', onInitialError);
+                onConnect();
+            });
+        });
+    }
+
+    private setupSocketEvents(): void {
+        this.socket.on('data', (data: Buffer) => {
+            this.buffer += data.toString('utf8');
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() || '';
+
+            for (const line of lines) {
+                if (line.trim().length === 0) continue;
+                this.handleIncomingLine(line);
+            }
+        });
+
+        this.socket.on('close', () => {
+            this.emit('disconnect');
+            if (this.autoReconnect) {
+                setTimeout(() => {
+                    this.connect().catch(() => {});
+                }, this.reconnectInterval);
+            }
+        });
+
+        this.socket.on('error', (err: Error) => {
+            this.emit('error', err);
+        });
+    }
+
+    private handleIncomingLine(line: string): void {
+        try {
+            const msg = JSON.parse(line);
+            if (msg.type === 'action') {
+                const rawAction: string = msg.action;
+                const { name, args } = this.parseAction(rawAction);
+                const handler = this.actionHandlers.get(name);
+
+                if (handler) {
+                    const respond = (success: boolean) => {
+                        this.sendActionResult(msg.id, success);
+                    };
+                    handler(args, respond);
+                } else {
+                    this.sendActionResult(msg.id, true);
+                }
+                this.emit('action', { name, args, agent: msg.agent, id: msg.id });
+            } else if (msg.type === 'message') {
+                const { performative, sender, receiver, content } = msg;
+                this.emit('message', performative, sender, receiver, content);
+                this.emit(performative, sender, receiver, content);
+
+                // Compatibility: parse message content as an action
+                if (content && typeof content === 'string') {
+                    const parsed = this.parseAction(content);
+                    if (parsed && parsed.name) {
+                        const handler = this.actionHandlers.get(parsed.name);
+                        if (handler) {
+                            const dummyRespond = () => {};
+                            handler(parsed.args, dummyRespond);
+                        }
+                        this.emit('action', { name: parsed.name, args: parsed.args, agent: sender, id: null });
+                    }
+                }
+            }
+        } catch (e) {
+            this.emit('error', e);
+        }
+    }
+
+    private parseAction(actionStr: string): { name: string; args: string[] } {
+        const parenIdx = actionStr.indexOf('(');
+        if (parenIdx === -1) {
+            return { name: actionStr.trim(), args: [] };
+        }
+
+        const name = actionStr.substring(0, parenIdx).trim();
+        const argsStr = actionStr.substring(parenIdx + 1, actionStr.lastIndexOf(')'));
+        
+        const args: string[] = [];
+        let current = '';
+        let insideQuotes = false;
+        let depthBrackets = 0;
+        let depthParens = 0;
+
+        for (let i = 0; i < argsStr.length; i++) {
+            const char = argsStr[i];
+            if (char === '"') {
+                insideQuotes = !insideQuotes;
+                current += char;
+            } else if (!insideQuotes && char === '[') {
+                depthBrackets++;
+                current += char;
+            } else if (!insideQuotes && char === ']') {
+                depthBrackets--;
+                current += char;
+            } else if (!insideQuotes && char === '(') {
+                depthParens++;
+                current += char;
+            } else if (!insideQuotes && char === ')') {
+                depthParens--;
+                current += char;
+            } else if (char === ',' && !insideQuotes && depthBrackets === 0 && depthParens === 0) {
+                args.push(this.cleanArg(current));
+                current = '';
+            } else {
+                current += char;
+            }
+        }
+        if (current.trim().length > 0) {
+            args.push(this.cleanArg(current));
+        }
+
+        return { name, args };
+    }
+
+    private cleanArg(arg: string): string {
+        const s = arg.trim();
+        if (s.startsWith('"') && s.endsWith('"') && s.length >= 2) {
+            return s.substring(1, s.length - 1);
+        }
+        return s;
+    }
+
+        public sendMsg(performative: string, sender: string, receiver: string, content: string): void {
+        const payload = JSON.stringify({ type: 'message', performative, sender, receiver, content }) + '\n';
+        this.socket.write(payload);
+    }
+
+    public sendPerception(action: 'add' | 'remove', perception: string): void {
+        const payload = JSON.stringify({ type: 'perception', action, perception }) + '\n';
+        this.socket.write(payload);
+    }
+
+    public registerAction(actionName: string, callback: ActionCallback): void {
+        this.actionHandlers.set(actionName, callback);
+    }
+
+    private sendActionResult(id: string, success: boolean): void {
+        const payload = JSON.stringify({ type: 'action_result', id, success }) + '\n';
+        this.socket.write(payload);
+    }
+
+    public close(): void {
+        this.autoReconnect = false;
+        this.socket.destroy();
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+    }
+}
+
+export { BdiClient as Panteao, BdiClient as Panteão };
+

package/tsconfig.cjs.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "outDir": "./dist/cjs"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "outDir": "./dist/esm",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}