@open1s/ezbos 1.0.1 → 1.0.3

package/dist/agent.d.ts

@@ -0,0 +1,78 @@
+import * as jsbos from '@open1s/jsbos';
+import { SkillDef } from './skills.js';
+export declare class AgentBuilder {
+    private _inner;
+    private _tools;
+    private _hooks;
+    private _plugins;
+    private _mcp;
+    private _skillsDirs;
+    private _inlineSkills;
+    private _config;
+    constructor(name: string, options?: {
+        model?: string;
+        baseUrl?: string;
+        apiKey?: string;
+        systemPrompt?: string;
+        temperature?: number;
+        timeoutSecs?: number;
+        maxTokens?: number;
+        circuitBreakerMaxFailures?: number;
+        circuitBreakerCooldownSecs?: number;
+        rateLimitCapacity?: number;
+        rateLimitWindowSecs?: number;
+        rateLimitMaxRetries?: number;
+    });
+    with_model(model: string): this;
+    with_baseUrl(url: string): this;
+    with_apiKey(key: string): this;
+    with_systemPrompt(prompt: string): this;
+    with_prompt(prompt: string): this;
+    with_temperature(temp: number): this;
+    with_timeout(secs: number): this;
+    with_maxTokens(tokens: number): this;
+    with_tools(...tools: any[]): this;
+    register(...tools: any[]): this;
+    with_hooks(...sources: any[]): this;
+    with_plugins(...sources: any[]): this;
+    with_mcp_process(namespace: string, command: string, args: string[]): this;
+    with_mcp_http(namespace: string, url: string): this;
+    with_skills_dir(dirPath: string): this;
+    with_skills(...skills: SkillDef[]): this;
+    with_resilience(opts: {
+        circuitBreakerMaxFailures?: number;
+        circuitBreakerCooldownSecs?: number;
+        rateLimitCapacity?: number;
+        rateLimitWindowSecs?: number;
+        rateLimitMaxRetries?: number;
+    }): this;
+    start(): Promise<Agent>;
+    private rebuildAgentWithPrompt;
+    ask(prompt: string): Promise<string>;
+    runSimple(prompt: string): Promise<string>;
+    react(task: string): Promise<string>;
+    stop(): Promise<void>;
+}
+export declare class Agent {
+    private _inner;
+    constructor(_inner: jsbos.Agent);
+    run(task: string): Promise<string>;
+    ask(prompt: string): Promise<string>;
+    runSimple(prompt: string): Promise<string>;
+    react(task: string): Promise<string>;
+    compactSession(): Promise<void>;
+    saveSession(path: string): void;
+    restoreSession(path: string): void;
+    clearSession(): void;
+    exportSession(): string;
+    importSession(json: string): void;
+    stream(task: string, onToken: (token: any) => void): Promise<string>;
+    streamCollect(task: string): Promise<any[]>;
+    get tools(): string[];
+    get config(): any;
+    get inner(): jsbos.Agent;
+    listMcpTools(): Promise<any[]>;
+    get metrics(): jsbos.PerfSnapshot;
+    resetMetrics(): void;
+    close(): Promise<void>;
+}

package/dist/agent.js

