network-ai 3.0.3 → 3.1.2

package/dist/index.js

@@ -6,11 +6,11 @@
  * task decomposition, permission management, and shared blackboard coordination.
  *
  * @module SwarmOrchestrator
- * @version 3.0.0
+ * @version 3.1.0
  * @license MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomAdapter = exports.MCPAdapter = exports.CrewAIAdapter = exports.AutoGenAdapter = exports.LangChainAdapter = exports.OpenClawAdapter = exports.BaseAdapter = exports.AdapterRegistry = exports.QualityGateAgent = exports.BlackboardValidator = exports.TaskDecomposer = exports.AuthGuardian = exports.SharedBlackboard = exports.SwarmOrchestrator = void 0;
+exports.TimeoutError = exports.ParallelLimitError = exports.AdapterNotInitializedError = exports.AdapterNotFoundError = exports.AdapterAlreadyRegisteredError = exports.ConflictError = exports.LockAcquisitionError = exports.ValidationError = exports.NamespaceViolationError = exports.IdentityVerificationError = exports.NetworkAIError = exports.LogLevel = exports.Logger = exports.CustomAdapter = exports.MCPAdapter = exports.CrewAIAdapter = exports.AutoGenAdapter = exports.LangChainAdapter = exports.OpenClawAdapter = exports.BaseAdapter = exports.AdapterRegistry = exports.QualityGateAgent = exports.BlackboardValidator = exports.TaskDecomposer = exports.AuthGuardian = exports.SharedBlackboard = exports.SwarmOrchestrator = void 0;
 exports.createSwarmOrchestrator = createSwarmOrchestrator;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -19,6 +19,9 @@ const adapter_registry_1 = require("./adapters/adapter-registry");
 const security_1 = require("./security");
 const locked_blackboard_1 = require("./lib/locked-blackboard");
 const blackboard_validator_1 = require("./lib/blackboard-validator");
+const logger_1 = require("./lib/logger");
+const errors_1 = require("./lib/errors");
+const log = logger_1.Logger.create('SwarmOrchestrator');
 // ============================================================================
 // CONFIGURATION
 // ============================================================================
