@iworkforces/tracelattice 2.0.3

package/dist/lib.d.ts

@@ -0,0 +1,273 @@
+import { EventEmitter } from 'node:events';
+import type * as v from 'valibot';
+import type { ThoughtData } from './core/thought.js';
+import type { BranchId } from './contracts/ids.js';
+import type { SequentialThinkingSchema } from './schema.js';
+import type { IDisposable } from './types/disposable.js';
+import type { ConfigFileOptions } from './config/ConfigLoader.js';
+import { HistoryManager } from './core/HistoryManager.js';
+import { type CallToolResult } from './core/ThoughtProcessor.js';
+import { Container } from './di/Container.js';
+import { StructuredLogger } from './logger/StructuredLogger.js';
+import { SkillRegistry } from './registry/SkillRegistry.js';
+import { ToolRegistry } from './registry/ToolRegistry.js';
+import { ServerConfig } from './ServerConfig.js';
+import type { SseTransportOptions } from './transport/SseTransport.js';
+export interface ServerOptions {
+    maxHistorySize?: number;
+    maxBranches?: number;
+    maxBranchSize?: number;
+    logger?: StructuredLogger;
+    enableWatcher?: boolean;
+    config?: ServerConfig;
+    fileConfig?: ConfigFileOptions;
+    container?: Container;
+    /**
+     * Enable automatic tool and skill discovery on server startup.
+     * @default true
+     */
+    autoDiscover?: boolean;
+    /**
+     * Suppress startup discovery so callers can discover through registry APIs explicitly.
+     * @default false
+     */
+    lazyDiscovery?: boolean;
+    /**
+     * Load history from persistence on initialization
+     * @default true
+     */
+    loadFromPersistence?: boolean;
+    /**
+     * Transport type to use
+     * @default 'stdio'
+     */
+    transport?: 'stdio' | 'sse';
+    /**
+     * SSE transport options (used when transport: 'sse')
+     */
+    sseTransportOptions?: SseTransportOptions;
+}
+/**
+ * Server error events for event-driven error handling
+ */
+interface ServerEvents {
+    persistenceError: {
+        operation: string;
+        error: Error;
+    };
+    discoveryError: {
+        directory: string;
+        error: Error;
+    };
+    transportError: {
+        transport: string;
+        error: Error;
+    };
+    thoughtProcessed: {
+        thoughtNumber: number;
+        duration: number;
+    };
+}
+/**
+ * Public API contract for the tool-aware sequential thinking server.
+ *
+ * Extends {@link IDisposable} for resource cleanup. Concrete implementations
+ * are expected to also extend Node's `EventEmitter` to support the typed
+ * `emit`/`on` overloads.
+ */
+export interface IToolAwareSequentialThinkingServer extends IDisposable {
+    /** Direct access to the history manager. */
+    readonly history: HistoryManager;
+    /** Direct access to the tool registry. */
+    readonly tools: ToolRegistry;
+    /** Direct access to the skill registry. */
+    readonly skills: SkillRegistry;
+    /** Server configuration. */
+    readonly config: ServerConfig;
+    /**
+     * Discover skills asynchronously without blocking server startup.
+     *
+     * @returns The number of skills discovered
+     */
+    discoverSkillsAsync(): Promise<number>;
+    /**
+     * Get all branches from the history manager.
+     *
+     * @returns Map of branch IDs to thought arrays
+     */
+    getBranches(): Record<string, ThoughtData[]>;
+    /**
+     * Process a thought through the configured pipeline.
+     *
+     * @param input - Validated thought input matching the schema
+     * @returns The processing result
+     */
+    processThought(input: v.InferInput<typeof SequentialThinkingSchema>): Promise<CallToolResult>;
+    /**
+     * Export the current Prometheus metrics snapshot.
+     */
+    getMetricsSnapshot(): string;
+    /**
+     * Get the DI container used by this server.
+     * Useful for testing and advanced customizations.
+     */
+    getContainer(): Container;
+    /**
+     * Stop the server and clean up watchers, suspension stores, and persistence.
+     */
+    stop(): Promise<void>;
+    /**
+     * Clear all server state (history, tools, skills).
+     */
+    clear(): void;
+    /** Awaitably reset one session and all matching auxiliary state. */
+    resetSession(sessionId: string): Promise<void>;
+    /** Awaitably reset all state from a trusted ownerless context. */
+    resetAll(): Promise<void>;
+    /**
+     * Dispose of the server and all container services.
+     */
+    dispose(): Promise<void>;
+}
+export declare class ToolAwareSequentialThinkingServer extends EventEmitter implements IToolAwareSequentialThinkingServer {
+    /**
+     * Factory method to create a new server instance with async initialization.
+     * This is the recommended way to create server instances.
+     *
+     * @param options - Server configuration options
+     * @returns A Promise that resolves to a configured server instance
+     */
+    static create(options?: ServerOptions): Promise<ToolAwareSequentialThinkingServer>;
+    emit<K extends keyof ServerEvents>(event: K, payload: ServerEvents[K]): boolean;
+    on<K extends keyof ServerEvents>(event: K, listener: (payload: ServerEvents[K]) => void): this;
+    private _container;
+    private _logger;
+    private _historyManager;
+    private _thoughtProcessor;
+    private _metrics;
+    private _skillWatcher;
+    private _toolWatcher;
+    private _config;
+    private _stopPromise;
+    private _disposePromise;
+    /**
+     * Direct access to the history manager
+     * @example
+     * ```typescript
+     * server.history.getHistory();
+     * server.history.clear();
+     * ```
+     */
+    readonly history: HistoryManager;
+    /**
+     * Direct access to the tool registry
+     * @example
+     * ```typescript
+     * server.tools.addTool(tool);
+     * server.tools.getTool('my-tool');
+     * ```
+     */
+    readonly tools: ToolRegistry;
+    /**
+     * Direct access to the skill registry
+     * @example
+     * ```typescript
+     * server.skills.addSkill(skill);
+     * server.skills.getSkill('my-skill');
+     * ```
+     */
+    readonly skills: SkillRegistry;
+    /**
+     * Server configuration
+     * @example
+     * ```typescript
+     * console.log(server.config.maxHistorySize);
+     * ```
+     */
+    readonly config: ServerConfig;
+    constructor(options?: ServerOptions);
+    /**
+     * Shared core logic for container creation.
+     * This method contains all common initialization logic between sync and async paths.
+     */
+    private static _createContainerCore;
+    private static _resolveEffectiveConfig;
+    private static _registerDiscoveryRegistries;
+    private static _registerHistoryManager;
+    private static _registerThoughtPipeline;
+    /**
+     * Create and configure the DI container with async persistence initialization.
+     * This is used internally by the static create() factory.
+     */
+    private static _createContainerAsyncStatic;
+    /**
+     * Get the DI container used by this server
+     * Useful for testing and advanced customizations
+     */
+    getContainer(): Container;
+    /**
+     * Discover skills asynchronously without blocking server startup.
+     * This is the recommended method for skill discovery.
+     * @returns Promise<number> - The number of skills discovered
+     */
+    discoverSkillsAsync(): Promise<number>;
+    /**
+     * Get all branches from the history manager
+     * @returns Record<string, ThoughtData[]> - Map of branch IDs to thought arrays
+     */
+    getBranches(): Record<BranchId, ThoughtData[]>;
+    processThought(input: v.InferInput<typeof SequentialThinkingSchema>): Promise<CallToolResult>;
+    getMetricsSnapshot(): string;
+    /**
+     * Stop the server and clean up watchers.
+     * Closes persistence backend gracefully to ensure data is flushed.
+     */
+    stop(): Promise<void>;
+    /**
+     * Clear all server state (history, tools, skills)
+     * Useful for testing to reset state between tests
+     */
+    clear(): void;
+    /** Awaitably resets one session and matching processor-owned state. */
+    resetSession(sessionId: string): Promise<void>;
+    /** Awaitably resets all server state from a trusted ownerless context. */
+    resetAll(): Promise<void>;
+    /**
+     * Dispose of the server and all container services.
+     * Implements the IDisposable interface.
+     * Calls stop() for existing cleanup, then disposes the DI container.
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Factory function to create a new server instance with async initialization.
+ *
+ * This is the recommended way to create server instances, especially for testing,
+ * as it allows for proper async initialization, dependency injection, and persistence.
+ *
+ * @param options - Server configuration options
+ * @returns A Promise that resolves to a configured server instance
+ *
+ * @example
+ * ```typescript
+ * // Basic usage (with async discovery and persistence)
+ * const server = await createServer();
+ *
+ * // With custom options
+ * const server = await createServer({
+ *   autoDiscover: false,
+ *   lazyDiscovery: true,
+ *   maxHistorySize: 500,
+ *   loadFromPersistence: true
+ * });
+ *
+ * // With custom container for testing
+ * const mockContainer = new Container();
+ * mockContainer.registerInstance('Logger', mockLogger);
+ * const server = await createServer({ container: mockContainer });
+ * ```
+ */
+export declare function createServer(options?: ServerOptions): Promise<ToolAwareSequentialThinkingServer>;
+export declare function initializeServer(): Promise<ToolAwareSequentialThinkingServer>;
+export {};
+//# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"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"}

package/dist/lib.js

@@ -0,0 +1,409 @@
+import { EventEmitter } from "node:events";
+import { SEQUENTIAL_THINKING_TOOL } from "./schema.js";
+import { getErrorMessage } from "./errors.js";
+import { assertNever } from "./utils.js";
+import { DiscoveryCache } from "./cache/DiscoveryCache.js";
+import { ConfigLoader } from "./config/ConfigLoader.js";
+import { HistoryManager } from "./core/HistoryManager.js";
+import { EdgeStore } from "./core/graph/EdgeStore.js";
+import { InMemorySummaryStore } from "./core/compression/InMemorySummaryStore.js";
+import { CompressionService } from "./core/compression/CompressionService.js";
+import { InMemorySuspensionStore } from "./core/tools/InMemorySuspensionStore.js";
+import { ThoughtEvaluator } from "./core/ThoughtEvaluator.js";
+import { Calibrator } from "./core/evaluator/Calibrator.js";
+import { OutcomeRecorder } from "./core/reasoning/OutcomeRecorder.js";
+import { createReasoningStrategy } from "./core/reasoning/strategies/StrategyFactory.js";
+import { ThoughtFormatter } from "./core/ThoughtFormatter.js";
+import { ThoughtProcessor } from "./core/ThoughtProcessor.js";
+import { SessionLock } from "./core/SessionLock.js";
+import { SessionLifecycleCoordinator } from "./core/SessionLifecycleCoordinator.js";
+import { Container } from "./di/Container.js";
+import { StructuredLogger } from "./logger/StructuredLogger.js";
+import { Metrics } from "./metrics/metrics.impl.js";
+import { createPersistenceBackend } from "./persistence/PersistenceFactory.js";
+import { SkillRegistry } from "./registry/SkillRegistry.js";
+import { ToolRegistry } from "./registry/ToolRegistry.js";
+import { ServerConfig } from "./ServerConfig.js";
+import { SkillWatcher } from "./watchers/SkillWatcher.js";
+import { ToolWatcher } from "./watchers/ToolWatcher.js";
+function appendCleanupFailure(failures, failure) {
+    if (failure instanceof AggregateError) return void failures.push(...failure.errors);
+    failures.push(failure);
+}
+async function collectCleanupFailures(operations) {
+    const failures = [];
+    for (const operation of operations)try {
+        await operation();
+    } catch (error) {
+        appendCleanupFailure(failures, error);
+    }
+    return failures;
+}
+class ToolAwareSequentialThinkingServer extends EventEmitter {
+    static async create(options = {}) {
+        const container = await ToolAwareSequentialThinkingServer._createContainerAsyncStatic(options);
+        let server;
+        try {
+            server = new ToolAwareSequentialThinkingServer({
+                ...options,
+                container
+            });
+            await Promise.all([
+                server._skillWatcher?.ready() ?? Promise.resolve(),
+                server._toolWatcher?.ready() ?? Promise.resolve()
+            ]);
+            if (false !== options.loadFromPersistence) await server.history.loadFromPersistence();
+            if (false !== options.autoDiscover && true !== options.lazyDiscovery) await Promise.all([
+                server.tools.discoverAsync(),
+                server.discoverSkillsAsync()
+            ]);
+            return server;
+        } catch (error) {
+            const startedServer = server;
+            const cleanupFailures = await collectCleanupFailures(startedServer ? [
+                ()=>startedServer.dispose()
+            ] : [
+                ()=>{
+                    if (container.has('suspensionStore')) container.resolve('suspensionStore').stop();
+                },
+                ()=>container.resolve('Persistence')?.close(),
+                ()=>container.dispose()
+            ]);
+            if (cleanupFailures.length > 0) throw new AggregateError([
+                error,
+                ...cleanupFailures
+            ], 'Server startup failed and cleanup also failed', {
+                cause: error
+            });
+            throw error;
+        }
+    }
+    emit(event, payload) {
+        return super.emit(event, payload);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    _container;
+    _logger;
+    _historyManager;
+    _thoughtProcessor;
+    _metrics;
+    _skillWatcher = null;
+    _toolWatcher = null;
+    _config;
+    _stopPromise = null;
+    _disposePromise = null;
+    history;
+    tools;
+    skills;
+    config;
+    constructor(options = {}){
+        super();
+        if (!options.container) throw new Error('Container is required. Use createServer() or provide a container.');
+        this._container = options.container;
+        this._logger = this._container.resolve('Logger');
+        this._historyManager = this._container.resolve('HistoryManager');
+        this._historyManager.bindShutdownOwner(()=>this.stop());
+        this._thoughtProcessor = this._container.resolve('ThoughtProcessor');
+        this._metrics = this._container.resolve('Metrics');
+        this._config = this._container.resolve('Config');
+        this.history = this._historyManager;
+        this._historyManager.setEventEmitter(this);
+        this.tools = this._container.resolve('ToolRegistry');
+        this.skills = this._container.resolve('SkillRegistry');
+        this.config = this._config;
+        this.tools.addTool(SEQUENTIAL_THINKING_TOOL);
+        if (options.enableWatcher) {
+            this._skillWatcher = new SkillWatcher(this.skills, this._logger, this.config.skillDirs);
+            this._toolWatcher = new ToolWatcher(this.tools, this._logger, this.config.toolDirs);
+        }
+    }
+    static _createContainerCore(options, fileConfig, persistence) {
+        const container = new Container();
+        const metrics = new Metrics({
+            prefix: 'sequentialthinking'
+        });
+        const config = ToolAwareSequentialThinkingServer._resolveEffectiveConfig(options, fileConfig);
+        const logger = options.logger ?? new StructuredLogger({
+            level: fileConfig?.logLevel ?? 'info',
+            context: 'SequentialThinking',
+            pretty: fileConfig?.prettyLog ?? true
+        });
+        container.registerInstance('Logger', logger);
+        container.registerInstance('Config', config);
+        container.registerInstance('FileConfig', fileConfig || {});
+        container.registerInstance('Persistence', persistence);
+        container.registerInstance('Metrics', metrics);
+        ToolAwareSequentialThinkingServer._registerDiscoveryRegistries(container, options.lazyDiscovery);
+        container.register('EdgeStore', ()=>new EdgeStore());
+        container.register('summaryStore', ()=>new InMemorySummaryStore());
+        if (config.features.toolInterleave) container.register('suspensionStore', ()=>{
+            const store = new InMemorySuspensionStore({
+                ttlMs: config.toolInterleaveTtlMs,
+                sweepIntervalMs: config.toolInterleaveSweepMs,
+                logger
+            });
+            store.start();
+            return store;
+        });
+        container.register('compressionService', ()=>{
+            const historyManager = container.resolve('HistoryManager');
+            const edgeStore = container.resolve('EdgeStore');
+            const summaryStore = container.resolve('summaryStore');
+            const log = container.resolve('Logger');
+            return new CompressionService({
+                historyManager,
+                edgeStore,
+                summaryStore,
+                onSummaryCreated: (summary)=>{
+                    historyManager.bufferSummaries(summary.sessionId, summaryStore.forSession(summary.sessionId));
+                },
+                logger: log
+            });
+        });
+        container.register('reasoningStrategy', ()=>createReasoningStrategy(config.features.reasoningStrategy));
+        container.register('sessionLock', ()=>new SessionLock());
+        container.register('sessionLifecycle', ()=>new SessionLifecycleCoordinator());
+        ToolAwareSequentialThinkingServer._registerHistoryManager(container);
+        ToolAwareSequentialThinkingServer._registerThoughtPipeline(container, config);
+        return container;
+    }
+    static _resolveEffectiveConfig(options, fileConfig) {
+        if (options.config) return options.config;
+        const loadedOptions = new ConfigLoader().toServerConfigOptions(fileConfig ?? {});
+        return new ServerConfig({
+            ...loadedOptions,
+            maxHistorySize: options.maxHistorySize ?? loadedOptions.maxHistorySize,
+            maxBranches: options.maxBranches ?? loadedOptions.maxBranches,
+            maxBranchSize: options.maxBranchSize ?? loadedOptions.maxBranchSize
+        });
+    }
+    static _registerDiscoveryRegistries(container, lazyDiscovery) {
+        const logger = container.resolve('Logger');
+        const config = container.resolve('Config');
+        const metrics = container.resolve('Metrics');
+        container.register('ToolRegistry', ()=>new ToolRegistry({
+                logger,
+                cache: config.discoveryCache ? new DiscoveryCache({
+                    ...config.discoveryCache,
+                    metrics
+                }) : void 0,
+                toolDirs: config.toolDirs,
+                lazyDiscovery
+            }));
+        container.register('SkillRegistry', ()=>new SkillRegistry({
+                logger,
+                cache: config.discoveryCache ? new DiscoveryCache({
+                    ...config.discoveryCache,
+                    metrics
+                }) : void 0,
+                skillDirs: config.skillDirs,
+                lazyDiscovery
+            }));
+    }
+    static _registerHistoryManager(container) {
+        container.register('HistoryManager', ()=>{
+            const cfg = container.resolve('Config');
+            const log = container.resolve('Logger');
+            const pers = container.resolve('Persistence');
+            const componentMetrics = container.resolve('Metrics');
+            const edgeStore = container.resolve('EdgeStore');
+            const summaryStore = container.resolve('summaryStore');
+            return new HistoryManager({
+                maxHistorySize: cfg.maxHistorySize,
+                maxBranches: cfg.maxBranches,
+                maxBranchSize: cfg.maxBranchSize,
+                logger: log,
+                persistence: pers,
+                metrics: componentMetrics,
+                persistenceBufferSize: cfg.persistenceBufferSize,
+                persistenceFlushInterval: cfg.persistenceFlushInterval,
+                persistenceMaxRetries: cfg.persistenceMaxRetries,
+                edgeStore,
+                summaryStore,
+                dagEdges: cfg.features.dagEdges,
+                maxSessionsPerOwner: cfg.maxSessionsPerOwner,
+                sessionLock: container.resolve('sessionLock'),
+                lifecycleCoordinator: container.resolve('sessionLifecycle'),
+                clearSessionAuxiliaryState: (sessionId)=>container.resolve('ThoughtProcessor').clearSessionAuxiliaryState(sessionId),
+                clearAllAuxiliaryState: ()=>container.resolve('ThoughtProcessor').clearAllAuxiliaryState()
+            });
+        });
+    }
+    static _registerThoughtPipeline(container, config) {
+        container.registerFactory('ThoughtFormatter', ()=>new ThoughtFormatter());
+        container.register('outcomeRecorder', ()=>new OutcomeRecorder({
+                enabled: config.features.outcomeRecording ?? false
+            }));
+        container.register('calibrator', ()=>new Calibrator(container.resolve('outcomeRecorder'), config.features.calibration ?? false));
+        container.registerFactory('ThoughtEvaluator', ()=>new ThoughtEvaluator(container.resolve('calibrator')));
+        container.register('ThoughtProcessor', ()=>{
+            const history = container.resolve('HistoryManager');
+            const formatter = container.resolve('ThoughtFormatter');
+            const evaluator = container.resolve('ThoughtEvaluator');
+            const log = container.resolve('Logger');
+            const strategy = container.resolve('reasoningStrategy');
+            const compressionService = config.features.compression ? container.resolve('compressionService') : void 0;
+            const suspensionStore = config.features.toolInterleave ? container.resolve('suspensionStore') : void 0;
+            const toolRegistry = container.resolve('ToolRegistry');
+            const sessionLock = container.resolve('sessionLock');
+            return new ThoughtProcessor(history, formatter, evaluator, log, strategy, compressionService, suspensionStore, toolRegistry, config.features, sessionLock, container.resolve('outcomeRecorder'), container.resolve('sessionLifecycle'), container.resolve('calibrator'));
+        });
+    }
+    static async _createContainerAsyncStatic(options) {
+        let fileConfig;
+        let config;
+        if (options.config) {
+            fileConfig = options.fileConfig ?? null;
+            config = options.config;
+        } else {
+            const configLoader = new ConfigLoader();
+            fileConfig = void 0 === options.fileConfig ? configLoader.load() : configLoader.applyEnvironmentOverrides(options.fileConfig);
+            config = ToolAwareSequentialThinkingServer._resolveEffectiveConfig(options, fileConfig);
+        }
+        let persistence = null;
+        try {
+            persistence = await createPersistenceBackend(config.persistence);
+            return ToolAwareSequentialThinkingServer._createContainerCore({
+                ...options,
+                config
+            }, fileConfig, persistence);
+        } catch (error) {
+            const acquiredPersistence = persistence;
+            const cleanupFailures = null === acquiredPersistence ? [] : await collectCleanupFailures([
+                ()=>acquiredPersistence.close()
+            ]);
+            if (cleanupFailures.length > 0) throw new AggregateError([
+                error,
+                ...cleanupFailures
+            ], 'Container construction failed and cleanup also failed', {
+                cause: error
+            });
+            throw error;
+        }
+    }
+    getContainer() {
+        return this._container;
+    }
+    async discoverSkillsAsync() {
+        const discovered = await this.skills.discoverAsync();
+        return discovered;
+    }
+    getBranches() {
+        return this._historyManager.getBranches();
+    }
+    async processThought(input) {
+        const startTime = Date.now();
+        const result = await this._thoughtProcessor.process(input);
+        const durationSeconds = (Date.now() - startTime) / 1000;
+        this._metrics.histogram('thought_processing_duration_seconds', durationSeconds, {});
+        return result;
+    }
+    getMetricsSnapshot() {
+        return this._metrics.export();
+    }
+    stop() {
+        if (this._stopPromise) return this._stopPromise;
+        this._stopPromise = this._container.resolve('sessionLifecycle').shutdown(async ()=>{
+            const failures = [];
+            const watcherResults = await Promise.allSettled([
+                this._skillWatcher?.stop() ?? Promise.resolve(),
+                this._toolWatcher?.stop() ?? Promise.resolve()
+            ]);
+            for (const result of watcherResults)switch(result.status){
+                case 'fulfilled':
+                    break;
+                case 'rejected':
+                    appendCleanupFailure(failures, result.reason);
+                    this._logger.error('Error stopping watcher', {
+                        error: getErrorMessage(result.reason)
+                    });
+                    break;
+                default:
+                    assertNever(result);
+            }
+            if (this._config.features.toolInterleave && this._container.has('suspensionStore')) try {
+                const suspensionStore = this._container.resolve('suspensionStore');
+                suspensionStore.stop();
+            } catch (error) {
+                appendCleanupFailure(failures, error);
+                this._logger.error('Error stopping suspension store', {
+                    error: getErrorMessage(error)
+                });
+            }
+            try {
+                await this._historyManager.shutdownWithinLifecycle();
+            } catch (error) {
+                appendCleanupFailure(failures, error);
+                this._logger.error('Error flushing write buffer during shutdown', {
+                    error: getErrorMessage(error)
+                });
+            }
+            const persistence = this._container.resolve('Persistence');
+            if (persistence) try {
+                await persistence.close();
+                this._logger.info('Persistence backend closed');
+            } catch (error) {
+                appendCleanupFailure(failures, error);
+                this._logger.error('Error closing persistence backend', {
+                    error: getErrorMessage(error)
+                });
+            }
+            if (failures.length > 0) throw new AggregateError(failures, 'Failed to stop server cleanly');
+            this._historyManager.clearLiveStateAfterShutdown();
+            this._logger.info('Server stopped, watchers cleaned up');
+        });
+        return this._stopPromise;
+    }
+    clear() {
+        this._historyManager.clear();
+        this._logger.info('Server state cleared');
+    }
+    async resetSession(sessionId) {
+        await this._thoughtProcessor.resetSession(sessionId);
+        this._logger.info('Server session reset', {
+            sessionId
+        });
+    }
+    async resetAll() {
+        await this._thoughtProcessor.resetAll();
+        this._logger.info('All server sessions reset');
+    }
+    dispose() {
+        if (this._disposePromise) return this._disposePromise;
+        this._disposePromise = (async ()=>{
+            const failures = await collectCleanupFailures([
+                ()=>this.stop(),
+                ()=>this._container.dispose()
+            ]);
+            if (failures.length > 0) throw new AggregateError(failures, 'Failed to dispose server cleanly');
+            this._logger.info('Server disposed, all resources released');
+        })();
+        return this._disposePromise;
+    }
+}
+async function createServer(options = {}) {
+    return ToolAwareSequentialThinkingServer.create(options);
+}
+async function initializeServer() {
+    const configLoader = new ConfigLoader();
+    const fileConfig = configLoader.load() ?? {};
+    const config = new ServerConfig(configLoader.toServerConfigOptions(fileConfig));
+    const logger = new StructuredLogger({
+        level: fileConfig.logLevel ?? 'info',
+        context: 'SequentialThinking',
+        pretty: fileConfig.prettyLog ?? true
+    });
+    const thinkingServer = await createServer({
+        logger,
+        enableWatcher: true,
+        config,
+        fileConfig
+    });
+    logger.info('Server initialized successfully');
+    return thinkingServer;
+}
+export { ToolAwareSequentialThinkingServer, createServer, initializeServer };
+
+//# sourceMappingURL=lib.js.map