@open1s/ezbos 1.0.0

package/src/brainos.ts

@@ -0,0 +1,357 @@
+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 class BrainOS {
+  private _bus: jsbos.Bus | null = null;
+  private _started = false;
+  private _config: any = null;
+  private _options: BrainOSOptions & { bus?: BusOptions } = {};
+
+  constructor(options: BrainOSOptions = {}) {
+    this._options = options;
+  }
+
+  async start(): Promise<this> {
+    const loader = new jsbos.ConfigLoader();
+    loader.discover();
+    try {
+      this._config = JSON.parse(loader.loadSync());
+    } catch {
+      this._config = {};
+    }
+
+    const gm = this._config.global_model || {};
+    const apiKey = this._options.apiKey || gm.api_key;
+    const baseUrl = this._options.baseUrl || gm.base_url || 'https://integrate.api.nvidia.com/v1';
+    const model = this._options.model || gm.model || 'nvidia/meta/llama-3.1-8b-instruct';
+
+    this._options.apiKey = apiKey;
+    this._options.baseUrl = baseUrl;
+    this._options.model = model;
+
+    const busConfig = this._options.bus || { mode: 'peer' };
+    this._bus = await jsbos.Bus.create(busConfig as any);
+    this._started = true;
+
+    return this;
+  }
+
+  async stop(): Promise<void> {
+    if (this._bus) {
+      this._bus = null;
+    }
+    this._started = false;
+  }
+
+  get isStarted(): boolean {
+    return this._started;
+  }
+
+  with_bus(config: BusOptions): this {
+    this._options.bus = { ...this._options.bus, ...config };
+    return this;
+  }
+
+  agent(name: string = 'assistant', options: {
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    systemPrompt?: string;
+    temperature?: number;
+    timeoutSecs?: number;
+    maxTokens?: number;
+  } = {}): AgentBuilder {
+    if (!this._started) {
+      throw new Error('BrainOS not started. Call start() first.');
+    }
+    return new AgentBuilder(name, {
+      ...this._options,
+      ...options,
+      apiKey: options.apiKey || this._options.apiKey,
+      model: options.model || this._options.model,
+      baseUrl: options.baseUrl || this._options.baseUrl,
+    });
+  }
+
+  get bus(): jsbos.Bus {
+    if (!this._started) throw new Error('BrainOS not started');
+    return this._bus!;
+  }
+
+  async publish(topic: string, payload: any, isJson: boolean = false): Promise<void> {
+    if (!this._started) throw new Error('BrainOS not started');
+    if (isJson) {
+      await this._bus!.publishJson(topic, payload);
+    } else {
+      await this._bus!.publishText(topic, String(payload));
+    }
+  }
+
+  async publisher(topic: string): Promise<PublisherWrapper> {
+    if (!this._started) throw new Error('BrainOS not started');
+    const pub = await this._bus!.createPublisher(topic);
+    return new PublisherWrapper(pub);
+  }
+
+  async subscriber(topic: string): Promise<SubscriberWrapper> {
+    if (!this._started) throw new Error('BrainOS not started');
+    const sub = await this._bus!.createSubscriber(topic);
+    return new SubscriberWrapper(sub);
+  }
+
+  async query(topic: string): Promise<QueryClient> {
+    if (!this._started) throw new Error('BrainOS not started');
+    const q = await this._bus!.createQuery(topic);
+    return new QueryClient(q);
+  }
+
+  async queryable(topic: string, handler?: (input: string) => any): Promise<QueryableServer> {
+    if (!this._started) throw new Error('BrainOS not started');
+    const q = await this._bus!.createQueryable(topic);
+    if (handler) {
+      (q as any)._handler = handler;
+    }
+    return new QueryableServer(q, handler);
+  }
+
+  async caller(name: string): Promise<CallerClient> {
+    if (!this._started) throw new Error('BrainOS not started');
+    const c = await this._bus!.createCaller(name);
+    return new CallerClient(c);
+  }
+
+  async callable(uri: string, handler?: (input: string) => any): Promise<CallableServer> {
+    if (!this._started) throw new Error('BrainOS not started');
+    const c = await this._bus!.createCallable(uri);
+    return new CallableServer(c, handler);
+  }
+
+  get config(): any {
+    return this._config;
+  }
+
+  static async with(name: string = 'assistant', options: BrainOSOptions = {}): Promise<Agent> {
+    const brain = new BrainOS(options);
+    await brain.start();
+    const builder = brain.agent(name);
+    return await builder.start();
+  }
+}
+
+export class PublisherWrapper {
+  constructor(private _inner: jsbos.Publisher) {}
+
+  get topic(): string {
+    return this._inner.topic;
+  }
+
+  async publish(payload: any, isJson: boolean = false): Promise<void> {
+    if (isJson) {
+      await this._inner.publishJson(payload);
+    } else {
+      await this._inner.publishText(String(payload));
+    }
+  }
+
+  async text(payload: string): Promise<void> {
+    await this._inner.publishText(payload);
+  }
+
+  async json(data: any): Promise<void> {
+    await this._inner.publishJson(data);
+  }
+}
+
+export class SubscriberWrapper {
+  constructor(private _inner: jsbos.Subscriber) {}
+
+  get topic(): string {
+    return this._inner.topic;
+  }
+
+  async recv(timeoutMs?: number): Promise<string | null> {
+    if (timeoutMs) {
+      return await this._inner.recvWithTimeoutMs(timeoutMs);
+    }
+    return await this._inner.recv();
+  }
+
+  async recvJson(timeoutMs?: number): Promise<any | null> {
+    const msg = await this.recv(timeoutMs);
+    if (!msg) return null;
+    try {
+      return JSON.parse(msg);
+    } catch {
+      return msg;
+    }
+  }
+
+  async run(callback: (msg: string) => void): Promise<void> {
+    await this._inner.run((e, msg) => {
+      if (e) return;
+      callback(msg as string);
+    });
+  }
+
+  async runJson(callback: (data: any) => void): Promise<void> {
+    await this._inner.runJson((e, data) => {
+      if (e) return;
+      callback(data);
+    });
+  }
+
+  async stop(): Promise<void> {
+    await this._inner.stop();
+  }
+
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+
+  async next(): Promise<{ done: boolean; value?: string }> {
+    const msg = await this.recv();
+    return msg === null ? { done: true } : { done: false, value: msg };
+  }
+}
+
+export class QueryClient {
+  constructor(private _inner: jsbos.Query) {}
+
+  get topic(): string {
+    return this._inner.topic;
+  }
+
+  async ask(payload: string, timeoutMs?: number): Promise<string> {
+    if (timeoutMs) {
+      return await this._inner.queryTextTimeoutMs(payload, timeoutMs);
+    }
+    return await this._inner.queryText(payload);
+  }
+
+  async askJson(payload: any, timeoutMs?: number): Promise<any> {
+    const response = await this.ask(JSON.stringify(payload), timeoutMs);
+    try {
+      return JSON.parse(response);
+    } catch {
+      return response;
+    }
+  }
+}
+
+export class QueryableServer {
+  private _handler?: (input: string) => any;
+
+  constructor(private _inner: jsbos.Queryable, handler?: (input: string) => any) {
+    this._handler = handler;
+    if (handler) {
+      this._inner.setHandler((e, input) => {
+        if (e) throw e;
+        return handler(input);
+      });
+    }
+  }
+
+  handle(handler: (input: string) => any): this {
+    this._handler = handler;
+    this._inner.setHandler((e, input) => {
+      if (e) throw e;
+      return handler(input);
+    });
+    return this;
+  }
+
+  async start(): Promise<this> {
+    await this._inner.start();
+    return this;
+  }
+
+  async run(handler: (input: string) => any): Promise<void> {
+    this._inner.run((e, input) => {
+      if (e) throw e;
+      return handler(input);
+    });
+  }
+
+  async runJson(handler: (input: any) => any): Promise<void> {
+    this._inner.runJson((e, input) => {
+      if (e) throw e;
+      return handler(input);
+    });
+  }
+}
+
+export class CallerClient {
+  constructor(private _inner: jsbos.Caller) {}
+
+  async call(payload: string): Promise<string> {
+    return await this._inner.callText(payload);
+  }
+
+  async callJson(payload: any): Promise<any> {
+    const response = await this._inner.callText(JSON.stringify(payload));
+    try {
+      return JSON.parse(response);
+    } catch {
+      return response;
+    }
+  }
+}
+
+export class CallableServer {
+  private _handler?: (input: string) => any;
+
+  constructor(private _inner: jsbos.Callable, handler?: (input: string) => any) {
+    this._handler = handler;
+    if (handler) {
+      this._inner.setHandler((e, input) => {
+        if (e) throw e;
+        return handler(input);
+      });
+    }
+  }
+
+  handle(handler: (input: string) => any): this {
+    this._handler = handler;
+    this._inner.setHandler((e, input) => {
+      if (e) throw e;
+      return handler(input);
+    });
+    return this;
+  }
+
+  get isStarted(): boolean {
+    return this._inner.isStarted();
+  }
+
+  async start(): Promise<this> {
+    await this._inner.start();
+    return this;
+  }
+
+  async run(handler: (input: string) => any): Promise<void> {
+    this._inner.run((e, input) => {
+      if (e) throw e;
+      return handler(input);
+    });
+  }
+
+  async runJson(handler: (input: any) => any): Promise<void> {
+    this._inner.runJson((e, input) => {
+      if (e) throw e;
+      return handler(input);
+    });
+  }
+}