@@ -71,11 +74,29 @@ const DEFAULT_AGENT_TRUST = [
 // BLACKBOARD MANAGEMENT -- Secured with LockedBlackboard, identity verification,
 // namespace scoping, value validation, and input sanitization
 // ============================================================================
+/**
+ * Namespace-scoped, identity-verified shared state for multi-agent coordination.
+ *
+ * Every write is identity-verified (agent token), namespace-checked,
+ * size-validated, input-sanitized, and atomically persisted through
+ * {@link LockedBlackboard}.
+ *
+ * @example
+ * ```typescript
+ * const bb = new SharedBlackboard('./workspace');
+ * bb.registerAgent('analyst', 'secret-token', ['task:', 'analytics:']);
+ * bb.write('task:revenue', { q4: 42_000 }, 'analyst', 3600, 'secret-token');
+ * const entry = bb.read('task:revenue');
+ * ```
+ */
 class SharedBlackboard {
     backend;
     agentTokens = new Map(); // agentId -> verified token
     agentNamespaces = new Map(); // agentId -> allowed prefixes
     constructor(basePath) {
+        if (!basePath || typeof basePath !== 'string' || basePath.trim() === '') {
+            throw new errors_1.ValidationError('basePath must be a non-empty string');
+        }
         this.backend = new locked_blackboard_1.LockedBlackboard(basePath);
     }
     /**
@@ -84,6 +105,15 @@ class SharedBlackboard {
      * verifying their identity through the AuthGuardian.
      */
     registerAgent(agentId, verificationToken, allowedNamespaces = ['*']) {
+        if (!agentId || typeof agentId !== 'string' || agentId.trim() === '') {
+            throw new errors_1.ValidationError('agentId must be a non-empty string');
+        }
+        if (!verificationToken || typeof verificationToken !== 'string') {
+            throw new errors_1.ValidationError('verificationToken must be a non-empty string');
+        }
+        if (!Array.isArray(allowedNamespaces)) {
+            throw new errors_1.ValidationError('allowedNamespaces must be an array of strings');
+        }
         this.agentTokens.set(agentId, verificationToken);
         this.agentNamespaces.set(agentId, allowedNamespaces);
     }
@@ -131,7 +161,17 @@ class SharedBlackboard {
         // Keys must be safe for markdown headings -- no #, newlines, or markdown syntax
         return key.replace(/[#\n\r|`]/g, '_').slice(0, 256);
     }
+    /**
+     * Read an entry from the blackboard by key.
+     *
+     * @param key - The entry key to look up
+     * @returns The entry, or `null` if not found or expired
+     * @throws {@link ValidationError} if `key` is not a non-empty string
+     */
     read(key) {
+        if (!key || typeof key !== 'string') {
+            throw new errors_1.ValidationError('key must be a non-empty string');
+        }
         const entry = this.backend.read(key);
         if (!entry)
             return null;
@@ -158,18 +198,18 @@ class SharedBlackboard {
     write(key, value, sourceAgent, ttl, agentToken) {
         // 1. Verify agent identity
         if (!this.verifyAgent(sourceAgent, agentToken)) {
-            throw new Error(`[Blackboard] Identity verification failed for agent '${sourceAgent}'`);
+            throw new errors_1.IdentityVerificationError(sourceAgent);
         }
         // 2. Namespace check
         if (!this.canAccessKey(sourceAgent, key)) {
-            throw new Error(`[Blackboard] Agent '${sourceAgent}' not allowed to write to key '${key}'`);
+            throw new errors_1.NamespaceViolationError(sourceAgent, key);
         }
         // 3. Sanitize key
         const safeKey = this.sanitizeKey(key);
         // 4. Validate value size/structure
         const validation = this.validateValue(value);
         if (!validation.valid) {
-            throw new Error(`[Blackboard] Value validation failed: ${validation.reason}`);
+            throw new errors_1.ValidationError(validation.reason);
         }
         // 5. Sanitize value -- strip injection payloads from string content
         let sanitizedValue;
@@ -190,6 +230,10 @@ class SharedBlackboard {
             ttl: entry.ttl,
         };
     }
+    /**
+     * Check whether a key exists on the blackboard (not expired).
+     * @param key - The entry key to check
+     */
     exists(key) {
         return this.read(key) !== null;
     }
@@ -215,6 +259,9 @@ class SharedBlackboard {
      * Prevents data leakage between agents.
      */
     getScopedSnapshot(agentId) {
+        if (!agentId || typeof agentId !== 'string') {
+            throw new errors_1.ValidationError('agentId must be a non-empty string');
+        }
         const full = this.getSnapshot();
         const scoped = {};
         for (const [key, entry] of Object.entries(full)) {
@@ -243,6 +290,29 @@ exports.SharedBlackboard = SharedBlackboard;
 // Integrates with SecureSwarmGateway for HMAC tokens, rate limiting, 
 // input sanitization, and cryptographic audit logs.
 // ============================================================================
+/**
+ * Universal permission wall for multi-agent systems.
+ *
+ * Evaluates permission requests using a weighted formula of justification
+ * quality (40%), agent trust level (30%), and risk score (30%).
+ * Resource types, risk profiles, trust levels, and restrictions are all
+ * configurable — works for coding, finance, DevOps, or any domain.
+ *
+ * @example
+ * ```typescript
+ * const guardian = new AuthGuardian({
+ *   trustLevels: [{ agentId: 'analyst', trustLevel: 0.8 }],
+ *   resourceProfiles: { CUSTOM_API: { baseRisk: 0.5, defaultRestrictions: ['audit_required'] } },
+ * });
+ *
+ * const grant = await guardian.requestPermission(
+ *   'analyst', 'CUSTOM_API', 'Need to fetch Q4 revenue data for report', 'read'
+ * );
+ * if (grant.granted) {
+ *   // Use grant.grantToken to prove authorization
+ * }
+ * ```
+ */
 class AuthGuardian {
     activeGrants = new Map();
     agentTrustLevels = new Map();
@@ -273,12 +343,33 @@ class AuthGuardian {
      * Makes the system extensible for any domain.
      */
     registerResourceType(name, profile) {
+        if (!name || typeof name !== 'string' || name.trim() === '') {
+            throw new errors_1.ValidationError('resource name must be a non-empty string');
+        }
+        if (!profile || typeof profile !== 'object' || typeof profile.baseRisk !== 'number') {
+            throw new errors_1.ValidationError('profile must be an object with a numeric baseRisk');
+        }
+        if (profile.baseRisk < 0 || profile.baseRisk > 1) {
+            throw new errors_1.ValidationError('profile.baseRisk must be between 0 and 1');
+        }
+        if (!Array.isArray(profile.defaultRestrictions)) {
+            throw new errors_1.ValidationError('profile.defaultRestrictions must be an array');
+        }
         this.resourceProfiles.set(name, profile);
     }
     /**
      * Register or update an agent's trust configuration at runtime.
      */
     registerAgentTrust(config) {
+        if (!config || typeof config !== 'object') {
+            throw new errors_1.ValidationError('config must be an object');
+        }
+        if (!config.agentId || typeof config.agentId !== 'string' || config.agentId.trim() === '') {
+            throw new errors_1.ValidationError('config.agentId must be a non-empty string');
+        }
+        if (typeof config.trustLevel !== 'number' || config.trustLevel < 0 || config.trustLevel > 1) {
+            throw new errors_1.ValidationError('config.trustLevel must be a number between 0 and 1');
+        }
         this.agentTrustLevels.set(config.agentId, config.trustLevel);
         this.agentTrustConfigs.set(config.agentId, config);
         this.persistTrustToDisk();
@@ -288,6 +379,15 @@ class AuthGuardian {
      * resourceType is now a free string -- validated against registered profiles.
      */
     async requestPermission(agentId, resourceType, justification, scope) {
+        if (!agentId || typeof agentId !== 'string') {
+            throw new errors_1.ValidationError('agentId must be a non-empty string');
+        }
+        if (!resourceType || typeof resourceType !== 'string') {
+            throw new errors_1.ValidationError('resourceType must be a non-empty string');
+        }
+        if (!justification || typeof justification !== 'string') {
+            throw new errors_1.ValidationError('justification must be a non-empty string');
+        }
         // Sanitize inputs
         let safeAgentId;
         let safeJustification;
@@ -346,7 +446,15 @@ class AuthGuardian {
             restrictions: evaluation.restrictions,
         };
     }
+    /**
+     * Validate a grant token and return `true` if it is active and not expired.
+     *
+     * @param token - The grant token to validate
+     * @returns `true` if the token is valid, `false` otherwise
+     */
     validateToken(token) {
+        if (!token || typeof token !== 'string')
+            return false;
         const grant = this.activeGrants.get(token);
         if (!grant)
             return false;
@@ -360,7 +468,16 @@ class AuthGuardian {
      * Validate a token and return the bound restrictions and scope.
      * Used to enforce restrictions at the point of use.
      */
+    /**
+     * Validate a token and return the full grant object (including restrictions
+     * and scope) for point-of-use enforcement.
+     *
+     * @param token - The grant token to validate
+     * @returns The grant details, or `null` if invalid/expired
+     */
     validateTokenWithGrant(token) {
+        if (!token || typeof token !== 'string')
+            return null;
         const grant = this.activeGrants.get(token);
         if (!grant)
             return null;
@@ -374,7 +491,18 @@ class AuthGuardian {
      * Enforce restrictions on an operation. Returns an error string if
      * the operation violates any restriction, or null if allowed.
      */
+    /**
+     * Enforce restrictions on an operation. Returns an error string if
+     * the operation violates any restriction, or `null` if all restrictions pass.
+     *
+     * @param grantToken  - The grant token authorizing the operation
+     * @param operation   - Description of the operation to check against restrictions
+     * @returns Error message string if a restriction is violated, or `null` if allowed
+     */
     enforceRestrictions(grantToken, operation) {
+        if (!grantToken || typeof grantToken !== 'string') {
+            return 'Invalid or expired grant token';
+        }
         const grant = this.validateTokenWithGrant(grantToken);
         if (!grant)
             return 'Invalid or expired grant token';
@@ -422,6 +550,12 @@ class AuthGuardian {
         }
         return null; // All restrictions passed
     }
+    /**
+     * Revoke a grant token, immediately invalidating it.
+     * Silently no-ops if the token doesn't exist.
+     *
+     * @param token - The grant token to revoke
+     */
     revokeToken(token) {
         this.activeGrants.delete(token);
         this.log('permission_revoked', { token });
@@ -558,6 +692,10 @@ class AuthGuardian {
             // Non-fatal -- log is also in memory
         }
     }
+    /**
+     * Get all active (non-expired) permission grants.
+     * Automatically cleans up expired grants before returning.
+     */
     getActiveGrants() {
         // Clean expired grants
         const now = new Date();
@@ -568,6 +706,10 @@ class AuthGuardian {
         }
         return Array.from(this.activeGrants.values());
     }
+    /**
+     * Get the full audit log of permission decisions.
+     * Returns a defensive copy.
+     */
     getAuditLog() {
         return [...this.auditLog];
     }
@@ -581,6 +723,8 @@ class AuthGuardian {
      * Get the allowed namespaces for an agent (used by blackboard scoping).
      */
     getAgentNamespaces(agentId) {
+        if (!agentId || typeof agentId !== 'string')
+            return ['task:'];
         const config = this.agentTrustConfigs.get(agentId);
         return config?.allowedNamespaces ?? ['task:'];
     }
@@ -628,11 +772,28 @@ exports.AuthGuardian = AuthGuardian;
 // ============================================================================
 // TASK DECOMPOSITION ENGINE
 // ============================================================================
+/**
+ * Decomposes complex tasks into parallel sub-agent executions.
+ *
+ * Supports four synthesis strategies (`merge`, `vote`, `chain`, `first-success`)
+ * and caches results on the blackboard to avoid redundant work.
+ * Routes each sub-task through the {@link AdapterRegistry} so any
+ * registered framework can participate.
+ */
 class TaskDecomposer {
     blackboard;
     authGuardian;
     adapterRegistry;
     constructor(blackboard, authGuardian, adapterRegistry) {
+        if (!blackboard || !(blackboard instanceof SharedBlackboard)) {
+            throw new errors_1.ValidationError('blackboard must be an instance of SharedBlackboard');
+        }
+        if (!authGuardian || !(authGuardian instanceof AuthGuardian)) {
+            throw new errors_1.ValidationError('authGuardian must be an instance of AuthGuardian');
+        }
+        if (!adapterRegistry || !(adapterRegistry instanceof adapter_registry_1.AdapterRegistry)) {
+            throw new errors_1.ValidationError('adapterRegistry must be an instance of AdapterRegistry');
+        }
         this.blackboard = blackboard;
         this.authGuardian = authGuardian;
         this.adapterRegistry = adapterRegistry;
@@ -643,10 +804,18 @@ class TaskDecomposer {
      * into manageable parallel executions
      */
     async executeParallel(tasks, synthesisStrategy = 'merge', context) {
+        if (!tasks || !Array.isArray(tasks)) {
+            throw new errors_1.ValidationError('tasks must be an array');
+        }
+        if (tasks.length === 0) {
+            throw new errors_1.ValidationError('tasks array must not be empty');
+        }
+        if (!context || typeof context !== 'object' || !context.agentId) {
+            throw new errors_1.ValidationError('context is required and must include agentId');
+        }
         // Enforce maximum parallel agent limit
         if (tasks.length > CONFIG.maxParallelAgents) {
-            throw new Error(`Cannot spawn ${tasks.length} agents. Maximum is ${CONFIG.maxParallelAgents}. ` +
-                `Decompose further or use 'chain' strategy.`);
+            throw new errors_1.ParallelLimitError(tasks.length, CONFIG.maxParallelAgents);
         }
         const startTime = Date.now();
         const individualResults = [];
@@ -842,9 +1011,31 @@ exports.TaskDecomposer = TaskDecomposer;
 // ============================================================================
 // SWARM ORCHESTRATOR - MAIN SKILL IMPLEMENTATION
 // ============================================================================
+/**
+ * The main orchestrator class — coordinates agents, permissions, blackboard,
+ * quality gates, and adapter routing in a single entry point.
+ *
+ * Implements the OpenClaw skill interface for backward compatibility and
+ * can also be used standalone via {@link createSwarmOrchestrator}.
+ *
+ * @example
+ * ```typescript
+ * import { createSwarmOrchestrator, LangChainAdapter } from 'network-ai';
+ *
+ * const orchestrator = createSwarmOrchestrator({
+ *   adapters: [{ adapter: new LangChainAdapter() }],
+ *   trustLevels: [{ agentId: 'my-agent', trustLevel: 0.8 }],
+ * });
+ *
+ * const result = await orchestrator.execute('delegate_task', {
+ *   targetAgent: 'my-agent',
+ *   taskPayload: { instruction: 'Summarize the quarterly report' },
+ * }, { agentId: 'orchestrator' });
+ * ```
+ */
 class SwarmOrchestrator {
     name = 'SwarmOrchestrator';
-    version = '3.0.0';
+    version = '3.1.0';
     blackboard;
     authGuardian;
     taskDecomposer;
@@ -854,6 +1045,12 @@ class SwarmOrchestrator {
     /** The adapter registry -- routes requests to the right agent framework */
     adapters;
     constructor(workspacePath = process.cwd(), adapterRegistry, options) {
+        if (workspacePath !== undefined && typeof workspacePath !== 'string') {
+            throw new errors_1.ValidationError('workspacePath must be a string');
+        }
+        if (workspacePath !== undefined && workspacePath.trim() === '') {
+            throw new errors_1.ValidationError('workspacePath must not be empty');
+        }
         this.blackboard = new SharedBlackboard(workspacePath);
         this.authGuardian = new AuthGuardian({
             trustLevels: options?.trustLevels,
@@ -875,6 +1072,12 @@ class SwarmOrchestrator {
      * This is the plug-and-play entry point.
      */
     async addAdapter(adapter, config = {}) {
+        if (!adapter || typeof adapter !== 'object') {
+            throw new errors_1.ValidationError('adapter is required and must be an object');
+        }
+        if (typeof adapter.name !== 'string' || adapter.name.trim() === '') {
+            throw new errors_1.ValidationError('adapter.name must be a non-empty string');
+        }
         await this.adapters.addAdapter(adapter, config);
     }
     /**
@@ -883,6 +1086,36 @@ class SwarmOrchestrator {
      * input sanitization, rate limiting, and agent ID validation.
      */
     async execute(action, params, context) {
+        if (!action || typeof action !== 'string') {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'action is required and must be a non-empty string',
+                    recoverable: false,
+                },
+            };
+        }
+        if (!params || typeof params !== 'object' || Array.isArray(params)) {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'params is required and must be a plain object',
+                    recoverable: false,
+                },
+            };
+        }
+        if (!context || typeof context !== 'object' || !context.agentId || typeof context.agentId !== 'string') {
+            return {
+                success: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'context is required and must include a non-empty agentId string',
+                    recoverable: false,
+                },
+            };
+        }
         const traceId = (0, crypto_1.randomUUID)();
         // P0: Route through SecureSwarmGateway -- sanitization + rate limiting
         const gatewayResult = await this.gateway.handleSecureRequest(context.agentId, action, params);
@@ -1343,13 +1576,20 @@ class SwarmOrchestrator {
     }
     timeoutPromise(ms) {
         return new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms);
+            setTimeout(() => reject(new errors_1.TimeoutError(ms)), ms);
         });
     }
     /**
      * Register an agent with the swarm
      */
     registerAgent(agentId, status = 'available') {
+        if (!agentId || typeof agentId !== 'string' || agentId.trim() === '') {
+            throw new errors_1.ValidationError('agentId must be a non-empty string');
+        }
+        const validStatuses = ['available', 'busy', 'waiting_auth', 'offline'];
+        if (!validStatuses.includes(status)) {
+            throw new errors_1.ValidationError(`status must be one of: ${validStatuses.join(', ')}`);
+        }
         this.agentRegistry.set(agentId, {
             agentId,
             status,
@@ -1361,6 +1601,9 @@ class SwarmOrchestrator {
      * Update agent status
      */
     updateAgentStatus(agentId, status, currentTask) {
+        if (!agentId || typeof agentId !== 'string' || agentId.trim() === '') {
+            throw new errors_1.ValidationError('agentId must be a non-empty string');
+        }
         const existing = this.agentRegistry.get(agentId);
         if (existing) {
             existing.status = status;
@@ -1396,6 +1639,23 @@ var mcp_adapter_1 = require("./adapters/mcp-adapter");
 Object.defineProperty(exports, "MCPAdapter", { enumerable: true, get: function () { return mcp_adapter_1.MCPAdapter; } });
 var custom_adapter_1 = require("./adapters/custom-adapter");
 Object.defineProperty(exports, "CustomAdapter", { enumerable: true, get: function () { return custom_adapter_1.CustomAdapter; } });
+// Logger
+var logger_2 = require("./lib/logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_2.Logger; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_2.LogLevel; } });
+// Typed errors
+var errors_2 = require("./lib/errors");
+Object.defineProperty(exports, "NetworkAIError", { enumerable: true, get: function () { return errors_2.NetworkAIError; } });
+Object.defineProperty(exports, "IdentityVerificationError", { enumerable: true, get: function () { return errors_2.IdentityVerificationError; } });
+Object.defineProperty(exports, "NamespaceViolationError", { enumerable: true, get: function () { return errors_2.NamespaceViolationError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_2.ValidationError; } });
+Object.defineProperty(exports, "LockAcquisitionError", { enumerable: true, get: function () { return errors_2.LockAcquisitionError; } });
+Object.defineProperty(exports, "ConflictError", { enumerable: true, get: function () { return errors_2.ConflictError; } });
+Object.defineProperty(exports, "AdapterAlreadyRegisteredError", { enumerable: true, get: function () { return errors_2.AdapterAlreadyRegisteredError; } });
+Object.defineProperty(exports, "AdapterNotFoundError", { enumerable: true, get: function () { return errors_2.AdapterNotFoundError; } });
+Object.defineProperty(exports, "AdapterNotInitializedError", { enumerable: true, get: function () { return errors_2.AdapterNotInitializedError; } });
+Object.defineProperty(exports, "ParallelLimitError", { enumerable: true, get: function () { return errors_2.ParallelLimitError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_2.TimeoutError; } });
 /**
  * Factory function for creating a configured SwarmOrchestrator instance.
  *
@@ -1405,7 +1665,34 @@ Object.defineProperty(exports, "CustomAdapter", { enumerable: true, get: functio
  *     adapters: [{ adapter: new LangChainAdapter(), config: {} }],
  *   });
  */
+/**
+ * Factory function for creating a fully configured {@link SwarmOrchestrator}.
+ *
+ * Accepts optional configuration for adapters, trust levels, resource profiles,
+ * quality gate settings, and runtime overrides.
+ *
+ * @param config - Optional configuration object. Pass `undefined` for all defaults.
+ * @returns A ready-to-use SwarmOrchestrator instance.
+ *
+ * @example
+ * ```typescript
+ * import { createSwarmOrchestrator, LangChainAdapter } from 'network-ai';
+ *
+ * // Minimal
+ * const orc = createSwarmOrchestrator();
+ *
+ * // With adapters and trust
+ * const orc2 = createSwarmOrchestrator({
+ *   adapters: [{ adapter: new LangChainAdapter() }],
+ *   trustLevels: [{ agentId: 'analyst', trustLevel: 0.8 }],
+ *   qualityThreshold: 0.7,
+ * });
+ * ```
+ */
 function createSwarmOrchestrator(config) {
+    if (config !== undefined && (typeof config !== 'object' || config === null || Array.isArray(config))) {
+        throw new errors_1.ValidationError('config must be a plain object');
+    }
     if (config) {
         const { adapters: adapterList, adapterRegistry, trustLevels, resourceProfiles, validationConfig, qualityThreshold, aiReviewCallback, ...rest } = config;
         Object.assign(CONFIG, rest);
@@ -1419,7 +1706,7 @@ function createSwarmOrchestrator(config) {
         });
         // Initialize adapters if provided
         if (adapterList) {
-            Promise.all(adapterList.map(({ adapter, config: adapterConfig }) => orchestrator.addAdapter(adapter, adapterConfig ?? {}))).catch(err => console.error('[SwarmOrchestrator] Adapter init error:', err));
+            Promise.all(adapterList.map(({ adapter, config: adapterConfig }) => orchestrator.addAdapter(adapter, adapterConfig ?? {}))).catch(err => log.error('Adapter init error', { error: err instanceof Error ? err.message : String(err) }));
         }
         return orchestrator;
     }