orbitx 0.0.1 → 0.0.2

package/.env.example

@@ -0,0 +1 @@
+CHROME_PATH="C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"

package/Readme.md

@@ -0,0 +1,81 @@
+[![OrbitX Logo](./orbitx.png)](#)
+
+
+Better DOCS Coming soon Sorry
+
+Example of Simple Agent
+```ts
+const ollamaProvider = new OllamaProvider("gemma3:latest");
+
+const agent = new SimpleAgent({
+    aiProvider: ollamaProvider,
+    instruction: "",
+    tools: [GetCurrentTimeTool]
+});
+
+let oldRole: "assistant" | "tool" | undefined;
+agent.run("what is current time?", (chunk) => {
+    if (oldRole != chunk.role) {
+        process.stdout.write(`\n${chunk.role}: `);
+        oldRole = chunk.role;
+    }
+    process.stdout.write(chunk.content);
+    if (chunk.done) {
+        process.stdout.write("\n\n");
+        oldRole = undefined;
+    }
+});
+```
+
+Example of Research Agent
+```ts
+const ollamaProvider = new OllamaProvider("gemma3:latest");
+
+const agent = new ResearcherAgent({ aiProvider: ollamaProvider });
+
+let oldRole: "assistant" | "tool" | undefined;
+agent.run("what is IRR Value In USD", (chunk) => {
+    if (oldRole != chunk.role) {
+        process.stdout.write(`\n${chunk.role}: `);
+        oldRole = chunk.role;
+    }
+    process.stdout.write(chunk.content);
+    if (chunk.done) {
+        process.stdout.write("\n\n");
+        oldRole = undefined;
+    }
+});
+```
+
+
+
+Writing from base
+```ts
+const ollamaProvider = new OllamaProvider("gemma3:latest");
+
+const connection = new MCPConnection();
+
+const mcpServer = new MCPServer(connection);
+mcpServer.registerTool(GetCurrentTimeTool);
+const mcpClient = new MCPClient("DEFAULT_ENV", connection);
+
+const agent = new BaseAgent({
+    aiProvider: ollamaProvider,
+    instruction: "",
+    mcpClient,
+    allowedTools: [GetCurrentTimeTool]
+});
+
+let oldRole: "assistant" | "tool" | undefined;
+agent.run("what is current time?", (chunk) => {
+    if (oldRole != chunk.role) {
+        process.stdout.write(`\n${chunk.role}: `);
+        oldRole = chunk.role;
+    }
+    process.stdout.write(chunk.content);
+    if (chunk.done) {
+        process.stdout.write("\n\n");
+        oldRole = undefined;
+    }
+});
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orbitx",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "An AI SDK providing agents, swarms, planners, skills, MCP tools, workflows, and multi-provider AI integrations.",
   "main": "index.js",
   "scripts": {
@@ -14,6 +14,21 @@
     "Skills",
     "Tools"
   ],
+  "type": "module",
   "author": "ali39",
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "express": "^5.2.1",
+    "ollama": "^0.6.3",
+    "openai": "^6.45.0",
+    "puppeteer-core": "^24.43.1",
+    "socket.io": "^4.8.3"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.0.0",
+    "nodemon": "^3.1.14",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
+  }
 }

package/src/core/ai-provider.ts

@@ -0,0 +1,25 @@
+export interface Message {
+    role: "user" | "system" | "assistant" | "tool";
+    content?: string;
+}
+
+export interface ChatResponse {
+    content: string;
+    inputTokens: number;
+    outputTokens: number;
+}
+
+export type StreamCallback = (chunk: {
+    role: "assistant" | "tool";
+    content: string;
+    done: boolean;
+}) => void;
+
+export abstract class AIProvider {
+    abstract chat(
+        messages: Message[],
+        streamCallback?: StreamCallback
+    ): Promise<ChatResponse>;
+}
+
+export default AIProvider;

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 += this.#currentOutputTokens;
+            this.#currentLastOutputTokens = this.#currentOutputTokens;
+
+            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 += this.#currentOutputTokens;
+
+                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;