orbitx 0.0.1 → 0.0.3

package/src/core/base-agent.ts

@@ -0,0 +1,297 @@
+import type { AIProvider, Message, StreamCallback } from "./ai-provider";
+import type MCPClient from "./mcp-client";
+import type MCPTool from "./mcp";
+import type Skill from "./skill";
+
+export interface ParsedToolCall {
+    id: string;
+    tool: string;
+    inputs: Record<string, any>;
+}
+
+export type ExtractedSegment =
+    | { type: "text"; context: string }
+    | { type: "tool"; context: ParsedToolCall };
+
+export class BaseAgent {
+    #maxMemorizeToken = 16000;
+    #instruction: string = "";
+    #allowedTools: string[] = [];
+
+    #skills: Skill[] = [];
+
+    #memory: string = "";
+
+    #messagesFull: Message[] = [];
+
+    #fullInputMissTokens = 0;
+    #fullInputHitTokens = 0;
+    #fullOutputTokens = 0;
+
+    #messagesCompact: Message[] = [];
+    #currentInputMissTokens = 0;
+    #currentInputHitTokens = 0;
+    #currentLastOutputTokens = 0;
+    #currentOutputTokens = 0;
+
+    #mcpClient: MCPClient;
+    #aiProvider: AIProvider;
+
+    constructor({ instruction, allowedTools, aiProvider, mcpClient, initData = {
+        memory: "",
+        messagesFull: [],
+        fullInputMissTokens: 0,
+        fullInputHitTokens: 0,
+        fullOutputTokens: 0,
+        messagesCompact: [],
+        currentInputMissTokens: 0,
+        currentInputHitTokens: 0,
+        currentOutputTokens: 0,
+    }, skills = [], maxMemorizeToken = 16000 }: {
+        instruction: string;
+        allowedTools: MCPTool[];
+        aiProvider: AIProvider;
+        mcpClient: MCPClient;
+        skills?: Skill[];
+        maxMemorizeToken?: number;
+        initData?: {
+            memory: string;
+            messagesFull: Message[];
+            fullInputMissTokens: number;
+            fullInputHitTokens: number;
+            fullOutputTokens: number;
+            messagesCompact: Message[];
+            currentInputMissTokens: number;
+            currentInputHitTokens: number;
+            currentOutputTokens: number;
+        }
+    }) {
+        this.#instruction = instruction;
+        this.#allowedTools = allowedTools.map(t => t.getOptions().name);
+        this.#aiProvider = aiProvider;
+        this.#mcpClient = mcpClient;
+        this.#memory = initData.memory;
+        this.#messagesFull = initData.messagesFull;
+        this.#fullInputMissTokens = initData.fullInputMissTokens
+        this.#fullInputHitTokens = initData.fullInputHitTokens
+        this.#fullOutputTokens = initData.fullOutputTokens
+        this.#messagesCompact = initData.messagesCompact;
+        this.#currentInputMissTokens = initData.currentInputMissTokens
+        this.#currentInputHitTokens = initData.currentInputHitTokens
+        this.#currentOutputTokens = initData.currentOutputTokens
+        this.#maxMemorizeToken = maxMemorizeToken;
+        this.#skills = skills;
+    }
+
+    #extractJson(str: string): ExtractedSegment[] {
+        const segments: ExtractedSegment[] = [];
+        let cursor = 0;
+        let textStart = 0;
+
+        for (let i = 0; i < str.length; i++) {
+            if (str[i] !== "{") continue;
+
+            let brace = 0;
+            for (let j = i; j < str.length; j++) {
+                if (str[j] === "{") brace++;
+                if (str[j] === "}") brace--;
+
+                if (brace === 0) {
+                    const candidate = str.slice(i, j + 1);
+                    try {
+                        const result = JSON.parse(candidate);
+                        if (
+                            result &&
+                            typeof result === "object" &&
+                            "tool" in result &&
+                            "inputs" in result &&
+                            typeof result.tool === "string"
+                        ) {
+                            const text = str.slice(textStart, i);
+                            if (text.trim().length > 0) {
+                                segments.push({ type: "text", context: text });
+                            }
+                            segments.push({ type: "tool", context: result as ParsedToolCall });
+
+                            i = j;
+                            textStart = j + 1;
+                            cursor = j + 1;
+                        }
+                    } catch {
+                        // not valid JSON, skip
+                    }
+                    break;
+                }
+            }
+        }
+
+        const remaining = str.slice(textStart);
+        if (remaining.trim().length > 0) {
+            segments.push({ type: "text", context: remaining });
+        }
+
+        return segments;
+    }
+
+    async #buildSystemPrompt(): Promise<string> {
+        const tools = (await this.#mcpClient.getTools())
+            .filter(t => this.#allowedTools.includes(t.name));
+
+        const toolBlock = tools.map(t => {
+            const params = t.inputs.map(ti =>
+                `${ti.name}${ti.required ? "" : "?"}:${ti.type}${ti.default !== undefined ? `=${JSON.stringify(ti.default)}` : ""} // ${ti.description}`
+            ).join(", ");
+
+            const example: Record<string, unknown> = {};
+            t.inputs.forEach(ti => {
+                example[ti.name] = ti.default !== undefined ? ti.default
+                    : ti.type === "string" ? "..."
+                        : ti.type === "number" ? 0
+                            : ti.type === "boolean" ? true
+                                : ti.type === "array" ? []
+                                    : {};
+            });
+
+            return `${t.name}(${params || ""})\n${t.description}\nex: {"tool":"${t.name}","inputs":${JSON.stringify(example)}}`;
+        }).join("\n\n");
+
+        return `You are an assistant with tools. CRITICAL RULES:
+1. Think step by step.
+${tools.length > 0 && `2. EVERY tool call MUST include a UNIQUE 10-digit random ID in the format: {"id":"1234567890", "tool":"<name>","inputs":{...}}
+3. The ID MUST be exactly 10 digits (numbers only) and MUST be different for EACH tool call.
+4. Example of VALID tool call: {"id":"7845123698", "tool":"search", "inputs":{"query":"weather"}}
+5. After each tool result, continue reasoning or call another tool.
+6. Never invent tool results.`}
+${tools.length > 0 ? "7" : "2"}. If any rules conflict with upper ones, align with upper rules.
+
+${tools.length > 0 && `REMEMBER: Every tool call MUST include a random 10-digit ID!
+
+TOOLS:
+${toolBlock}
+`}
+
+${this.#skills &&`
+SKILLS:
+${this.#skills.map(skill => (`${skill.getSkill().name} - ${skill.getSkill().description}
+${skill.getSkill().instructions}
+\n`))}
+`}
+
+MEMORY:
+${this.#memory || "(empty)"}
+
+INSTRUCTIONS:
+${this.#instruction}
+`;
+    }
+
+    #buildMemoryPrompt(): string {
+        return `Summarize all important facts and pending tasks from this conversation.
+Output only this JSON line, nothing else:
+{"tool":"set_memory","inputs":{"new_memory":"<compact summary>"}}`;
+    }
+
+    async #extractToolCalls(content: string): Promise<ParsedToolCall[]> {
+        return await this.#extractJson(content)
+            .filter((r: { type: string }) => r.type === "tool")
+            .map((t) => t.context as ParsedToolCall);
+    }
+
+    async #dispatchTool(toolCall: ParsedToolCall): Promise<string> {
+        if (toolCall.tool === "set_memory") {
+            if (typeof toolCall.inputs?.new_memory === "string") {
+                this.#memory = toolCall.inputs.new_memory;
+                return "Memory updated.";
+            }
+            return `Error: set_memory requires new_memory:string, got ${JSON.stringify(toolCall.inputs)}`;
+        }
+
+        if (this.#allowedTools.includes(toolCall.tool)) {
+            return JSON.stringify({ id: toolCall.id, output: await this.#mcpClient.callTool(toolCall.tool, toolCall.inputs) });
+        }
+
+        return `Error: tool "${toolCall.tool}" not found or not allowed.`;
+    }
+
+    async run(prompt: string, streamCallback?: StreamCallback): Promise<void> {
+        let toolsCalls: ParsedToolCall[] = [];
+
+        do {
+            const systemPrompt = await this.#buildSystemPrompt();
+
+            const chat = await this.#aiProvider.chat([
+                { role: "system", content: systemPrompt },
+                ...this.#messagesCompact,
+                { role: "user", content: prompt }
+            ], streamCallback);
+
+            this.#messagesFull.push({ role: "user", content: prompt });
+            this.#messagesCompact.push({ role: "user", content: prompt });
+            this.#messagesFull.push({ role: "assistant", content: chat.content });
+            this.#messagesCompact.push({ role: "assistant", content: chat.content });
+
+            this.#currentInputHitTokens += this.#currentInputMissTokens;
+            this.#currentInputMissTokens += chat.inputTokens - this.#currentInputMissTokens;
+            this.#currentOutputTokens += chat.outputTokens;
+            this.#currentLastOutputTokens = chat.outputTokens;
+
+            toolsCalls = await this.#extractToolCalls(chat.content);
+
+            for (const toolCall of toolsCalls) {
+                const toolResponse = await this.#dispatchTool(toolCall);
+                this.#messagesFull.push({ role: "system", content: toolResponse });
+                this.#messagesCompact.push({ role: "system", content: toolResponse });
+                streamCallback?.({ role: "tool", content: toolResponse, done: true });
+            }
+
+            if (this.#currentInputMissTokens + this.#currentLastOutputTokens > this.#maxMemorizeToken) {
+                const memChat = await this.#aiProvider.chat([
+                    { role: "system", content: systemPrompt },
+                    ...this.#messagesCompact,
+                    { role: "user", content: this.#buildMemoryPrompt() }
+                ]);
+
+                this.#currentInputHitTokens += this.#currentInputMissTokens;
+                this.#currentInputMissTokens += memChat.inputTokens - this.#currentInputMissTokens;
+                this.#currentOutputTokens += memChat.outputTokens;
+
+                for (const mc of await this.#extractToolCalls(memChat.content)) {
+                    const toolResponse = await this.#dispatchTool(mc);
+                    streamCallback?.({ role: "tool", content: toolResponse, done: true });
+                }
+
+                this.#messagesCompact = [];
+                this.#fullInputHitTokens += this.#currentInputHitTokens;
+                this.#fullInputMissTokens += this.#currentInputMissTokens;
+                this.#fullOutputTokens += this.#currentOutputTokens;
+                this.#currentInputHitTokens = 0;
+                this.#currentInputMissTokens = 0;
+                this.#currentOutputTokens = 0;
+                this.#currentLastOutputTokens = 0;
+            }
+
+            prompt = "";
+
+        } while (toolsCalls.length > 0);
+    }
+
+    getCurrentTotalTokens() {
+        return {
+            total: this.#currentInputHitTokens + this.#currentInputMissTokens + this.#currentOutputTokens,
+            inputHit: this.#currentInputHitTokens,
+            inputMiss: this.#currentInputMissTokens,
+            output: this.#currentOutputTokens
+        };
+    }
+
+    getFullTotalTokens() {
+        return {
+            total: this.#fullInputHitTokens + this.#fullInputMissTokens + this.#fullOutputTokens,
+            inputHit: this.#fullInputHitTokens,
+            inputMiss: this.#fullInputMissTokens,
+            output: this.#fullOutputTokens
+        };
+    }
+}
+
+export default BaseAgent;

package/src/core/deepseek-provider.ts

@@ -0,0 +1,71 @@
+import OpenAI from "openai";
+import AIProvider, { type Message, type ChatResponse, type StreamCallback } from "./ai-provider";
+
+export class DeepSeekProvider extends AIProvider {
+    private client: OpenAI;
+    private model: string;
+
+    constructor(apiKey: string, model: string = "deepseek-v4-flash") {
+        super();
+        this.client = new OpenAI({
+            apiKey: apiKey,
+            baseURL: "https://api.deepseek.com"
+        });
+        this.model = model;
+    }
+
+    async chat(
+        messages: Message[],
+        streamCallback?: StreamCallback
+    ): Promise<ChatResponse> {
+        const formattedMessages = messages.map(msg => ({
+            role: msg.role,
+            content: msg.content || ""
+        }));
+
+        if (streamCallback) {
+            const stream = await this.client.chat.completions.create({
+                model: this.model,
+                messages: formattedMessages as any,
+                stream: true
+            });
+
+            let fullContent = "";
+            let inputTokens = 0;
+            let outputTokens = 0;
+
+            for await (const chunk of stream) {
+                const content = chunk.choices[0]?.delta?.content || "";
+                if (content) {
+                    fullContent += content;
+                    streamCallback({ role: "assistant", content, done: false });
+                }
+
+                if (chunk.usage) {
+                    inputTokens = chunk.usage.prompt_tokens || 0;
+                    outputTokens = chunk.usage.completion_tokens || 0;
+                }
+            }
+
+            streamCallback({ role: "assistant", content: "", done: true });
+            return {
+                content: fullContent,
+                inputTokens,
+                outputTokens,
+            };
+        } else {
+            const response = await this.client.chat.completions.create({
+                model: this.model,
+                messages: formattedMessages as any
+            });
+
+            return {
+                content: response.choices[0]?.message?.content || "",
+                inputTokens: response.usage?.prompt_tokens || 0,
+                outputTokens: response.usage?.completion_tokens || 0,
+            };
+        }
+    }
+}
+
+export default DeepSeekProvider;

package/src/core/mcp-client.ts

@@ -0,0 +1,113 @@
+import type MCPTool from "./mcp";
+import type MCPConnection from "./mcp-connection";
+import { randomUUID } from "crypto";
+
+export class MCPClient {
+    #connections;
+    #tools: MCPTool[] = [];
+    #envID;
+    constructor(envID: string, connection: MCPConnection | MCPConnection[]) {
+        this.#connections = Array.isArray(connection) ? connection : [connection];
+        this.#envID = envID;
+    }
+
+    async getTools() {
+        const connectionPromises = this.#connections.map(conn => {
+            return new Promise<{
+                name: string;
+                description: string;
+                inputs: {
+                    name: string;
+                    type: "number" | "string" | "boolean" | "object" | "array";
+                    description: string;
+                    required?: boolean;
+                    default?: any;
+                }[];
+            }[]>((resolve) => {
+                const pid = randomUUID();
+                let resolved = false;
+
+                const onRead = (data: any) => {
+                    if (data.topic === "getToolsCallback" && data.pid === pid) {
+                        resolved = true;
+                        conn.off("read", onRead);
+                        resolve(data.tools || []);
+                    }
+                };
+
+                conn.on("read", onRead);
+                conn.emit("write", {
+                    pid,
+                    topic: "getTools"
+                });
+
+                setTimeout(() => {
+                    if (!resolved) {
+                        conn.off("read", onRead);
+                        resolve([]);
+                    }
+                }, 2000);
+            });
+        });
+
+        const results = await Promise.all(connectionPromises);
+
+        const connectionsTools = results.flat();
+        return [...this.#tools.map(t => ({
+            name: t.getOptions().name,
+            description: t.getOptions().description,
+            inputs: t.getOptions().inputs
+        })), ...connectionsTools];
+    }
+
+    async callTool(toolName: string, inputs: Record<string, any>) {
+        const clientTool = this.#tools.find(t => t.getOptions().name == toolName);
+        if (clientTool) {
+            return JSON.stringify(await clientTool.getOptions().execute(this.#envID, inputs));
+        } else {
+            return JSON.stringify(await new Promise<any>((resolve) => {
+                let resolvedResult = false;
+                this.#connections.map(conn => {
+                    const pid = randomUUID();
+                    let resolved = false;
+
+                    const onRead = (data: any) => {
+                        if (data.topic === "toolCallCallback" && data.pid === pid) {
+                            resolved = true;
+                            conn.off("read", onRead);
+                            if (!resolvedResult) {
+                                resolve(data.output || {});
+                                resolvedResult = true;
+                            }
+                        }
+                    };
+
+                    conn.on("read", onRead);
+                    conn.emit("write", {
+                        pid,
+                        topic: "toolCall",
+                        tool: toolName,
+                        envID: this.#envID,
+                        inputs
+                    });
+
+                    setTimeout(() => {
+                        if (!resolved) {
+                            conn.off("read", onRead);
+                        }
+                        if (!resolvedResult) {
+                            resolve({ error: "The tool call exceeded the 300second timeout limit." });
+                            resolvedResult = true;
+                        }
+                    }, 300000);
+                });
+            }));
+        }
+    }
+
+    registerTool(tool: MCPTool) {
+        this.#tools.push(tool);
+    }
+}
+
+export default MCPClient;

package/src/core/mcp-computer.ts

@@ -0,0 +1,5 @@
+export default class MCPComputer {
+    constructor() {
+
+    }
+}

package/src/core/mcp-connection.ts

@@ -0,0 +1,12 @@
+import EventEmitter from "events";
+
+export class MCPConnection extends EventEmitter {
+    constructor(overrided: boolean = false) {
+        super();
+
+        if (!overrided)
+            this.on("write", (data) => this.emit("read", data))
+    }
+}
+
+export default MCPConnection;

package/src/core/mcp-ipc-connection.ts

@@ -0,0 +1,153 @@
+import * as net from "net";
+import * as fs from "fs";
+import MCPConnection from "./mcp-connection";
+
+type Role = "server" | "client" | "pending";
+
+export class MCPIPCConnection extends MCPConnection {
+    private readonly socketPath: string;
+    private socket: net.Socket | null = null;
+    private server: net.Server | null = null;
+    private role: Role = "pending";
+    private writeBuffer: Buffer[] = [];
+    private readBuffer = "";
+
+    constructor(socketPath: string) {
+        super(true);
+        this.socketPath = socketPath;
+
+        this.on("write", (data: unknown) => {
+            this._sendJSON(data);
+        });
+
+        setTimeout(() => {
+            this._tryConnect();
+        }, Math.random() * 200); // Pervent Race Condtion
+    }
+
+    close(): void {
+        this.socket?.destroy();
+        this.server?.close();
+        this._cleanSocketFile();
+    }
+
+    private _tryConnect(): void {
+        const sock = net.createConnection({ path: this.socketPath });
+
+        sock.once("connect", () => {
+            this.role = "client";
+            this.emit("role", "client");
+            this._attachSocket(sock);
+        });
+
+        sock.once("error", (err: NodeJS.ErrnoException) => {
+            if (err.code === "ENOENT" || err.code === "ECONNREFUSED") {
+                sock.destroy();
+                this._becomeServer();
+            } else {
+                this.emit("error", err);
+            }
+        });
+    }
+
+    private _becomeServer(): void {
+        this._cleanSocketFile();
+
+        const srv = net.createServer((peer) => {
+            this.role = "server";
+            this.emit("role", "server");
+
+            srv.close();
+
+            this._attachSocket(peer);
+        });
+
+        srv.on("error", (err) => this.emit("error", err));
+
+        srv.listen({ path: this.socketPath }, () => {
+            this.server = srv;
+            this.emit("listening", this.socketPath);
+        });
+    }
+
+    private _attachSocket(sock: net.Socket): void {
+        this.socket = sock;
+
+        for (const chunk of this.writeBuffer) {
+            sock.write(chunk);
+        }
+        this.writeBuffer = [];
+
+        sock.setEncoding("utf8");
+
+        sock.on("data", (chunk: string) => {
+            this._handleIncoming(chunk);
+        });
+
+        sock.on("end", () => {
+            this.emit("disconnected");
+            this._maybeReconnect();
+        });
+
+        sock.on("error", (err: NodeJS.ErrnoException) => {
+            this.emit("error", err);
+        });
+
+        this.emit("connected", this.role);
+    }
+
+    private _sendJSON(data: unknown): void {
+        let line: string;
+        try {
+            line = JSON.stringify(data) + "\n";
+        } catch (err) {
+            this.emit("error", new Error(`MCPIPCConnection: cannot serialise data – ${err}`));
+            return;
+        }
+
+        const chunk = Buffer.from(line, "utf8");
+
+        if (this.socket && !this.socket.destroyed) {
+            this.socket.write(chunk);
+        } else {
+            this.writeBuffer.push(chunk);
+        }
+    }
+
+    private _handleIncoming(chunk: string): void {
+        this.readBuffer += chunk;
+
+        const lines = this.readBuffer.split("\n");
+
+        this.readBuffer = lines.pop() ?? "";
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+
+            try {
+                const parsed = JSON.parse(trimmed);
+                this.emit("read", parsed);
+            } catch {
+                this.emit("error", new Error(`MCPIPCConnection: malformed JSON – ${trimmed}`));
+            }
+        }
+    }
+
+    private _cleanSocketFile(): void {
+        try {
+            fs.unlinkSync(this.socketPath);
+        } catch { }
+    }
+
+    private _maybeReconnect(): void {
+        if (this.role === "client") {
+            setTimeout(() => {
+                this.role = "pending";
+                this._tryConnect();
+            }, 500);
+        }
+    }
+}
+
+export default MCPIPCConnection;