tracelattice 1.2.5

package/dist/errors.d.ts

@@ -0,0 +1,482 @@
+/**
+ * Custom error types for the TraceLattice server.
+ *
+ * This module defines a hierarchy of error classes for handling various
+ * error conditions that can occur in the sequential thinking server.
+ * All errors extend the base `SequentialThinkingError` class with
+ * specific error codes for programmatic handling.
+ *
+ * @example
+ * ```typescript
+ * import { ToolNotFoundError, SkillDiscoveryError } from './errors.js';
+ *
+ * // Throw a tool not found error
+ * throw new ToolNotFoundError('my-tool');
+ *
+ * // Catch and handle specific errors
+ * try {
+ *   await discoverSkills(dir);
+ * } catch (error) {
+ *   if (error instanceof SkillDiscoveryError) {
+ *     console.error(`Failed to discover skills: ${error.message}`);
+ *     console.error(`Error code: ${error.code}`);
+ *   }
+ * }
+ * ```
+ * @module errors
+ */
+/**
+ * Base error class for all Sequential Thinking server errors.
+ *
+ * This error extends the native `Error` class and adds a `code` property
+ * for programmatic error identification and handling. All specific error
+ * types in the system extend this base class.
+ *
+ * @remarks
+ * **Error Codes:**
+ * - `TOOL_NOT_FOUND` - A requested tool was not found
+ * - `SKILL_NOT_FOUND` - A requested skill was not found
+ * - `INVALID_THOUGHT` - Thought validation failed
+ * - `SKILL_DISCOVERY_FAILED` - Skill discovery operation failed
+ * - `HISTORY_LIMIT_EXCEEDED` - History size limit was exceeded
+ *
+ * @example
+ * ```typescript
+ * // Throw a custom sequential thinking error
+ * throw new SequentialThinkingError('Custom error message', 'CUSTOM_CODE');
+ *
+ * // Check if an error is a SequentialThinkingError
+ * if (error instanceof SequentialThinkingError) {
+ *   console.error(`Error [${error.code}]: ${error.message}`);
+ * }
+ * ```
+ */
+export declare class SequentialThinkingError extends Error {
+    /** The error code for programmatic identification. */
+    readonly code: string;
+    /**
+     * Creates a new SequentialThinkingError.
+     *
+     * @param message - Human-readable error message
+     * @param code - Error code for programmatic handling
+     *
+     * @example
+     * ```typescript
+     * const error = new SequentialThinkingError(
+     *   'Something went wrong',
+     *   'CUSTOM_ERROR'
+     * );
+     * console.log(error.code); // 'CUSTOM_ERROR'
+     * ```
+     */
+    constructor(message: string, code: string);
+}
+export declare class ConfigurationError extends SequentialThinkingError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a requested tool is not found in the registry.
+ *
+ * This error is thrown when attempting to retrieve, update, or delete
+ * a tool that doesn't exist in the tool registry.
+ *
+ * @example
+ * ```typescript
+ * const tool = registry.getTool('non-existent-tool');
+ * if (!tool) {
+ *   throw new ToolNotFoundError('non-existent-tool');
+ * }
+ * ```
+ */
+export declare class ToolNotFoundError extends SequentialThinkingError {
+    /**
+     * Creates a new ToolNotFoundError.
+     *
+     * @param toolName - The name of the tool that was not found
+     * @param action - Optional action being performed (e.g., 'remove', 'update')
+     *
+     * @example
+     * ```typescript
+     * throw new ToolNotFoundError('my-custom-tool');
+     * // Error: tool 'my-custom-tool' not found
+     *
+     * throw new ToolNotFoundError('my-custom-tool', 'remove');
+     * // Error: tool 'my-custom-tool' not found, cannot remove
+     * // Code: TOOL_NOT_FOUND
+     * ```
+     */
+    constructor(toolName: string, action?: string);
+}
+/**
+ * Error thrown when a requested skill is not found in the registry.
+ *
+ * This error is thrown when attempting to retrieve, update, or delete
+ * a skill that doesn't exist in the skill registry.
+ *
+ * @example
+ * ```typescript
+ * const skill = registry.getSkill('non-existent-skill');
+ * if (!skill) {
+ *   throw new SkillNotFoundError('non-existent-skill');
+ * }
+ * ```
+ */
+export declare class SkillNotFoundError extends SequentialThinkingError {
+    /**
+     * Creates a new SkillNotFoundError.
+     *
+     * @param skillName - The name of the skill that was not found
+     * @param action - Optional action being performed (e.g., 'remove', 'update')
+     *
+     * @example
+     * ```typescript
+     * throw new SkillNotFoundError('my-custom-skill');
+     * // Error: skill 'my-custom-skill' not found
+     *
+     * throw new SkillNotFoundError('my-custom-skill', 'remove');
+     * // Error: skill 'my-custom-skill' not found, cannot remove
+     * // Code: SKILL_NOT_FOUND
+     * ```
+     */
+    constructor(skillName: string, action?: string);
+}
+/**
+ * Error thrown when thought validation fails.
+ *
+ * This error is thrown when a thought fails validation, typically due to
+ * invalid values, missing required fields, or constraint violations.
+ *
+ * @example
+ * ```typescript
+ * // Validate thought number
+ * if (thought.thought_number < 1) {
+ *   throw new InvalidThoughtError(thought.thought_number, 'thought_number must be >= 1');
+ * }
+ * ```
+ */
+export declare class InvalidThoughtError extends SequentialThinkingError {
+    /**
+     * Creates a new InvalidThoughtError.
+     *
+     * @param thoughtNumber - The thought number that failed validation
+     * @param reason - Human-readable explanation of why validation failed
+     *
+     * @example
+     * ```typescript
+     * throw new InvalidThoughtError(5, 'thought_number exceeds total_thoughts');
+     * // Error: Invalid thought 5: thought_number exceeds total_thoughts
+     * // Code: INVALID_THOUGHT
+     * ```
+     */
+    constructor(thoughtNumber: number, reason: string);
+}
+/**
+ * Error thrown when skill discovery fails.
+ *
+ * This error is thrown when the skill discovery process encounters an issue,
+ * such as filesystem errors, invalid skill files, or parsing failures.
+ *
+ * @remarks
+ * The original error that caused the discovery failure is preserved in the
+ * `cause` property for debugging purposes.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await discoverSkills('./skills');
+ * } catch (error) {
+ *   throw new SkillDiscoveryError('./skills', error as Error);
+ * }
+ * ```
+ */
+export declare class SkillDiscoveryError extends SequentialThinkingError {
+    /** The underlying error that caused the discovery failure. */
+    readonly cause: Error;
+    /**
+     * Creates a new SkillDiscoveryError.
+     *
+     * @param directory - The directory where discovery failed
+     * @param cause - The underlying error that caused the failure
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const skills = await loadSkills('./invalid-directory');
+     * } catch (error) {
+     *   throw new SkillDiscoveryError('./invalid-directory', error as Error);
+     * }
+     * ```
+     */
+    constructor(directory: string, cause: Error);
+}
+/**
+ * Error thrown when history size exceeds the configured limit.
+ *
+ * This error is thrown when an operation would cause the history size
+ * to exceed the maximum configured size limit.
+ *
+ * @example
+ * ```typescript
+ * if (history.length >= maxSize) {
+ *   throw new HistoryLimitExceededError(history.length, maxSize);
+ * }
+ * ```
+ */
+export declare class HistoryLimitExceededError extends SequentialThinkingError {
+    /**
+     * Creates a new HistoryLimitExceededError.
+     *
+     * @param currentSize - The current history size
+     * @param maxSize - The maximum allowed size
+     *
+     * @example
+     * ```typescript
+     * throw new HistoryLimitExceededError(1500, 1000);
+     * // Error: History size 1500 exceeds limit 1000
+     * // Code: HISTORY_LIMIT_EXCEEDED
+     * ```
+     */
+    constructor(currentSize: number, maxSize: number);
+}
+/**
+ * Error thrown when attempting to add a skill that already exists.
+ *
+ * This error is thrown when trying to register a skill with a name that
+ * is already present in the skill registry.
+ *
+ * @example
+ * ```typescript
+ * if (registry.hasSkill(skill.name)) {
+ *   throw new DuplicateSkillError(skill.name);
+ * }
+ * ```
+ */
+export declare class DuplicateSkillError extends SequentialThinkingError {
+    /**
+     * Creates a new DuplicateSkillError.
+     *
+     * @param skillName - The name of the duplicate skill
+     *
+     * @example
+     * ```typescript
+     * throw new DuplicateSkillError('my-skill');
+     * // Error: skill 'my-skill' already exists
+     * // Code: DUPLICATE_SKILL
+     * ```
+     */
+    constructor(skillName: string);
+}
+/**
+ * Error thrown when a skill has invalid data.
+ *
+ * This error is thrown when a skill fails validation, typically due to
+ * missing required fields or invalid values.
+ *
+ * @example
+ * ```typescript
+ * if (!skill.name) {
+ *   throw new InvalidSkillError('Skill must have a valid name');
+ * }
+ * ```
+ */
+export declare class InvalidSkillError extends SequentialThinkingError {
+    /**
+     * Creates a new InvalidSkillError.
+     *
+     * @param reason - The reason for the validation failure
+     *
+     * @example
+     * ```typescript
+     * throw new InvalidSkillError('Skill must have a valid name');
+     * // Error: Invalid skill: Skill must have a valid name
+     * // Code: INVALID_SKILL
+     * ```
+     */
+    constructor(reason: string);
+}
+/**
+ * Error thrown when attempting to add a tool that already exists.
+ *
+ * This error is thrown when trying to register a tool with a name that
+ * is already present in the tool registry.
+ *
+ * @example
+ * ```typescript
+ * if (registry.hasTool(tool.name)) {
+ *   throw new DuplicateToolError(tool.name);
+ * }
+ * ```
+ */
+export declare class DuplicateToolError extends SequentialThinkingError {
+    /**
+     * Creates a new DuplicateToolError.
+     *
+     * @param toolName - The name of the duplicate tool
+     *
+     * @example
+     * ```typescript
+     * throw new DuplicateToolError('my-tool');
+     * // Error: tool 'my-tool' already exists
+     * // Code: DUPLICATE_TOOL
+     * ```
+     */
+    constructor(toolName: string);
+}
+/**
+ * Error thrown when a tool has invalid data.
+ *
+ * This error is thrown when a tool fails validation, typically due to
+ * missing required fields or invalid values.
+ *
+ * @example
+ * ```typescript
+ * if (!tool.name) {
+ *   throw new InvalidToolError('Tool must have a valid name');
+ * }
+ * ```
+ */
+export declare class InvalidToolError extends SequentialThinkingError {
+    /**
+     * Creates a new InvalidToolError.
+     *
+     * @param reason - The reason for the validation failure
+     *
+     * @example
+     * ```typescript
+     * throw new InvalidToolError('Tool must have a valid name');
+     * // Error: Invalid tool: Tool must have a valid name
+     * // Code: INVALID_TOOL
+     * ```
+     */
+    constructor(reason: string);
+}
+/**
+ * Error thrown when attempting to process a session that is not active.
+ *
+ * This error is thrown when trying to use a session that has been closed
+ * or deactivated.
+ *
+ * @example
+ * ```typescript
+ * if (!session.isActive) {
+ *   throw new SessionNotActiveError(sessionId);
+ * }
+ * ```
+ */
+export declare class SessionNotActiveError extends SequentialThinkingError {
+    /**
+     * Creates a new SessionNotActiveError.
+     *
+     * @param sessionId - The ID of the inactive session
+     *
+     * @example
+     * ```typescript
+     * throw new SessionNotActiveError('session-123');
+     * // Error: Session 'session-123' is not active
+     * // Code: SESSION_NOT_ACTIVE
+     * ```
+     */
+    constructor(sessionId: string);
+}
+/**
+ * Error thrown when a requested session is not found in the pool.
+ *
+ * This error is thrown when attempting to retrieve, process, or close
+ * a session that doesn't exist in the session pool.
+ *
+ * @example
+ * ```typescript
+ * const session = pool.getSession('non-existent-session');
+ * if (!session) {
+ *   throw new SessionNotFoundError('non-existent-session');
+ * }
+ * ```
+ */
+export declare class SessionNotFoundError extends SequentialThinkingError {
+    /**
+     * Creates a new SessionNotFoundError.
+     *
+     * @param sessionId - The ID of the session that was not found
+     *
+     * @example
+     * ```typescript
+     * throw new SessionNotFoundError('session-123');
+     * // Error: Session not found: session-123
+     * // Code: SESSION_NOT_FOUND
+     * ```
+     */
+    constructor(sessionId: string);
+}
+/**
+ * Error thrown when the maximum number of sessions has been reached.
+ *
+ * This error is thrown when trying to create a new session when the
+ * pool has reached its configured maximum session limit.
+ *
+ * @example
+ * ```typescript
+ * if (pool.sessionCount >= pool.maxSessions) {
+ *   throw new MaxSessionsReachedError(pool.maxSessions);
+ * }
+ * ```
+ */
+export declare class MaxSessionsReachedError extends SequentialThinkingError {
+    /**
+     * Creates a new MaxSessionsReachedError.
+     *
+     * @param maxSessions - The maximum number of sessions allowed
+     *
+     * @example
+     * ```typescript
+     * throw new MaxSessionsReachedError(100);
+     * // Error: Max sessions (100) reached. Wait for a session to close or increase maxSessions.
+     * // Code: MAX_SESSIONS_REACHED
+     * ```
+     */
+    constructor(maxSessions: number);
+}
+/**
+ * Error thrown when attempting to use a terminated connection pool.
+ *
+ * This error is thrown when trying to create sessions or process requests
+ * after the connection pool has been terminated.
+ *
+ * @example
+ * ```typescript
+ * if (pool.isTerminated) {
+ *   throw new PoolTerminatedError();
+ * }
+ * ```
+ */
+export declare class PoolTerminatedError extends SequentialThinkingError {
+    /**
+     * Creates a new PoolTerminatedError.
+     *
+     * @example
+     * ```typescript
+     * throw new PoolTerminatedError();
+     * // Error: ConnectionPool has been terminated
+     * // Code: POOL_TERMINATED
+     * ```
+     */
+    constructor();
+}
+/**
+ * Error thrown when input validation fails due to invalid or malicious data.
+ *
+ * This error is thrown when user input fails security or format validation,
+ * such as path traversal attempts or invalid identifier formats.
+ *
+ * @example
+ * ```typescript
+ * if (!BRANCH_ID_PATTERN.test(branchId)) {
+ *   throw new ValidationError('branchId', 'Invalid format');
+ * }
+ * ```
+ */
+export declare class ValidationError extends SequentialThinkingError {
+    /** The field that failed validation. */
+    readonly field: string;
+    constructor(field: string, reason: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;IACjD,sDAAsD;IACtD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;;;;;;;;;;;;;OAcG;gBACS,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAMzC;AAED,qBAAa,kBAAmB,SAAQ,uBAAuB;gBAClD,OAAO,EAAE,MAAM;CAI3B;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,iBAAkB,SAAQ,uBAAuB;IAC7D;;;;;;;;;;;;;;;OAeG;gBACS,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;CAO7C;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,kBAAmB,SAAQ,uBAAuB;IAC9D;;;;;;;;;;;;;;;OAeG;gBACS,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;CAO9C;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,mBAAoB,SAAQ,uBAAuB;IAC/D;;;;;;;;;;;;OAYG;gBACS,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAIjD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,mBAAoB,SAAQ,uBAAuB;IAC/D,8DAA8D;IAC9D,SAAyB,KAAK,EAAE,KAAK,CAAC;IAEtC;;;;;;;;;;;;;;OAcG;gBACS,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAK3C;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,yBAA0B,SAAQ,uBAAuB;IACrE;;;;;;;;;;;;OAYG;gBACS,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAIhD;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAoB,SAAQ,uBAAuB;IAC/D;;;;;;;;;;;OAWG;gBACS,SAAS,EAAE,MAAM;CAI7B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAkB,SAAQ,uBAAuB;IAC7D;;;;;;;;;;;OAWG;gBACS,MAAM,EAAE,MAAM;CAI1B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,kBAAmB,SAAQ,uBAAuB;IAC9D;;;;;;;;;;;OAWG;gBACS,QAAQ,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAiB,SAAQ,uBAAuB;IAC5D;;;;;;;;;;;OAWG;gBACS,MAAM,EAAE,MAAM;CAI1B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAsB,SAAQ,uBAAuB;IACjE;;;;;;;;;;;OAWG;gBACS,SAAS,EAAE,MAAM;CAI7B;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,oBAAqB,SAAQ,uBAAuB;IAChE;;;;;;;;;;;OAWG;gBACS,SAAS,EAAE,MAAM;CAI7B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,uBAAwB,SAAQ,uBAAuB;IACnE;;;;;;;;;;;OAWG;gBACS,WAAW,EAAE,MAAM;CAO/B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAoB,SAAQ,uBAAuB;IAC/D;;;;;;;;;OASG;;CAKH;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAgB,SAAQ,uBAAuB;IAC3D,wCAAwC;IACxC,SAAgB,KAAK,EAAE,MAAM,CAAC;gBAElB,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAKzC"}

package/dist/errors.js

@@ -0,0 +1,108 @@
+class SequentialThinkingError extends Error {
+    code;
+    constructor(message, code){
+        super(message);
+        this.code = code;
+        this.name = 'SequentialThinkingError';
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+class ConfigurationError extends SequentialThinkingError {
+    constructor(message){
+        super(message, 'CONFIGURATION_ERROR');
+        this.name = 'ConfigurationError';
+    }
+}
+class ToolNotFoundError extends SequentialThinkingError {
+    constructor(toolName, action){
+        const message = action ? `Tool '${toolName}' not found, cannot ${action}` : `Tool '${toolName}' not found`;
+        super(message, 'TOOL_NOT_FOUND');
+        this.name = 'ToolNotFoundError';
+    }
+}
+class SkillNotFoundError extends SequentialThinkingError {
+    constructor(skillName, action){
+        const message = action ? `Skill '${skillName}' not found, cannot ${action}` : `Skill '${skillName}' not found`;
+        super(message, 'SKILL_NOT_FOUND');
+        this.name = 'SkillNotFoundError';
+    }
+}
+class InvalidThoughtError extends SequentialThinkingError {
+    constructor(thoughtNumber, reason){
+        super(`Invalid thought ${thoughtNumber}: ${reason}`, 'INVALID_THOUGHT');
+        this.name = 'InvalidThoughtError';
+    }
+}
+class SkillDiscoveryError extends SequentialThinkingError {
+    cause;
+    constructor(directory, cause){
+        super(`Failed to discover skills in ${directory}: ${cause.message}`, 'SKILL_DISCOVERY_FAILED');
+        this.name = 'SkillDiscoveryError';
+        this.cause = cause;
+    }
+}
+class HistoryLimitExceededError extends SequentialThinkingError {
+    constructor(currentSize, maxSize){
+        super(`History size ${currentSize} exceeds limit ${maxSize}`, 'HISTORY_LIMIT_EXCEEDED');
+        this.name = 'HistoryLimitExceededError';
+    }
+}
+class DuplicateSkillError extends SequentialThinkingError {
+    constructor(skillName){
+        super(`skill '${skillName}' already exists`, 'DUPLICATE_SKILL');
+        this.name = 'DuplicateSkillError';
+    }
+}
+class InvalidSkillError extends SequentialThinkingError {
+    constructor(reason){
+        super(`Invalid skill: ${reason}`, 'INVALID_SKILL');
+        this.name = 'InvalidSkillError';
+    }
+}
+class DuplicateToolError extends SequentialThinkingError {
+    constructor(toolName){
+        super(`tool '${toolName}' already exists`, 'DUPLICATE_TOOL');
+        this.name = 'DuplicateToolError';
+    }
+}
+class InvalidToolError extends SequentialThinkingError {
+    constructor(reason){
+        super(`Invalid tool: ${reason}`, 'INVALID_TOOL');
+        this.name = 'InvalidToolError';
+    }
+}
+class SessionNotActiveError extends SequentialThinkingError {
+    constructor(sessionId){
+        super(`Session '${sessionId}' is not active`, 'SESSION_NOT_ACTIVE');
+        this.name = 'SessionNotActiveError';
+    }
+}
+class SessionNotFoundError extends SequentialThinkingError {
+    constructor(sessionId){
+        super(`Session not found: ${sessionId}`, 'SESSION_NOT_FOUND');
+        this.name = 'SessionNotFoundError';
+    }
+}
+class MaxSessionsReachedError extends SequentialThinkingError {
+    constructor(maxSessions){
+        super(`Max sessions (${maxSessions}) reached. Wait for a session to close or increase maxSessions.`, 'MAX_SESSIONS_REACHED');
+        this.name = 'MaxSessionsReachedError';
+    }
+}
+class PoolTerminatedError extends SequentialThinkingError {
+    constructor(){
+        super('ConnectionPool has been terminated', 'POOL_TERMINATED');
+        this.name = 'PoolTerminatedError';
+    }
+}
+class ValidationError extends SequentialThinkingError {
+    field;
+    constructor(field, reason){
+        super(`Validation failed for '${field}': ${reason}`, 'VALIDATION_ERROR');
+        this.name = 'ValidationError';
+        this.field = field;
+    }
+}
+export { ConfigurationError, DuplicateSkillError, DuplicateToolError, HistoryLimitExceededError, InvalidSkillError, InvalidThoughtError, InvalidToolError, MaxSessionsReachedError, PoolTerminatedError, SequentialThinkingError, SessionNotActiveError, SessionNotFoundError, SkillDiscoveryError, SkillNotFoundError, ToolNotFoundError, ValidationError };
+
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../src/errors.ts"],"sourcesContent":["/**\n * Custom error types for the TraceLattice server.\n *\n * This module defines a hierarchy of error classes for handling various\n * error conditions that can occur in the sequential thinking server.\n * All errors extend the base `SequentialThinkingError` class with\n * specific error codes for programmatic handling.\n *\n * @example\n * ```typescript\n * import { ToolNotFoundError, SkillDiscoveryError } from './errors.js';\n *\n * // Throw a tool not found error\n * throw new ToolNotFoundError('my-tool');\n *\n * // Catch and handle specific errors\n * try {\n *   await discoverSkills(dir);\n * } catch (error) {\n *   if (error instanceof SkillDiscoveryError) {\n *     console.error(`Failed to discover skills: ${error.message}`);\n *     console.error(`Error code: ${error.code}`);\n *   }\n * }\n * ```\n * @module errors\n */\n\n/**\n * Base error class for all Sequential Thinking server errors.\n *\n * This error extends the native `Error` class and adds a `code` property\n * for programmatic error identification and handling. All specific error\n * types in the system extend this base class.\n *\n * @remarks\n * **Error Codes:**\n * - `TOOL_NOT_FOUND` - A requested tool was not found\n * - `SKILL_NOT_FOUND` - A requested skill was not found\n * - `INVALID_THOUGHT` - Thought validation failed\n * - `SKILL_DISCOVERY_FAILED` - Skill discovery operation failed\n * - `HISTORY_LIMIT_EXCEEDED` - History size limit was exceeded\n *\n * @example\n * ```typescript\n * // Throw a custom sequential thinking error\n * throw new SequentialThinkingError('Custom error message', 'CUSTOM_CODE');\n *\n * // Check if an error is a SequentialThinkingError\n * if (error instanceof SequentialThinkingError) {\n *   console.error(`Error [${error.code}]: ${error.message}`);\n * }\n * ```\n */\nexport class SequentialThinkingError extends Error {\n\t/** The error code for programmatic identification. */\n\tpublic readonly code: string;\n\n\t/**\n\t * Creates a new SequentialThinkingError.\n\t *\n\t * @param message - Human-readable error message\n\t * @param code - Error code for programmatic handling\n\t *\n\t * @example\n\t * ```typescript\n\t * const error = new SequentialThinkingError(\n\t *   'Something went wrong',\n\t *   'CUSTOM_ERROR'\n\t * );\n\t * console.log(error.code); // 'CUSTOM_ERROR'\n\t * ```\n\t */\n\tconstructor(message: string, code: string) {\n\t\tsuper(message);\n\t\tthis.code = code;\n\t\tthis.name = 'SequentialThinkingError';\n\t\tError.captureStackTrace(this, this.constructor);\n\t}\n}\n\nexport class ConfigurationError extends SequentialThinkingError {\n\tconstructor(message: string) {\n\t\tsuper(message, 'CONFIGURATION_ERROR');\n\t\tthis.name = 'ConfigurationError';\n\t}\n}\n\n/**\n * Error thrown when a requested tool is not found in the registry.\n *\n * This error is thrown when attempting to retrieve, update, or delete\n * a tool that doesn't exist in the tool registry.\n *\n * @example\n * ```typescript\n * const tool = registry.getTool('non-existent-tool');\n * if (!tool) {\n *   throw new ToolNotFoundError('non-existent-tool');\n * }\n * ```\n */\nexport class ToolNotFoundError extends SequentialThinkingError {\n\t/**\n\t * Creates a new ToolNotFoundError.\n\t *\n\t * @param toolName - The name of the tool that was not found\n\t * @param action - Optional action being performed (e.g., 'remove', 'update')\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new ToolNotFoundError('my-custom-tool');\n\t * // Error: tool 'my-custom-tool' not found\n\t *\n\t * throw new ToolNotFoundError('my-custom-tool', 'remove');\n\t * // Error: tool 'my-custom-tool' not found, cannot remove\n\t * // Code: TOOL_NOT_FOUND\n\t * ```\n\t */\n\tconstructor(toolName: string, action?: string) {\n\t\tconst message = action\n\t\t\t? `Tool '${toolName}' not found, cannot ${action}`\n\t\t\t: `Tool '${toolName}' not found`;\n\t\tsuper(message, 'TOOL_NOT_FOUND');\n\t\tthis.name = 'ToolNotFoundError';\n\t}\n}\n\n/**\n * Error thrown when a requested skill is not found in the registry.\n *\n * This error is thrown when attempting to retrieve, update, or delete\n * a skill that doesn't exist in the skill registry.\n *\n * @example\n * ```typescript\n * const skill = registry.getSkill('non-existent-skill');\n * if (!skill) {\n *   throw new SkillNotFoundError('non-existent-skill');\n * }\n * ```\n */\nexport class SkillNotFoundError extends SequentialThinkingError {\n\t/**\n\t * Creates a new SkillNotFoundError.\n\t *\n\t * @param skillName - The name of the skill that was not found\n\t * @param action - Optional action being performed (e.g., 'remove', 'update')\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new SkillNotFoundError('my-custom-skill');\n\t * // Error: skill 'my-custom-skill' not found\n\t *\n\t * throw new SkillNotFoundError('my-custom-skill', 'remove');\n\t * // Error: skill 'my-custom-skill' not found, cannot remove\n\t * // Code: SKILL_NOT_FOUND\n\t * ```\n\t */\n\tconstructor(skillName: string, action?: string) {\n\t\tconst message = action\n\t\t\t? `Skill '${skillName}' not found, cannot ${action}`\n\t\t\t: `Skill '${skillName}' not found`;\n\t\tsuper(message, 'SKILL_NOT_FOUND');\n\t\tthis.name = 'SkillNotFoundError';\n\t}\n}\n\n/**\n * Error thrown when thought validation fails.\n *\n * This error is thrown when a thought fails validation, typically due to\n * invalid values, missing required fields, or constraint violations.\n *\n * @example\n * ```typescript\n * // Validate thought number\n * if (thought.thought_number < 1) {\n *   throw new InvalidThoughtError(thought.thought_number, 'thought_number must be >= 1');\n * }\n * ```\n */\nexport class InvalidThoughtError extends SequentialThinkingError {\n\t/**\n\t * Creates a new InvalidThoughtError.\n\t *\n\t * @param thoughtNumber - The thought number that failed validation\n\t * @param reason - Human-readable explanation of why validation failed\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new InvalidThoughtError(5, 'thought_number exceeds total_thoughts');\n\t * // Error: Invalid thought 5: thought_number exceeds total_thoughts\n\t * // Code: INVALID_THOUGHT\n\t * ```\n\t */\n\tconstructor(thoughtNumber: number, reason: string) {\n\t\tsuper(`Invalid thought ${thoughtNumber}: ${reason}`, 'INVALID_THOUGHT');\n\t\tthis.name = 'InvalidThoughtError';\n\t}\n}\n\n/**\n * Error thrown when skill discovery fails.\n *\n * This error is thrown when the skill discovery process encounters an issue,\n * such as filesystem errors, invalid skill files, or parsing failures.\n *\n * @remarks\n * The original error that caused the discovery failure is preserved in the\n * `cause` property for debugging purposes.\n *\n * @example\n * ```typescript\n * try {\n *   await discoverSkills('./skills');\n * } catch (error) {\n *   throw new SkillDiscoveryError('./skills', error as Error);\n * }\n * ```\n */\nexport class SkillDiscoveryError extends SequentialThinkingError {\n\t/** The underlying error that caused the discovery failure. */\n\tpublic override readonly cause: Error;\n\n\t/**\n\t * Creates a new SkillDiscoveryError.\n\t *\n\t * @param directory - The directory where discovery failed\n\t * @param cause - The underlying error that caused the failure\n\t *\n\t * @example\n\t * ```typescript\n\t * try {\n\t *   const skills = await loadSkills('./invalid-directory');\n\t * } catch (error) {\n\t *   throw new SkillDiscoveryError('./invalid-directory', error as Error);\n\t * }\n\t * ```\n\t */\n\tconstructor(directory: string, cause: Error) {\n\t\tsuper(`Failed to discover skills in ${directory}: ${cause.message}`, 'SKILL_DISCOVERY_FAILED');\n\t\tthis.name = 'SkillDiscoveryError';\n\t\tthis.cause = cause;\n\t}\n}\n\n/**\n * Error thrown when history size exceeds the configured limit.\n *\n * This error is thrown when an operation would cause the history size\n * to exceed the maximum configured size limit.\n *\n * @example\n * ```typescript\n * if (history.length >= maxSize) {\n *   throw new HistoryLimitExceededError(history.length, maxSize);\n * }\n * ```\n */\nexport class HistoryLimitExceededError extends SequentialThinkingError {\n\t/**\n\t * Creates a new HistoryLimitExceededError.\n\t *\n\t * @param currentSize - The current history size\n\t * @param maxSize - The maximum allowed size\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new HistoryLimitExceededError(1500, 1000);\n\t * // Error: History size 1500 exceeds limit 1000\n\t * // Code: HISTORY_LIMIT_EXCEEDED\n\t * ```\n\t */\n\tconstructor(currentSize: number, maxSize: number) {\n\t\tsuper(`History size ${currentSize} exceeds limit ${maxSize}`, 'HISTORY_LIMIT_EXCEEDED');\n\t\tthis.name = 'HistoryLimitExceededError';\n\t}\n}\n\n/**\n * Error thrown when attempting to add a skill that already exists.\n *\n * This error is thrown when trying to register a skill with a name that\n * is already present in the skill registry.\n *\n * @example\n * ```typescript\n * if (registry.hasSkill(skill.name)) {\n *   throw new DuplicateSkillError(skill.name);\n * }\n * ```\n */\nexport class DuplicateSkillError extends SequentialThinkingError {\n\t/**\n\t * Creates a new DuplicateSkillError.\n\t *\n\t * @param skillName - The name of the duplicate skill\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new DuplicateSkillError('my-skill');\n\t * // Error: skill 'my-skill' already exists\n\t * // Code: DUPLICATE_SKILL\n\t * ```\n\t */\n\tconstructor(skillName: string) {\n\t\tsuper(`skill '${skillName}' already exists`, 'DUPLICATE_SKILL');\n\t\tthis.name = 'DuplicateSkillError';\n\t}\n}\n\n/**\n * Error thrown when a skill has invalid data.\n *\n * This error is thrown when a skill fails validation, typically due to\n * missing required fields or invalid values.\n *\n * @example\n * ```typescript\n * if (!skill.name) {\n *   throw new InvalidSkillError('Skill must have a valid name');\n * }\n * ```\n */\nexport class InvalidSkillError extends SequentialThinkingError {\n\t/**\n\t * Creates a new InvalidSkillError.\n\t *\n\t * @param reason - The reason for the validation failure\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new InvalidSkillError('Skill must have a valid name');\n\t * // Error: Invalid skill: Skill must have a valid name\n\t * // Code: INVALID_SKILL\n\t * ```\n\t */\n\tconstructor(reason: string) {\n\t\tsuper(`Invalid skill: ${reason}`, 'INVALID_SKILL');\n\t\tthis.name = 'InvalidSkillError';\n\t}\n}\n\n/**\n * Error thrown when attempting to add a tool that already exists.\n *\n * This error is thrown when trying to register a tool with a name that\n * is already present in the tool registry.\n *\n * @example\n * ```typescript\n * if (registry.hasTool(tool.name)) {\n *   throw new DuplicateToolError(tool.name);\n * }\n * ```\n */\nexport class DuplicateToolError extends SequentialThinkingError {\n\t/**\n\t * Creates a new DuplicateToolError.\n\t *\n\t * @param toolName - The name of the duplicate tool\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new DuplicateToolError('my-tool');\n\t * // Error: tool 'my-tool' already exists\n\t * // Code: DUPLICATE_TOOL\n\t * ```\n\t */\n\tconstructor(toolName: string) {\n\t\tsuper(`tool '${toolName}' already exists`, 'DUPLICATE_TOOL');\n\t\tthis.name = 'DuplicateToolError';\n\t}\n}\n\n/**\n * Error thrown when a tool has invalid data.\n *\n * This error is thrown when a tool fails validation, typically due to\n * missing required fields or invalid values.\n *\n * @example\n * ```typescript\n * if (!tool.name) {\n *   throw new InvalidToolError('Tool must have a valid name');\n * }\n * ```\n */\nexport class InvalidToolError extends SequentialThinkingError {\n\t/**\n\t * Creates a new InvalidToolError.\n\t *\n\t * @param reason - The reason for the validation failure\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new InvalidToolError('Tool must have a valid name');\n\t * // Error: Invalid tool: Tool must have a valid name\n\t * // Code: INVALID_TOOL\n\t * ```\n\t */\n\tconstructor(reason: string) {\n\t\tsuper(`Invalid tool: ${reason}`, 'INVALID_TOOL');\n\t\tthis.name = 'InvalidToolError';\n\t}\n}\n\n/**\n * Error thrown when attempting to process a session that is not active.\n *\n * This error is thrown when trying to use a session that has been closed\n * or deactivated.\n *\n * @example\n * ```typescript\n * if (!session.isActive) {\n *   throw new SessionNotActiveError(sessionId);\n * }\n * ```\n */\nexport class SessionNotActiveError extends SequentialThinkingError {\n\t/**\n\t * Creates a new SessionNotActiveError.\n\t *\n\t * @param sessionId - The ID of the inactive session\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new SessionNotActiveError('session-123');\n\t * // Error: Session 'session-123' is not active\n\t * // Code: SESSION_NOT_ACTIVE\n\t * ```\n\t */\n\tconstructor(sessionId: string) {\n\t\tsuper(`Session '${sessionId}' is not active`, 'SESSION_NOT_ACTIVE');\n\t\tthis.name = 'SessionNotActiveError';\n\t}\n}\n\n/**\n * Error thrown when a requested session is not found in the pool.\n *\n * This error is thrown when attempting to retrieve, process, or close\n * a session that doesn't exist in the session pool.\n *\n * @example\n * ```typescript\n * const session = pool.getSession('non-existent-session');\n * if (!session) {\n *   throw new SessionNotFoundError('non-existent-session');\n * }\n * ```\n */\nexport class SessionNotFoundError extends SequentialThinkingError {\n\t/**\n\t * Creates a new SessionNotFoundError.\n\t *\n\t * @param sessionId - The ID of the session that was not found\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new SessionNotFoundError('session-123');\n\t * // Error: Session not found: session-123\n\t * // Code: SESSION_NOT_FOUND\n\t * ```\n\t */\n\tconstructor(sessionId: string) {\n\t\tsuper(`Session not found: ${sessionId}`, 'SESSION_NOT_FOUND');\n\t\tthis.name = 'SessionNotFoundError';\n\t}\n}\n\n/**\n * Error thrown when the maximum number of sessions has been reached.\n *\n * This error is thrown when trying to create a new session when the\n * pool has reached its configured maximum session limit.\n *\n * @example\n * ```typescript\n * if (pool.sessionCount >= pool.maxSessions) {\n *   throw new MaxSessionsReachedError(pool.maxSessions);\n * }\n * ```\n */\nexport class MaxSessionsReachedError extends SequentialThinkingError {\n\t/**\n\t * Creates a new MaxSessionsReachedError.\n\t *\n\t * @param maxSessions - The maximum number of sessions allowed\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new MaxSessionsReachedError(100);\n\t * // Error: Max sessions (100) reached. Wait for a session to close or increase maxSessions.\n\t * // Code: MAX_SESSIONS_REACHED\n\t * ```\n\t */\n\tconstructor(maxSessions: number) {\n\t\tsuper(\n\t\t\t`Max sessions (${maxSessions}) reached. Wait for a session to close or increase maxSessions.`,\n\t\t\t'MAX_SESSIONS_REACHED'\n\t\t);\n\t\tthis.name = 'MaxSessionsReachedError';\n\t}\n}\n\n/**\n * Error thrown when attempting to use a terminated connection pool.\n *\n * This error is thrown when trying to create sessions or process requests\n * after the connection pool has been terminated.\n *\n * @example\n * ```typescript\n * if (pool.isTerminated) {\n *   throw new PoolTerminatedError();\n * }\n * ```\n */\nexport class PoolTerminatedError extends SequentialThinkingError {\n\t/**\n\t * Creates a new PoolTerminatedError.\n\t *\n\t * @example\n\t * ```typescript\n\t * throw new PoolTerminatedError();\n\t * // Error: ConnectionPool has been terminated\n\t * // Code: POOL_TERMINATED\n\t * ```\n\t */\n\tconstructor() {\n\t\tsuper('ConnectionPool has been terminated', 'POOL_TERMINATED');\n\t\tthis.name = 'PoolTerminatedError';\n\t}\n}\n\n/**\n * Error thrown when input validation fails due to invalid or malicious data.\n *\n * This error is thrown when user input fails security or format validation,\n * such as path traversal attempts or invalid identifier formats.\n *\n * @example\n * ```typescript\n * if (!BRANCH_ID_PATTERN.test(branchId)) {\n *   throw new ValidationError('branchId', 'Invalid format');\n * }\n * ```\n */\nexport class ValidationError extends SequentialThinkingError {\n\t/** The field that failed validation. */\n\tpublic readonly field: string;\n\n\tconstructor(field: string, reason: string) {\n\t\tsuper(`Validation failed for '${field}': ${reason}`, 'VALIDATION_ERROR');\n\t\tthis.name = 'ValidationError';\n\t\tthis.field = field;\n\t}\n}\n"],"names":["SequentialThinkingError","Error","message","code","ConfigurationError","ToolNotFoundError","toolName","action","SkillNotFoundError","skillName","InvalidThoughtError","thoughtNumber","reason","SkillDiscoveryError","directory","cause","HistoryLimitExceededError","currentSize","maxSize","DuplicateSkillError","InvalidSkillError","DuplicateToolError","InvalidToolError","SessionNotActiveError","sessionId","SessionNotFoundError","MaxSessionsReachedError","maxSessions","PoolTerminatedError","ValidationError","field"],"mappings":"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"}