package/src/hook.ts

@@ -0,0 +1,73 @@
+import { HookEvent as JSHookEvent, HookContextData } from '@open1s/jsbos';
+
+export const HookEvent = {
+  BeforeToolCall: 0,
+  AfterToolCall: 1,
+  BeforeLlmCall: 2,
+  AfterLlmCall: 3,
+  OnMessage: 4,
+  OnComplete: 5,
+  OnError: 6,
+} as const;
+
+export type HookEvent = typeof HookEvent[keyof typeof HookEvent];
+export type { HookContextData } from '@open1s/jsbos';
+
+export const HookDecision = {
+  Continue: 'continue',
+  Abort: 'abort',
+} as const;
+
+export type HookDecision = 'continue' | 'abort';
+
+export type HookCallback = (ctx: HookContextData) => string | Promise<string>;
+
+const registeredHooks = new WeakMap<object, Map<HookEvent, HookCallback[]>>();
+
+export function hook(event: HookEvent) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const original = descriptor.value;
+    const hooks = registeredHooks.get(target) || new Map();
+    if (!hooks.has(event)) hooks.set(event, []);
+    hooks.get(event)!.push(async function(this: any, ctx: HookContextData) {
+      return await original.call(this, ctx);
+    });
+    registeredHooks.set(target, hooks);
+    return descriptor;
+  };
+}
+
+export function createHookRegistry(instance: object): Array<{ event: HookEvent, callback: HookCallback }> {
+  const hooks: Array<{ event: HookEvent, callback: HookCallback }> = [];
+  const proto = Object.getPrototypeOf(instance);
+  const map = registeredHooks.get(instance) || registeredHooks.get(proto);
+  if (map) {
+    for (const [event, callbacks] of map) {
+      for (const cb of callbacks) {
+        hooks.push({ event: event as HookEvent, callback: cb });
+      }
+    }
+  }
+  return hooks;
+}
+
+export function mergeHooks(...sources: any[]): Array<{ event: HookEvent, callback: HookCallback }> {
+  const result: Array<{ event: HookEvent, callback: HookCallback }> = [];
+  for (const source of sources) {
+    if (!source) continue;
+    if (typeof source === 'object' && 'callback' in source) {
+      result.push(source as { event: HookEvent, callback: HookCallback });
+    } else if (typeof source === 'object') {
+      const hooks = createHookRegistry(source);
+      result.push(...hooks);
+    } else if (typeof source === 'function') {
+      const hooks = createHookRegistry(source.prototype || source);
+      result.push(...hooks);
+    }
+  }
+  return result;
+}
+
+export function defineHook(event: HookEvent, callback: HookCallback): { event: HookEvent, callback: HookCallback } {
+  return { event, callback };
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+import * as jsbos from '@open1s/jsbos';
+
+export { jsbos };
+
+export * from './tool.js';
+export * from './hook.js';
+export * from './plugin.js';
+export * from './mcp.js';
+export * from './skills.js';
+export * from './agent.js';
+export * from './brainos.js';
+
+export const version = jsbos.version;
+export const initTracing = jsbos.initTracing;
+export const logTestMessage = jsbos.logTestMessage;
+export { McpClient } from '@open1s/jsbos';
+export { ConfigLoader } from '@open1s/jsbos';

package/src/mcp.ts

@@ -0,0 +1,40 @@
+export interface McpProcessConfig {
+  type: 'process';
+  namespace: string;
+  command: string;
+  args: string[];
+}
+
+export interface McpHttpConfig {
+  type: 'http';
+  namespace: string;
+  url: string;
+}
+
+export type McpConfig = McpProcessConfig | McpHttpConfig;
+
+export function defineMcpProcess(namespace: string, command: string, args: string[]): McpProcessConfig {
+  return { type: 'process', namespace, command, args };
+}
+
+export function defineMcpHttp(namespace: string, url: string): McpHttpConfig {
+  return { type: 'http', namespace, url };
+}
+
+export class McpBuilder {
+  private _configs: McpConfig[] = [];
+
+  process(namespace: string, command: string, args: string[]): this {
+    this._configs.push({ type: 'process', namespace, command, args });
+    return this;
+  }
+
+  http(namespace: string, url: string): this {
+    this._configs.push({ type: 'http', namespace, url });
+    return this;
+  }
+
+  build(): McpConfig[] {
+    return [...this._configs];
+  }
+}

package/src/plugin.ts

@@ -0,0 +1,93 @@
+import { jsbos } from './tool.js';
+
+export interface PluginHandlers {
+  name?: string;
+  on_llm_request?: (req: any) => any;
+  on_llm_response?: (resp: any) => any;
+  on_tool_call?: (call: any) => any;
+  on_tool_result?: (result: any) => any;
+}
+
+const registeredPlugins = new WeakMap<object, PluginHandlers>();
+
+export function plugin(name: string) {
+  return function <T extends { new (...args: any[]): {} }>(target: T) {
+    return class extends target {
+      __pluginName = name;
+      constructor(...args: any[]) {
+        super(...args);
+        const handlers: PluginHandlers = { name };
+        const proto = target.prototype;
+        for (const key of Object.getOwnPropertyNames(proto)) {
+          if (key === 'constructor') continue;
+          const method = (proto as any)[key];
+          if (typeof method === 'function') {
+            if (key === 'on_llm_request') handlers.on_llm_request = method.bind(this);
+            else if (key === 'on_llm_response') handlers.on_llm_response = method.bind(this);
+            else if (key === 'on_tool_call') handlers.on_tool_call = method.bind(this);
+            else if (key === 'on_tool_result') handlers.on_tool_result = method.bind(this);
+          }
+        }
+        registeredPlugins.set(this, handlers);
+      }
+    };
+  };
+}
+
+export function on_llm_request(_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
+  return descriptor;
+}
+
+export function on_llm_response(_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
+  return descriptor;
+}
+
+export function on_tool_call(_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
+  return descriptor;
+}
+
+export function on_tool_result(_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
+  return descriptor;
+}
+
+export function getPluginHandlers(instance: object): PluginHandlers {
+  const registered = registeredPlugins.get(instance);
+  if (registered) return registered;
+
+  const name = instance?.constructor?.name;
+  const handlers: PluginHandlers = { name };
+
+  const proto = Object.getPrototypeOf(instance);
+  for (const key of Object.getOwnPropertyNames(proto)) {
+    if (key === 'constructor') continue;
+    const method = (proto as any)[key];
+    if (typeof method === 'function') {
+      if (key === 'on_llm_request') handlers.on_llm_request = method.bind(instance);
+      else if (key === 'on_llm_response') handlers.on_llm_response = method.bind(instance);
+      else if (key === 'on_tool_call') handlers.on_tool_call = method.bind(instance);
+      else if (key === 'on_tool_result') handlers.on_tool_result = method.bind(instance);
+    }
+  }
+
+  return handlers;
+}
+
+export function mergePlugins(...sources: any[]): PluginHandlers[] {
+  const result: PluginHandlers[] = [];
+  for (const source of sources) {
+    if (!source) continue;
+    if (typeof source === 'object' && 'name' in source) {
+      result.push(source as PluginHandlers);
+    } else if (typeof source === 'function') {
+      const instance = new (source as any)();
+      result.push(getPluginHandlers(instance));
+    } else if (typeof source === 'object') {
+      result.push(getPluginHandlers(source));
+    }
+  }
+  return result;
+}
+
+export function definePlugin(handlers: PluginHandlers): PluginHandlers {
+  return handlers;
+}

package/src/skills.ts

@@ -0,0 +1,31 @@
+export interface SkillDef {
+  name: string;
+  content: string;
+}
+
+export interface SkillDir {
+  path: string;
+}
+
+export function defineSkill(name: string, content: string): SkillDef {
+  return { name, content };
+}
+
+export class SkillsBuilder {
+  private _dirs: string[] = [];
+  private _skills: SkillDef[] = [];
+
+  from_dir(path: string): this {
+    this._dirs.push(path);
+    return this;
+  }
+
+  add(name: string, content: string): this {
+    this._skills.push({ name, content });
+    return this;
+  }
+
+  build(): { dirs: string[], inline: SkillDef[] } {
+    return { dirs: this._dirs, inline: this._skills };
+  }
+}