@open1s/ezbos 1.0.2 → 1.0.4

package/dist/tool.d.ts

@@ -0,0 +1,34 @@
+import * as jsbos from '@open1s/jsbos';
+export interface ToolResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+export declare function ok(data: any, metadata?: Record<string, any>): ToolResult;
+export declare function err(error: string, metadata?: Record<string, any>): ToolResult;
+export declare function isErrorResult(result: any): result is ToolResult;
+export interface ToolParam {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+    default?: any;
+}
+export interface InternalToolDef {
+    name: string;
+    description: string;
+    schema: Record<string, any>;
+    callback: (args: Record<string, any>) => string | Promise<string>;
+}
+export { jsbos };
+export declare class ToolBuilder {
+    private _name;
+    private _description;
+    private _params;
+    private _required;
+    constructor(_name: string, _description: string);
+    param(name: string, type: ToolParam['type'], description?: string, defaultValue?: any): this;
+    required(name: string, type: ToolParam['type'], description?: string): this;
+    handle(callback: (args: Record<string, any>) => any): InternalToolDef;
+}
+export declare function defineTool(name: string, description: string): ToolBuilder;
+export declare function tool(name: string, description: string, callback: (args: any) => any): InternalToolDef;

package/dist/tool.js

@@ -0,0 +1,81 @@
+import * as jsbos from '@open1s/jsbos';
+export function ok(data, metadata) {
+    return { success: true, data, metadata };
+}
+export function err(error, metadata) {
+    return { success: false, error, metadata };
+}
+export function isErrorResult(result) {
+    return result && typeof result.success === 'boolean' && !result.success;
+}
+export { jsbos };
+export class ToolBuilder {
+    _name;
+    _description;
+    _params = {};
+    _required = [];
+    constructor(_name, _description) {
+        this._name = _name;
+        this._description = _description;
+    }
+    param(name, type, description, defaultValue) {
+        this._params[name] = { type, description, default: defaultValue };
+        return this;
+    }
+    required(name, type, description) {
+        this._params[name] = { type, description };
+        this._required.push(name);
+        return this;
+    }
+    handle(callback) {
+        const isAsync = callback.constructor.name === 'AsyncFunction' ||
+            callback.toString().startsWith('async ');
+        if (isAsync) {
+            throw new Error(`Tool "${this._name}" uses an async callback, but jsbos does not support async tool callbacks. Please use a synchronous callback instead.`);
+        }
+        const properties = {};
+        for (const [key, spec] of Object.entries(this._params)) {
+            properties[key] = { type: spec.type };
+            if (spec.description)
+                properties[key].description = spec.description;
+            if (spec.default !== undefined)
+                properties[key].default = spec.default;
+        }
+        const schema = {
+            type: 'object',
+            properties,
+            required: this._required.length > 0 ? this._required : Object.keys(this._params)
+        };
+        const wrappedCallback = (rawArgs) => {
+            try {
+                const args = typeof rawArgs === 'string' ? JSON.parse(rawArgs) : rawArgs;
+                const result = callback(args);
+                if (result instanceof Promise) {
+                    throw new Error('Async tool callbacks are not supported. Use a sync callback instead.');
+                }
+                if (isErrorResult(result))
+                    return 'Error: ' + (result.error || 'Unknown error');
+                if (result === undefined)
+                    return '';
+                if (typeof result === 'string')
+                    return result;
+                return JSON.stringify(result);
+            }
+            catch (e) {
+                return 'Error: ' + (e.message || String(e));
+            }
+        };
+        return {
+            name: this._name,
+            description: this._description,
+            schema,
+            callback: wrappedCallback
+        };
+    }
+}
+export function defineTool(name, description) {
+    return new ToolBuilder(name, description);
+}
+export function tool(name, description, callback) {
+    return new ToolBuilder(name, description).handle(callback);
+}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+import { HookEvent, HookDecision, PluginToolCallInfo } from '@open1s/jsbos';
+export { HookEvent, HookDecision };
+export type { PluginToolCallInfo };
+export interface ToolParamSchema {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+    default?: any;
+    required?: boolean;
+}
+export interface ToolResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+export declare function ok(data: any, metadata?: Record<string, any>): ToolResult;
+export declare function err(error: string, metadata?: Record<string, any>): ToolResult;
+export declare function isErrorResult(result: any): result is ToolResult;

package/dist/types.js

@@ -0,0 +1,9 @@
+export function ok(data, metadata) {
+    return { success: true, data, metadata };
+}
+export function err(error, metadata) {
+    return { success: false, error, metadata };
+}
+export function isErrorResult(result) {
+    return result && typeof result.success === 'boolean' && !result.success;
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@open1s/ezbos",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Simple BrainOS - Easy wrapper for @open1s/jsbos",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": ["dist", "src"],
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -34,7 +35,7 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@open1s/jsbos": "^2.2.0"
+    "@open1s/jsbos": "^2.2.1"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",

package/.github/workflows/ci.yml

@@ -1,34 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [20, 22]
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build
-        run: npm run build
-
-      - name: Verify dist
-        run: |
-          test -f dist/index.js
-          test -f dist/index.d.ts

package/.github/workflows/publish.yml

@@ -1,33 +0,0 @@
-name: Publish
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Use Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build
-        run: npm run build
-
-      - name: Publish to npm
-        run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}