@olane/o-test 0.7.12

package/LICENSE

@@ -0,0 +1,33 @@
+# Dual License: MIT OR Apache-2.0
+
+Copyright (c) 2025 Olane Inc.
+
+Olane OS is dual-licensed under your choice of either:
+
+- **MIT License** (LICENSE-MIT or https://opensource.org/licenses/MIT)
+- **Apache License, Version 2.0** (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
+
+## Why Dual Licensing?
+
+Dual licensing provides developers with flexibility when integrating Olane OS into their projects:
+
+- **Choose MIT**: If you prefer a simple, permissive license without patent provisions
+- **Choose Apache 2.0**: If you desire explicit patent protection and other features of the Apache license
+
+You may choose either license to govern your use of this software.
+
+## License Terms
+
+### MIT License
+The MIT license is very permissive and allows users to do almost anything with the software, including using, copying, modifying, merging, publishing, distributing, and selling it. The primary requirement is that the original copyright and license notice must be included in all copies of the software.
+
+See LICENSE-MIT for the full license text.
+
+### Apache License 2.0
+The Apache License 2.0 is also a permissive free software license. It grants users the right to use, modify, and distribute the software. It also includes provisions regarding patent grants, which are not present in the MIT license.
+
+See LICENSE-APACHE for the full license text.
+
+## Contributing
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you shall be dual-licensed as above, without any additional terms or conditions.

package/README.md

@@ -0,0 +1,400 @@
+# @olane/o-test
+
+> Testing utilities and best practices for O-Network node development
+
+## ⚠️ Important: We Use Mocha, Not Jest
+
+Since O-Network is built on the **libp2p ecosystem**, we use **aegir** with **Mocha** for testing (NOT Jest).
+
+- ✅ Use: `aegir`, `chai`, Mocha syntax (`before`, `after`, `.to.equal()`)
+- ❌ Don't use: `jest`, `@types/jest`, `ts-jest`
+
+See [MOCHA-MIGRATION.md](./MOCHA-MIGRATION.md) for migration guide.
+
+## Overview
+
+`@olane/o-test` provides comprehensive testing guidelines, utilities, and examples for building reliable O-Network nodes in the Olane OS ecosystem.
+
+## Quick Start
+
+### Installation
+
+```bash
+# From your package directory
+pnpm install --save-dev @olane/o-test
+
+# Install testing dependencies (aegir uses Mocha internally)
+pnpm install --save-dev aegir chai
+```
+
+**Important:** Since we're using the **libp2p ecosystem**, we use **aegir** as our test runner, which uses **Mocha** (not Jest). Do not install Jest dependencies.
+
+### Basic Test Structure
+
+```typescript
+import 'dotenv/config';
+import { describe, it, before, after } from 'mocha';
+import { expect } from 'chai';
+import { oLeaderNode } from '@olane/o-leader';
+import { MyTool } from '../src/my-tool.tool.js';
+
+describe('MyTool', () => {
+  let leaderNode: oLeaderNode;
+  let tool: MyTool;
+
+  before(async () => {
+    // Create leader
+    leaderNode = new oLeaderNode({
+      parent: null,
+      leader: null,
+    });
+    await leaderNode.start();
+
+    // Create tool
+    tool = new MyTool({
+      parent: leaderNode.address,
+      leader: leaderNode.address,
+    });
+
+    // Register with parent
+    (tool as any).hookInitializeFinished = () => {
+      leaderNode.addChildNode(tool);
+    };
+
+    await tool.start();
+  });
+
+  after(async () => {
+    await tool.stop();
+    await leaderNode.stop();
+  });
+
+  it('should start successfully', () => {
+    expect(tool.state).to.equal(NodeState.RUNNING);
+  });
+
+  it('should execute method', async () => {
+    const result = await tool.useSelf({
+      method: 'my_method',
+      params: { test: 'value' },
+    });
+
+    expect(result.success).to.be.true;
+    expect(result.result.data).to.exist;
+  });
+});
+```
+
+## Documentation
+
+### 📚 [Complete Testing Guide](./TESTING.md)
+
+Comprehensive guide covering:
+- Testing philosophy and baseline requirements
+- Testing stack and configuration
+- Lifecycle, method, and parent-child testing patterns
+- Error handling and validation tests
+- Test helpers and utilities
+- CI/CD integration
+- Common pitfalls and troubleshooting
+
+### 🔄 [Jest to Mocha Migration Guide](./MOCHA-MIGRATION.md)
+
+Quick reference for converting tests from Jest to Mocha:
+- Side-by-side syntax comparison
+- Complete code examples
+- Common pitfalls and solutions
+- Quick reference table
+
+## Baseline Requirements
+
+Every O-Network package **must** have:
+
+| Requirement | File/Location |
+|-------------|---------------|
+| Test directory | `/test/` |
+| Lifecycle test | `test/lifecycle.spec.ts` |
+| Method tests | `test/methods.spec.ts` |
+| Aegir config | `.aegir.js` (optional) |
+| Test script | `"test": "aegir test"` in package.json |
+
+**Note:** No Jest configuration needed - aegir uses Mocha internally for the libp2p ecosystem.
+
+## Minimum Test Coverage
+
+-  All nodes must have lifecycle tests (start/stop)
+-  All public methods (`_tool_*`) must have happy path tests
+-  All required parameters must have validation tests
+-  Parent-child patterns must test registration and routing
+-  Critical error paths must be tested
+
+## Running Tests
+
+```bash
+# Run all tests
+pnpm test
+
+# Run in watch mode
+pnpm test:watch
+
+# Run specific test file
+pnpm test test/lifecycle.spec.ts
+
+# Run with coverage
+pnpm test -- --coverage
+```
+
+## Configuration Files
+
+### `.aegir.js` (Optional)
+
+Aegir works out of the box with sensible defaults. Configuration is only needed for customization:
+
+```javascript
+export default {
+  test: {
+    target: ['node'],  // or ['browser'], or ['node', 'browser']
+  },
+  build: {
+    bundlesizeMax: '100KB',
+  },
+};
+```
+
+**Important for libp2p ecosystem:**
+- ✅ Aegir uses **Mocha** as the test runner (not Jest)
+- ✅ Use Mocha syntax: `before`, `after`, `beforeEach`, `afterEach`
+- ✅ Use Chai assertions: `expect().to.equal()`, `expect().to.exist`, etc.
+- ❌ Do NOT install or use `jest`, `@types/jest`, or `ts-jest`
+
+## Critical Testing Rules
+
+###  DO:
+
+- Load environment with `import 'dotenv/config'`
+- Use `.js` extensions in imports (ESM requirement)
+- Create leader node before child nodes
+- Inject `hookInitializeFinished` for parent-child registration
+- Clean up all nodes in `afterEach`
+- Access response data via `result.result.data`
+- Test both success and error paths
+
+### L DON'T:
+
+- Override `start()` method (use hooks instead)
+- Forget to call `stop()` on nodes
+- Access `result.data` directly (use `result.result.data`)
+- Use mocks for node instances (use real nodes)
+- Share mutable state between tests
+
+## Testing Philosophy
+
+We prioritize **practical, integration-oriented tests** that validate real node behavior:
+
+-  Real node instances over mocks
+-  Actual lifecycle management
+-  Parent-child relationships
+-  Simple, focused test cases
+-  Integration over unit isolation
+
+## Test Patterns
+
+### Lifecycle Testing
+
+```typescript
+it('should start and stop successfully', async () => {
+  const node = new MyTool({
+    parent: null,
+    leader: null,
+  });
+
+  await node.start();
+  expect(node.state).to.equal(NodeState.RUNNING);
+
+  await node.stop();
+  expect(node.state).to.equal(NodeState.STOPPED);
+});
+```
+
+### Method Testing
+
+```typescript
+it('should validate required parameters', async () => {
+  const result = await tool.useSelf({
+    method: 'my_method',
+    params: {}, // Missing required params
+  });
+
+  expect(result.success).to.be.false;
+  expect(result.error).to.include('required');
+});
+```
+
+### Parent-Child Testing
+
+```typescript
+it('should create and route to child', async () => {
+  // Create child
+  const createResult = await manager.useSelf({
+    method: 'create_worker',
+    params: { workerId: 'worker-1' },
+  });
+  expect(createResult.success).to.be.true;
+
+  // Route to child
+  const routeResult = await manager.useSelf({
+    method: 'use_worker',
+    params: {
+      workerId: 'worker-1',
+      method: 'process_task',
+      params: { data: 'test' },
+    },
+  });
+  expect(routeResult.success).to.be.true;
+});
+```
+
+## Common Pitfalls
+
+### Pitfall 1: Missing Hook Injection
+
+```typescript
+// L WRONG
+const tool = new MyTool({ parent: leader.address, leader: leader.address });
+await tool.start(); // Child not registered!
+
+//  CORRECT
+const tool = new MyTool({ parent: leader.address, leader: leader.address });
+(tool as any).hookInitializeFinished = () => {
+  leaderNode.addChildNode(tool);
+};
+await tool.start();
+```
+
+### Pitfall 2: No Cleanup
+
+```typescript
+// L WRONG
+it('test', async () => {
+  const tool = new MyTool({});
+  await tool.start();
+  // No cleanup - nodes leak!
+});
+
+//  CORRECT
+afterEach(async () => {
+  if (tool) await tool.stop();
+  if (leader) await leader.stop();
+});
+```
+
+### Pitfall 3: Wrong Response Access
+
+```typescript
+// L WRONG
+const data = result.data; // undefined!
+
+//  CORRECT
+const data = result.result.data;
+```
+
+## Test Helpers
+
+Create shared utilities for common patterns:
+
+```typescript
+// test/helpers/test-utils.ts
+export async function createToolWithLeader<T>(
+  ToolClass: new (config: any) => T,
+  config: any = {}
+): Promise<{ leader: oLeaderNode; tool: T }> {
+  const leader = new oLeaderNode({ parent: null, leader: null });
+  await leader.start();
+
+  const tool = new ToolClass({
+    ...config,
+    parent: leader.address,
+    leader: leader.address,
+  });
+
+  (tool as any).hookInitializeFinished = () => {
+    leader.addChildNode(tool as any);
+  };
+
+  await (tool as any).start();
+
+  return { leader, tool };
+}
+```
+
+## Example Tests
+
+See the `test/` directory for complete examples:
+
+- `test/lifecycle.spec.ts` - Node lifecycle testing
+- `test/methods.spec.ts` - Method validation and execution
+- `test/parent-child.spec.ts` - Manager/worker pattern testing
+- `test/helpers/` - Shared test utilities
+
+## Resources
+
+- [TESTING.md](./TESTING.md) - Complete testing guide
+- [CLAUDE.md](./CLAUDE.md) - O-Network node development guide
+- [Olane Documentation](https://docs.olane.ai) - Full ecosystem docs
+
+## Package Structure
+
+```
+o-test/
+ src/
+    index.ts                  # Public exports
+    example-tool.tool.ts      # Example tool implementation
+    methods/
+        example.methods.ts    # Method definitions
+ test/
+    lifecycle.spec.ts         # Lifecycle tests
+    methods.spec.ts           # Method tests
+    parent-child.spec.ts      # Parent-child tests
+    helpers/
+       test-utils.ts         # Test utilities
+    fixtures/
+        mock-data.ts          # Test data
+ jest.config.js                # Jest configuration
+ .aegir.js                     # Aegir configuration
+ tsconfig.json                 # TypeScript configuration
+ package.json                  # Package metadata
+ README.md                     # This file
+ TESTING.md                    # Complete testing guide
+ CLAUDE.md                     # Development guide
+```
+
+## Contributing
+
+When adding tests:
+
+1. Follow the patterns in [TESTING.md](./TESTING.md)
+2. Ensure all baseline requirements are met
+3. Test both success and error paths
+4. Clean up all resources
+5. Use descriptive test names
+
+## License
+
+See the root LICENSE file in the Olane monorepo.
+
+## Support
+
+- GitHub Issues: [olane/issues](https://github.com/olane-labs/olane/issues)
+- Documentation: [docs.olane.ai](https://docs.olane.ai)
+- Community: [Discord](https://discord.gg/olane)
+
+---
+
+**Remember:**
+-  Real nodes, not mocks
+-  Proper lifecycle management
+-  Clean up in `afterEach`
+-  Test integration, not isolation
+-  Keep it simple
+
+For detailed testing patterns and examples, see [TESTING.md](./TESTING.md).

package/dist/src/builders/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Test builders - Fluent APIs for common test scenarios
+ */
+export { SimpleNodeBuilder } from './simple-node-builder.js';
+export { LeaderChildBuilder, type LeaderConfig } from './leader-child-builder.js';
+export { ManagerWorkerBuilder, type ManagerWorkerResult } from './manager-worker-builder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/builders/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/builders/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAClF,OAAO,EAAE,oBAAoB,EAAE,KAAK,mBAAmB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/src/builders/index.js

@@ -0,0 +1,6 @@
+/**
+ * Test builders - Fluent APIs for common test scenarios
+ */
+export { SimpleNodeBuilder } from './simple-node-builder.js';
+export { LeaderChildBuilder } from './leader-child-builder.js';
+export { ManagerWorkerBuilder } from './manager-worker-builder.js';

package/dist/src/builders/leader-child-builder.d.ts

@@ -0,0 +1,50 @@
+/**
+ * LeaderChildBuilder - Fluent API for creating leader-child hierarchies
+ *
+ * @example
+ * ```typescript
+ * const { leader, tool } = await new LeaderChildBuilder(MyTool)
+ *   .withToolConfig({ apiKey: 'test' })
+ *   .withLeaderAddress('o://test-leader')
+ *   .build(env);
+ * ```
+ */
+import type { oNode, oNodeAddress } from '@olane/o-node';
+import type { TestEnvironment, TestNodeConfig, ToolWithLeaderResult } from '../test-environment.js';
+export interface LeaderConfig {
+    address?: oNodeAddress;
+    description?: string;
+    autoStart?: boolean;
+}
+export declare class LeaderChildBuilder<T extends oNode = any> {
+    private toolClass;
+    private toolConfig;
+    private leaderClass?;
+    private leaderConfig;
+    constructor(ToolClass: new (config: any) => T);
+    /**
+     * Set tool configuration
+     */
+    withToolConfig(config: TestNodeConfig): this;
+    /**
+     * Set leader class (optional, defaults to oLeaderNode)
+     */
+    withLeaderClass(LeaderClass: new (config: any) => any): this;
+    /**
+     * Set leader configuration
+     */
+    withLeaderConfig(config: LeaderConfig): this;
+    /**
+     * Set leader address
+     */
+    withLeaderAddress(address: string | oNodeAddress): this;
+    /**
+     * Set leader description
+     */
+    withLeaderDescription(description: string): this;
+    /**
+     * Build and create the leader-child hierarchy
+     */
+    build(env: TestEnvironment): Promise<ToolWithLeaderResult<T>>;
+}
+//# sourceMappingURL=leader-child-builder.d.ts.map

package/dist/src/builders/leader-child-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leader-child-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/leader-child-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEpG,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,kBAAkB,CAAC,CAAC,SAAS,KAAK,GAAG,GAAG;IACnD,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,WAAW,CAAC,CAA2B;IAC/C,OAAO,CAAC,YAAY,CAAoB;gBAE5B,SAAS,EAAE,KAAK,MAAM,EAAE,GAAG,KAAK,CAAC;IAI7C;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAK5C;;OAEG;IACH,eAAe,CAAC,WAAW,EAAE,KAAK,MAAM,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAK5D;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAK5C;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAKvD;;OAEG;IACH,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKhD;;OAEG;IACG,KAAK,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;CAOpE"}

package/dist/src/builders/leader-child-builder.js

@@ -0,0 +1,59 @@
+/**
+ * LeaderChildBuilder - Fluent API for creating leader-child hierarchies
+ *
+ * @example
+ * ```typescript
+ * const { leader, tool } = await new LeaderChildBuilder(MyTool)
+ *   .withToolConfig({ apiKey: 'test' })
+ *   .withLeaderAddress('o://test-leader')
+ *   .build(env);
+ * ```
+ */
+export class LeaderChildBuilder {
+    constructor(ToolClass) {
+        this.toolConfig = {};
+        this.leaderConfig = {};
+        this.toolClass = ToolClass;
+    }
+    /**
+     * Set tool configuration
+     */
+    withToolConfig(config) {
+        this.toolConfig = { ...this.toolConfig, ...config };
+        return this;
+    }
+    /**
+     * Set leader class (optional, defaults to oLeaderNode)
+     */
+    withLeaderClass(LeaderClass) {
+        this.leaderClass = LeaderClass;
+        return this;
+    }
+    /**
+     * Set leader configuration
+     */
+    withLeaderConfig(config) {
+        this.leaderConfig = { ...this.leaderConfig, ...config };
+        return this;
+    }
+    /**
+     * Set leader address
+     */
+    withLeaderAddress(address) {
+        this.leaderConfig.address = address;
+        return this;
+    }
+    /**
+     * Set leader description
+     */
+    withLeaderDescription(description) {
+        this.leaderConfig.description = description;
+        return this;
+    }
+    /**
+     * Build and create the leader-child hierarchy
+     */
+    async build(env) {
+        return await env.createToolWithLeader(this.toolClass, this.toolConfig, this.leaderClass);
+    }
+}

package/dist/src/builders/manager-worker-builder.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ManagerWorkerBuilder - Fluent API for manager-worker pattern tests
+ *
+ * @example
+ * ```typescript
+ * const { leader, manager, workers } = await new ManagerWorkerBuilder(MyManager, MyWorker)
+ *   .withManagerConfig({ maxInstances: 5 })
+ *   .withWorkerCount(3)
+ *   .withWorkerConfig({ timeout: 5000 })
+ *   .build(env);
+ * ```
+ */
+import type { oNode } from '@olane/o-node';
+import type { TestEnvironment, TestNodeConfig } from '../test-environment.js';
+export interface ManagerWorkerResult<M = any, W = any> {
+    leader: any;
+    manager: M;
+    workers: W[];
+}
+export declare class ManagerWorkerBuilder<M extends oNode = any, W extends oNode = any> {
+    private managerClass;
+    private workerClass?;
+    private managerConfig;
+    private workerConfig;
+    private workerCount;
+    private leaderClass?;
+    constructor(ManagerClass: new (config: any) => M, WorkerClass?: new (config: any) => W);
+    /**
+     * Set manager configuration
+     */
+    withManagerConfig(config: TestNodeConfig): this;
+    /**
+     * Set worker configuration
+     */
+    withWorkerConfig(config: TestNodeConfig): this;
+    /**
+     * Set number of workers to create
+     */
+    withWorkerCount(count: number): this;
+    /**
+     * Set leader class
+     */
+    withLeaderClass(LeaderClass: new (config: any) => any): this;
+    /**
+     * Build and create the manager-worker hierarchy
+     */
+    build(env: TestEnvironment): Promise<ManagerWorkerResult<M, W>>;
+}
+//# sourceMappingURL=manager-worker-builder.d.ts.map

package/dist/src/builders/manager-worker-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager-worker-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/manager-worker-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE9E,MAAM,WAAW,mBAAmB,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG;IACnD,MAAM,EAAE,GAAG,CAAC;IACZ,OAAO,EAAE,CAAC,CAAC;IACX,OAAO,EAAE,CAAC,EAAE,CAAC;CACd;AAED,qBAAa,oBAAoB,CAAC,CAAC,SAAS,KAAK,GAAG,GAAG,EAAE,CAAC,SAAS,KAAK,GAAG,GAAG;IAC5E,OAAO,CAAC,YAAY,CAAyB;IAC7C,OAAO,CAAC,WAAW,CAAC,CAAyB;IAC7C,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,WAAW,CAAC,CAA2B;gBAG7C,YAAY,EAAE,KAAK,MAAM,EAAE,GAAG,KAAK,CAAC,EACpC,WAAW,CAAC,EAAE,KAAK,MAAM,EAAE,GAAG,KAAK,CAAC;IAMtC;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAK/C;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAK9C;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKpC;;OAEG;IACH,eAAe,CAAC,WAAW,EAAE,KAAK,MAAM,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAK5D;;OAEG;IACG,KAAK,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAiCtE"}

package/dist/src/builders/manager-worker-builder.js

@@ -0,0 +1,79 @@
+/**
+ * ManagerWorkerBuilder - Fluent API for manager-worker pattern tests
+ *
+ * @example
+ * ```typescript
+ * const { leader, manager, workers } = await new ManagerWorkerBuilder(MyManager, MyWorker)
+ *   .withManagerConfig({ maxInstances: 5 })
+ *   .withWorkerCount(3)
+ *   .withWorkerConfig({ timeout: 5000 })
+ *   .build(env);
+ * ```
+ */
+export class ManagerWorkerBuilder {
+    constructor(ManagerClass, WorkerClass) {
+        this.managerConfig = {};
+        this.workerConfig = {};
+        this.workerCount = 0;
+        this.managerClass = ManagerClass;
+        this.workerClass = WorkerClass;
+    }
+    /**
+     * Set manager configuration
+     */
+    withManagerConfig(config) {
+        this.managerConfig = { ...this.managerConfig, ...config };
+        return this;
+    }
+    /**
+     * Set worker configuration
+     */
+    withWorkerConfig(config) {
+        this.workerConfig = { ...this.workerConfig, ...config };
+        return this;
+    }
+    /**
+     * Set number of workers to create
+     */
+    withWorkerCount(count) {
+        this.workerCount = count;
+        return this;
+    }
+    /**
+     * Set leader class
+     */
+    withLeaderClass(LeaderClass) {
+        this.leaderClass = LeaderClass;
+        return this;
+    }
+    /**
+     * Build and create the manager-worker hierarchy
+     */
+    async build(env) {
+        // Create leader and manager
+        const { leader, tool: manager } = await env.createToolWithLeader(this.managerClass, this.managerConfig, this.leaderClass);
+        const workers = [];
+        // Create workers if count specified and worker class provided
+        if (this.workerCount > 0 && this.workerClass) {
+            for (let i = 0; i < this.workerCount; i++) {
+                // Use manager's create_worker method if available
+                const createMethod = 'create_worker';
+                if (typeof manager.useSelf === 'function') {
+                    try {
+                        await manager.useSelf({
+                            method: createMethod,
+                            params: {
+                                workerId: `worker-${i}`,
+                                config: this.workerConfig,
+                            },
+                        });
+                    }
+                    catch (error) {
+                        console.warn(`Could not create worker ${i} via manager method:`, error);
+                    }
+                }
+            }
+        }
+        return { leader, manager, workers };
+    }
+}