@@ -0,0 +1,316 @@
+import * as jsbos from '@open1s/jsbos';
+import { mergeHooks } from './hook.js';
+import { mergePlugins } from './plugin.js';
+const DEFAULT_MODEL = 'nvidia/meta/llama-3.1-8b-instruct';
+const DEFAULT_BASE_URL = 'https://integrate.api.nvidia.com/v1';
+export class AgentBuilder {
+    _inner = null;
+    _tools = [];
+    _hooks = [];
+    _plugins = [];
+    _mcp = [];
+    _skillsDirs = [];
+    _inlineSkills = [];
+    _config;
+    constructor(name, options = {}) {
+        this._config = {
+            name,
+            model: options.model || DEFAULT_MODEL,
+            baseUrl: options.baseUrl || DEFAULT_BASE_URL,
+            apiKey: options.apiKey,
+            systemPrompt: options.systemPrompt || 'You are a helpful assistant.',
+            temperature: options.temperature ?? 0.7,
+            timeoutSecs: options.timeoutSecs || 120,
+            maxTokens: options.maxTokens ?? 4096,
+            circuitBreakerMaxFailures: options.circuitBreakerMaxFailures,
+            circuitBreakerCooldownSecs: options.circuitBreakerCooldownSecs,
+            rateLimitCapacity: options.rateLimitCapacity,
+            rateLimitWindowSecs: options.rateLimitWindowSecs,
+            rateLimitMaxRetries: options.rateLimitMaxRetries,
+        };
+    }
+    with_model(model) {
+        this._config.model = model;
+        return this;
+    }
+    with_baseUrl(url) {
+        this._config.baseUrl = url;
+        return this;
+    }
+    with_apiKey(key) {
+        this._config.apiKey = key;
+        return this;
+    }
+    with_systemPrompt(prompt) {
+        this._config.systemPrompt = prompt;
+        return this;
+    }
+    with_prompt(prompt) {
+        return this.with_systemPrompt(prompt);
+    }
+    with_temperature(temp) {
+        this._config.temperature = temp;
+        return this;
+    }
+    with_timeout(secs) {
+        this._config.timeoutSecs = secs;
+        return this;
+    }
+    with_maxTokens(tokens) {
+        this._config.maxTokens = tokens;
+        return this;
+    }
+    with_tools(...tools) {
+        for (const t of tools) {
+            if (t && typeof t === 'object' && 'name' in t && 'description' in t && 'callback' in t) {
+                this._tools.push(t);
+            }
+            else if (typeof t === 'function' && t.toolDef) {
+                this._tools.push(t.toolDef);
+            }
+        }
+        return this;
+    }
+    register(...tools) {
+        return this.with_tools(...tools);
+    }
+    with_hooks(...sources) {
+        const merged = mergeHooks(...sources);
+        this._hooks.push(...merged);
+        return this;
+    }
+    with_plugins(...sources) {
+        const merged = mergePlugins(...sources);
+        this._plugins.push(...merged);
+        return this;
+    }
+    with_mcp_process(namespace, command, args) {
+        this._mcp.push({ type: 'process', namespace, command, args });
+        return this;
+    }
+    with_mcp_http(namespace, url) {
+        this._mcp.push({ type: 'http', namespace, url });
+        return this;
+    }
+    with_skills_dir(dirPath) {
+        this._skillsDirs.push(dirPath);
+        return this;
+    }
+    with_skills(...skills) {
+        this._inlineSkills.push(...skills);
+        return this;
+    }
+    with_resilience(opts) {
+        if (opts.circuitBreakerMaxFailures !== undefined) {
+            this._config.circuitBreakerMaxFailures = opts.circuitBreakerMaxFailures;
+        }
+        if (opts.circuitBreakerCooldownSecs !== undefined) {
+            this._config.circuitBreakerCooldownSecs = opts.circuitBreakerCooldownSecs;
+        }
+        if (opts.rateLimitCapacity !== undefined) {
+            this._config.rateLimitCapacity = opts.rateLimitCapacity;
+        }
+        if (opts.rateLimitWindowSecs !== undefined) {
+            this._config.rateLimitWindowSecs = opts.rateLimitWindowSecs;
+        }
+        if (opts.rateLimitMaxRetries !== undefined) {
+            this._config.rateLimitMaxRetries = opts.rateLimitMaxRetries;
+        }
+        return this;
+    }
+    async start() {
+        this._inner = await jsbos.Agent.create(this._config);
+        for (const tool of this._tools) {
+            this._inner.addTool(tool.name, tool.description, JSON.stringify(tool.schema.properties || {}), JSON.stringify(tool.schema), (err, args) => {
+                if (err)
+                    return String(err);
+                try {
+                    return tool.callback(args);
+                }
+                catch (e) {
+                    return String(e);
+                }
+            });
+        }
+        for (const { event, callback } of this._hooks) {
+            this._inner.registerHook(event, async (e, ctx) => {
+                if (e)
+                    return 'continue';
+                return await callback(ctx);
+            });
+        }
+        for (const plugin of this._plugins) {
+            this._inner.registerPlugin(plugin.name || 'plugin', plugin.on_llm_request ? ((err, arg) => {
+                if (err)
+                    return;
+                return plugin.on_llm_request(arg);
+            }) : undefined, plugin.on_llm_response ? ((err, arg) => {
+                if (err)
+                    return;
+                return plugin.on_llm_response(arg);
+            }) : undefined, plugin.on_tool_call ? ((err, arg) => {
+                if (err)
+                    return;
+                return plugin.on_tool_call(arg);
+            }) : undefined, plugin.on_tool_result ? ((err, arg) => {
+                if (err)
+                    return;
+                return plugin.on_tool_result(arg);
+            }) : undefined);
+        }
+        for (const mcp of this._mcp) {
+            if (mcp.type === 'process' && mcp.command && mcp.args) {
+                await this._inner.addMcpServer(mcp.namespace, mcp.command, mcp.args);
+            }
+            else if (mcp.type === 'http' && mcp.url) {
+                await this._inner.addMcpServerHttp(mcp.namespace, mcp.url);
+            }
+        }
+        let systemPrompt = this._config.systemPrompt || '';
+        for (const dir of this._skillsDirs) {
+            await this._inner.registerSkillsFromDir(dir);
+        }
+        for (const skill of this._inlineSkills) {
+            const addition = `\n\n# Skill: ${skill.name}\n${skill.content}`;
+            systemPrompt += addition;
+        }
+        if (systemPrompt !== this._config.systemPrompt) {
+            this._config.systemPrompt = systemPrompt;
+            const newAgent = await this.rebuildAgentWithPrompt(systemPrompt);
+            this._inner = newAgent;
+        }
+        return new Agent(this._inner);
+    }
+    async rebuildAgentWithPrompt(newPrompt) {
+        const newAgent = await jsbos.Agent.create({
+            name: this._config.name,
+            model: this._config.model,
+            baseUrl: this._config.baseUrl,
+            apiKey: this._config.apiKey || '',
+            systemPrompt: newPrompt,
+            temperature: this._config.temperature,
+            timeoutSecs: this._config.timeoutSecs,
+            maxTokens: this._config.maxTokens,
+        });
+        for (const tool of this._tools) {
+            newAgent.addTool(tool.name, tool.description, JSON.stringify(tool.schema.properties || {}), JSON.stringify(tool.schema), (err, args) => {
+                if (err)
+                    return String(err);
+                try {
+                    return tool.callback(args);
+                }
+                catch (e) {
+                    return String(e);
+                }
+            });
+        }
+        return newAgent;
+    }
+    async ask(prompt) {
+        if (!this._inner)
+            await this.start();
+        return this._inner.react(prompt);
+    }
+    async runSimple(prompt) {
+        if (!this._inner)
+            await this.start();
+        return this._inner.runSimple(prompt);
+    }
+    async react(task) {
+        if (!this._inner)
+            await this.start();
+        return this._inner.react(task);
+    }
+    async stop() {
+        if (!this._inner)
+            return;
+        this._inner.stop();
+    }
+}
+export class Agent {
+    _inner;
+    constructor(_inner) {
+        this._inner = _inner;
+    }
+    async run(task) {
+        return this._inner.runSimple(task);
+    }
+    async ask(prompt) {
+        return this._inner.react(prompt);
+    }
+    async runSimple(prompt) {
+        return this._inner.runSimple(prompt);
+    }
+    async react(task) {
+        return this._inner.react(task);
+    }
+    async compactSession() {
+        const sessionJson = this._inner.getSessionJson();
+        const compactedJson = await this.ask(`Compact this session JSON. Preserve all important context, facts, and decisions while removing redundant messages. Return ONLY valid JSON. Use exact role names: "System", "User", "Assistant", "AssistantToolCall", "ToolResult".\n\nSession JSON:\n${sessionJson}`);
+        let cleaned = compactedJson.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+        cleaned = cleaned.replace(/"user"/g, '"User"')
+            .replace(/"assistant"/g, '"Assistant"')
+            .replace(/"system"/g, '"System"')
+            .replace(/"toolresult"/g, '"ToolResult"')
+            .replace(/"assistanttoolcall"/g, '"AssistantToolCall"');
+        this._inner.restoreSessionJson(cleaned);
+    }
+    saveSession(path) {
+        this._inner.saveSession(path);
+    }
+    restoreSession(path) {
+        this._inner.restoreSessionFromFile(path);
+    }
+    clearSession() {
+        this._inner.clearSession();
+    }
+    exportSession() {
+        return this._inner.getSessionJson();
+    }
+    importSession(json) {
+        this._inner.restoreSessionJson(json);
+    }
+    stream(task, onToken) {
+        return this._inner.stream(task, (err, token) => {
+            if (err) {
+                onToken({ type: 'Error', error: err.message });
+            }
+            else {
+                onToken(token);
+            }
+        });
+    }
+    async streamCollect(task) {
+        const tokens = [];
+        await new Promise((resolve) => {
+            this.stream(task, token => {
+                tokens.push(token);
+                if (token.type === 'Done') {
+                    resolve();
+                }
+            });
+        });
+        return tokens;
+    }
+    get tools() {
+        return this._inner.listTools();
+    }
+    get config() {
+        return this._inner.config();
+    }
+    get inner() {
+        return this._inner;
+    }
+    async listMcpTools() {
+        return this._inner.listMcpTools();
+    }
+    get metrics() {
+        return this._inner.getPerfMetrics();
+    }
+    resetMetrics() {
+        this._inner.resetPerfMetrics();
+    }
+    async close() {
+        this._inner.close();
+    }
+}

package/dist/brainos.d.ts

@@ -0,0 +1,99 @@
+import * as jsbos from '@open1s/jsbos';
+import { AgentBuilder, Agent } from './agent.js';
+interface BrainOSOptions {
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+}
+interface BusOptions {
+    mode?: string;
+    connect?: string[];
+    listen?: string[];
+    peer?: string;
+}
+export declare class BrainOS {
+    private _bus;
+    private _started;
+    private _config;
+    private _options;
+    constructor(options?: BrainOSOptions);
+    start(): Promise<this>;
+    stop(): Promise<void>;
+    get isStarted(): boolean;
+    with_bus(config: BusOptions): this;
+    agent(name?: string, options?: {
+        model?: string;
+        baseUrl?: string;
+        apiKey?: string;
+        systemPrompt?: string;
+        temperature?: number;
+        timeoutSecs?: number;
+        maxTokens?: number;
+    }): AgentBuilder;
+    get bus(): jsbos.Bus;
+    publish(topic: string, payload: any, isJson?: boolean): Promise<void>;
+    publisher(topic: string): Promise<PublisherWrapper>;
+    subscriber(topic: string): Promise<SubscriberWrapper>;
+    query(topic: string): Promise<QueryClient>;
+    queryable(topic: string, handler?: (input: string) => any): Promise<QueryableServer>;
+    caller(name: string): Promise<CallerClient>;
+    callable(uri: string, handler?: (input: string) => any): Promise<CallableServer>;
+    get config(): any;
+    static with(name?: string, options?: BrainOSOptions): Promise<Agent>;
+}
+export declare class PublisherWrapper {
+    private _inner;
+    constructor(_inner: jsbos.Publisher);
+    get topic(): string;
+    publish(payload: any, isJson?: boolean): Promise<void>;
+    text(payload: string): Promise<void>;
+    json(data: any): Promise<void>;
+}
+export declare class SubscriberWrapper {
+    private _inner;
+    constructor(_inner: jsbos.Subscriber);
+    get topic(): string;
+    recv(timeoutMs?: number): Promise<string | null>;
+    recvJson(timeoutMs?: number): Promise<any | null>;
+    run(callback: (msg: string) => void): Promise<void>;
+    runJson(callback: (data: any) => void): Promise<void>;
+    stop(): Promise<void>;
+    [Symbol.asyncIterator](): this;
+    next(): Promise<{
+        done: boolean;
+        value?: string;
+    }>;
+}
+export declare class QueryClient {
+    private _inner;
+    constructor(_inner: jsbos.Query);
+    get topic(): string;
+    ask(payload: string, timeoutMs?: number): Promise<string>;
+    askJson(payload: any, timeoutMs?: number): Promise<any>;
+}
+export declare class QueryableServer {
+    private _inner;
+    private _handler?;
+    constructor(_inner: jsbos.Queryable, handler?: (input: string) => any);
+    handle(handler: (input: string) => any): this;
+    start(): Promise<this>;
+    run(handler: (input: string) => any): Promise<void>;
+    runJson(handler: (input: any) => any): Promise<void>;
+}
+export declare class CallerClient {
+    private _inner;
+    constructor(_inner: jsbos.Caller);
+    call(payload: string): Promise<string>;
+    callJson(payload: any): Promise<any>;
+}
+export declare class CallableServer {
+    private _inner;
+    private _handler?;
+    constructor(_inner: jsbos.Callable, handler?: (input: string) => any);
+    handle(handler: (input: string) => any): this;
+    get isStarted(): boolean;
+    start(): Promise<this>;
+    run(handler: (input: string) => any): Promise<void>;
+    runJson(handler: (input: any) => any): Promise<void>;
+}
+export {};