indusagi 0.13.6 → 0.13.7

package/dist/types/facade/mcp-core/errors.d.ts

@@ -1,103 +0,0 @@
-/**
- * MCP Error Types
- *
- * Reference: structured MCP error handling patterns.
- */
-/**
- * Error codes for MCP operations.
- */
-export declare enum MCPErrorCode {
-    /** Failed to connect to MCP server */
-    CONNECTION_FAILED = "CONNECTION_FAILED",
-    /** Request timed out */
-    TIMEOUT = "TIMEOUT",
-    /** Tool not found on server */
-    TOOL_NOT_FOUND = "TOOL_NOT_FOUND",
-    /** Invalid parameters for tool call */
-    INVALID_PARAMETERS = "INVALID_PARAMETERS",
-    /** Server returned an error */
-    SERVER_ERROR = "SERVER_ERROR",
-    /** Transport layer error */
-    TRANSPORT_ERROR = "TRANSPORT_ERROR",
-    /** Not connected to server */
-    NOT_CONNECTED = "NOT_CONNECTED",
-    /** Protocol error */
-    PROTOCOL_ERROR = "PROTOCOL_ERROR",
-    /** Configuration error */
-    CONFIG_ERROR = "CONFIG_ERROR",
-    /** Schema conversion error */
-    SCHEMA_CONVERSION_ERROR = "SCHEMA_CONVERSION_ERROR",
-    /** Resource not found */
-    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
-    /** Prompt not found */
-    PROMPT_NOT_FOUND = "PROMPT_NOT_FOUND",
-    /** Session error (requires reconnection) */
-    SESSION_ERROR = "SESSION_ERROR"
-}
-/**
- * Error class for MCP operations.
- * Provides structured error information with error codes and details.
- */
-export declare class MCPError extends Error {
-    /** Error code */
-    readonly code: MCPErrorCode;
-    /** Additional error details */
-    readonly details?: unknown;
-    /** Server name where error occurred */
-    readonly serverName?: string;
-    /** Tool name if error occurred during tool execution */
-    readonly toolName?: string;
-    constructor(message: string, code: MCPErrorCode, details?: unknown, options?: {
-        serverName?: string;
-        toolName?: string;
-        cause?: Error;
-    });
-    /**
-     * Convert error to JSON for logging/serialization.
-     */
-    toJSON(): Record<string, unknown>;
-    /**
-     * Create a string representation of the error.
-     */
-    toString(): string;
-}
-/**
- * Type guard to check if an error is an MCPError.
- */
-export declare function isMCPError(error: unknown): error is MCPError;
-/**
- * Check if an error indicates a session problem requiring reconnection.
- */
-export declare function isSessionError(error: unknown): boolean;
-/**
- * Create a connection failed error.
- */
-export declare function createConnectionError(serverName: string, cause?: Error): MCPError;
-/**
- * Create a timeout error.
- */
-export declare function createTimeoutError(operation: string, serverName?: string): MCPError;
-/**
- * Create a tool not found error.
- */
-export declare function createToolNotFoundError(toolName: string, serverName?: string): MCPError;
-/**
- * Create an invalid parameters error.
- */
-export declare function createInvalidParametersError(toolName: string, details: unknown, serverName?: string): MCPError;
-/**
- * Create a server error.
- */
-export declare function createServerError(message: string, serverName?: string, details?: unknown): MCPError;
-/**
- * Create a not connected error.
- */
-export declare function createNotConnectedError(serverName?: string): MCPError;
-/**
- * Create a config error.
- */
-export declare function createConfigError(message: string, details?: unknown): MCPError;
-/**
- * Create a schema conversion error.
- */
-export declare function createSchemaConversionError(toolName: string, details: unknown, serverName?: string): MCPError;

package/dist/types/facade/mcp-core/index.d.ts

@@ -1,55 +0,0 @@
-/**
- * MCP Module - Public Exports
- *
- * This module provides Model Context Protocol (MCP) support for new_indusvx.
- * It allows connecting to MCP servers and using their tools as AgentTools.
- *
- * @example
- * ```typescript
- * import { MCPClient, MCPClientPool, loadMCPConfig } from "new_indusvx/mcp";
- * import { ToolRegistry } from "new_indusvx/agent";
- *
- * // Load config from file
- * const configs = loadMCPConfig(process.cwd());
- *
- * // Create a client pool
- * const pool = new MCPClientPool({ servers: configs });
- * await pool.connectAll();
- *
- * // Register tools
- * const registry = new ToolRegistry();
- * for (const client of pool.getAllClients()) {
- *   const tools = await client.listTools();
- *   await registerMCPToolsInRegistry(registry, client, tools);
- * }
- * ```
- */
-import { MCPClientPool } from "./client-pool.js";
-export { MCPClient, type MCPClientOptions } from "./client.js";
-export { MCPClientPool, type MCPClientPoolOptions, type MCPServerStatus } from "./client-pool.js";
-export { MCPServer, createMCPServer, type MCPServerOptions } from "./server.js";
-export { createMCPAgentToolFactory, registerMCPToolsInRegistry, createMCPToolsMap, createMCPToolsRecord, type MCPToolClient, } from "./tool-factory.js";
-export { jsonSchemaToTypeBox, applyPassthrough, convertMCPInputSchema, convertMCPOutputSchema, } from "./schema-converter.js";
-export { loadMCPConfig, getUserConfigPath, getProjectConfigPath, ensureUserConfigDir, ensureProjectConfigDir, saveConfig, saveUserConfig, saveProjectConfig, createDefaultConfig, EXAMPLE_CONFIG, } from "./config.js";
-export { MCPError, MCPErrorCode, isMCPError, isSessionError, createConnectionError, createTimeoutError, createToolNotFoundError, createInvalidParametersError, createServerError, createNotConnectedError, createConfigError, createSchemaConversionError, } from "./errors.js";
-export type { StdioServerConfig, HttpServerConfig, MCPServerConfig, MCPConnectionOptions, MCPToolDefinition, MCPResource, MCPPrompt, MCPInitializeResult, MCPClientState, MCPToolCallRequest, MCPContentBlock, MCPToolCallResult, MCPServerConfigEntry, MCPConfigFile, MCPLoggingLevel, MCPLogMessage, MCPLogHandler, MCPProgressNotification, MCPProgressHandler, MCPElicitRequest, MCPElicitResult, MCPElicitationHandler, MCPRoot, BaseServerOptions, } from "./types.js";
-/**
- * Convenience function: Initialize MCP and register tools.
- *
- * This is the simplest way to add MCP support to an agent.
- *
- * @example
- * ```typescript
- * import { initializeMCP } from "new_indusvx/mcp";
- * import { ToolRegistry, Agent } from "new_indusvx/agent";
- *
- * const registry = new ToolRegistry();
- * const { pool, toolCount } = await initializeMCP(registry, process.cwd());
- *
- * console.log(`Connected to ${pool.getAllClients().length} servers with ${toolCount} tools`);
- * ```
- */
-export declare function initializeMCP(registry: import("../bot/actions/registry.js").ToolRegistry, cwd?: string): Promise<{
-    pool: MCPClientPool;
-    toolCount: number;
-}>;

package/dist/types/facade/mcp-core/schema-converter.d.ts

@@ -1,67 +0,0 @@
-/**
- * JSON Schema to TypeBox Converter
- *
- * Converts MCP tool schemas (JSON Schema) to TypeBox schemas
- * for validation in new_indusvx.
- *
- * Reference: JSON Schema conversion adapted to TypeBox.
- */
-import { type TSchema } from "@sinclair/typebox";
-/**
- * JSON Schema types we support
- */
-interface JSONSchema {
-    type?: string | string[];
-    description?: string;
-    properties?: Record<string, JSONSchema>;
-    required?: string[];
-    items?: JSONSchema | JSONSchema[];
-    enum?: (string | number | boolean | null)[];
-    const?: string | number | boolean | null;
-    additionalProperties?: boolean | JSONSchema;
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: number | boolean;
-    exclusiveMaximum?: number | boolean;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: string;
-    minItems?: number;
-    maxItems?: number;
-    multipleOf?: number;
-    default?: unknown;
-    oneOf?: JSONSchema[];
-    anyOf?: JSONSchema[];
-    allOf?: JSONSchema[];
-    $ref?: string;
-}
-/**
- * Convert JSON Schema to TypeBox schema.
- *
- * Handles:
- * - Primitive types (string, number, boolean, null)
- * - Objects with properties
- * - Arrays with items
- * - Optional fields (not in required array)
- * - Enums
- * - Nested structures
- */
-export declare function jsonSchemaToTypeBox(schema: JSONSchema): TSchema;
-/**
- * Apply passthrough to allow extra properties.
- *
- * MCP servers may return extra fields not in the schema,
- * so we use passthrough to avoid validation errors.
- */
-export declare function applyPassthrough(schema: TSchema): TSchema;
-/**
- * Convert MCP tool inputSchema to TypeBox with passthrough.
- * This is the main entry point for converting MCP tool schemas.
- */
-export declare function convertMCPInputSchema(inputSchema: Record<string, unknown>): TSchema;
-/**
- * Convert MCP tool outputSchema to TypeBox with passthrough.
- */
-export declare function convertMCPOutputSchema(outputSchema: Record<string, unknown> | undefined): TSchema | undefined;
-export {};

package/dist/types/facade/mcp-core/server.d.ts

@@ -1,110 +0,0 @@
-/**
- * MCP Server
- *
- * Exposes new_indusvx tools as an MCP server.
- * Compatible with Claude Desktop, Cursor, etc.
- *
- * Reference: MCP server implementation patterns.
- */
-import type { AgentTool } from "../bot/types.js";
-/**
- * Options for creating an MCP server.
- */
-export interface MCPServerOptions {
-    /** Server name */
-    name: string;
-    /** Server version */
-    version?: string;
-    /** Tools to expose */
-    tools: AgentTool<any>[];
-    /** Optional description */
-    description?: string;
-}
-/**
- * Tool converted for MCP protocol.
- */
-interface MCPConvertedTool {
-    name: string;
-    description?: string;
-    inputSchema: Record<string, unknown>;
-    outputSchema?: Record<string, unknown>;
-    execute: (args: Record<string, unknown>) => Promise<unknown>;
-}
-/**
- * MCP Server - exposes new_indusvx tools via the Model Context Protocol.
- *
- * Supports stdio transport for subprocess communication.
- *
- * @example
- * ```typescript
- * import { MCPServer } from "new_indusvx/mcp";
- * import { createBashTool } from "new_indusvx/agent/tools";
- *
- * const server = new MCPServer({
- *   name: "My Tools Server",
- *   version: "1.0.0",
- *   tools: [createBashTool()],
- * });
- *
- * await server.startStdio();
- * ```
- */
-export declare class MCPServer {
-    private options;
-    private tools;
-    private buffer;
-    private isConnected;
-    /** Server name */
-    readonly name: string;
-    /** Server version */
-    readonly version: string;
-    constructor(options: MCPServerOptions);
-    /**
-     * Start the server using stdio transport.
-     *
-     * This is typically used when running the server as a subprocess
-     * that MCP clients (like Claude Desktop) spawn.
-     */
-    startStdio(): Promise<void>;
-    /**
-     * Stop the server.
-     */
-    stop(): Promise<void>;
-    /**
-     * Add a tool to the server.
-     */
-    addTool(tool: AgentTool<any>): void;
-    /**
-     * Remove a tool from the server.
-     */
-    removeTool(name: string): boolean;
-    /**
-     * List all available tools.
-     */
-    listTools(): MCPConvertedTool[];
-    private convertTool;
-    private typeBoxToJsonSchema;
-    private processBuffer;
-    private handleMessage;
-    private handleRequest;
-    private handleInitialize;
-    private handleToolsList;
-    private handleToolsCall;
-    private sendResponse;
-    private sendError;
-}
-/**
- * Create an MCP server from tools.
- *
- * @example
- * ```typescript
- * const server = createMCPServer({
- *   name: "My Tools",
- *   tools: [bashTool, readTool, writeTool],
- * });
- *
- * await server.startStdio();
- * ```
- */
-export declare function createMCPServer(options: MCPServerOptions): MCPServer;
-export {};

package/dist/types/facade/mcp-core/tool-factory.d.ts

@@ -1,62 +0,0 @@
-/**
- * MCP Tool Factory
- *
- * Creates AgentTool instances from MCP tool definitions.
- * Uses the factory pattern to match new_indusvx's ToolRegistry.
- *
- * Reference: MCP tool factory integration patterns.
- */
-import type { TSchema } from "@sinclair/typebox";
-import type { AgentTool } from "../bot/types.js";
-import type { MCPToolDefinition, MCPToolCallResult } from "./types.js";
-/**
- * Interface for MCP client that can call tools.
- */
-export interface MCPToolClient {
-    /** Server name */
-    readonly serverName: string;
-    /** Whether client is connected */
-    readonly connected: boolean;
-    /** Call a tool on the MCP server */
-    callTool(name: string, args: Record<string, unknown>): Promise<MCPToolCallResult>;
-}
-/**
- * Create an AgentTool from an MCP tool definition.
- *
- * This function creates a factory that matches ToolRegistry's pattern.
- * The tool is namespaced with the server name to avoid conflicts.
- *
- * @param mcpTool - MCP tool definition from the server
- * @param client - MCP client to use for tool execution
- * @returns Factory function that creates an AgentTool
- */
-export declare function createMCPAgentToolFactory(mcpTool: MCPToolDefinition, client: MCPToolClient): () => AgentTool<TSchema, MCPToolCallResult>;
-/**
- * Register all MCP tools from a client into a ToolRegistry.
- *
- * This is the main integration point with new_indusvx's ToolRegistry.
- *
- * @param registry - ToolRegistry instance to register tools into
- * @param client - MCP client with tools to register
- * @param tools - List of tool definitions from the server
- * @returns Number of tools registered
- */
-export declare function registerMCPToolsInRegistry(registry: import("../bot/actions/registry.js").ToolRegistry, client: MCPToolClient, tools: MCPToolDefinition[]): Promise<number>;
-/**
- * Create a map of AgentTools from MCP tool definitions.
- * Useful when you don't want to use the registry pattern.
- *
- * @param tools - List of tool definitions from the server
- * @param client - MCP client to use for tool execution
- * @returns Map of namespaced tool names to AgentTool instances
- */
-export declare function createMCPToolsMap(tools: MCPToolDefinition[], client: MCPToolClient): Map<string, AgentTool<TSchema, MCPToolCallResult>>;
-/**
- * Create a record of AgentTools from MCP tool definitions.
- * Matches the format expected by Agent's tools property.
- *
- * @param tools - List of tool definitions from the server
- * @param client - MCP client to use for tool execution
- * @returns Record of namespaced tool names to AgentTool instances
- */
-export declare function createMCPToolsRecord(tools: MCPToolDefinition[], client: MCPToolClient): Record<string, AgentTool<TSchema, MCPToolCallResult>>;

package/dist/types/facade/mcp-core/types.d.ts

@@ -1,298 +0,0 @@
-/**
- * MCP Type Definitions
- *
- * Aligned with Model Context Protocol specification
- * Reference: MCP client type definitions.
- */
-/**
- * Configuration for MCP servers using stdio (subprocess) transport.
- * Used when the MCP server is spawned as a subprocess that communicates via stdin/stdout.
- */
-export interface StdioServerConfig {
-    /** Command to execute (e.g., 'node', 'python', 'npx') */
-    command: string;
-    /** Optional arguments to pass to the command */
-    args?: string[];
-    /** Optional environment variables for the subprocess */
-    env?: Record<string, string>;
-    /** Optional working directory for the subprocess */
-    cwd?: string;
-}
-/**
- * Configuration for MCP servers using HTTP-based transport (Streamable HTTP or SSE fallback).
- * Used when connecting to remote MCP servers over HTTP.
- */
-export interface HttpServerConfig {
-    /** URL of the MCP server endpoint */
-    url: URL;
-    /** Optional headers for HTTP requests */
-    headers?: Record<string, string>;
-    /**
-     * Which HTTP transport to use.
-     *  - "http" (default): Streamable HTTP (single endpoint, server-push channel)
-     *  - "sse": legacy HTTP+SSE transport
-     */
-    transport?: "http" | "sse";
-    /** Custom fetch implementation */
-    fetch?: typeof fetch;
-}
-/**
- * Configuration for connecting to an MCP server.
- * Either stdio-based (subprocess) or HTTP-based (remote server).
- */
-export type MCPServerConfig = StdioServerConfig | HttpServerConfig;
-/**
- * Options for establishing an MCP connection.
- */
-export interface MCPConnectionOptions {
-    /** Unique name for this server connection */
-    name: string;
-    /** Server configuration (stdio or HTTP) */
-    config: MCPServerConfig;
-    /** Optional timeout in milliseconds */
-    timeout?: number;
-}
-/**
- * Definition of a tool exposed by an MCP server.
- */
-export interface MCPToolDefinition {
-    /** Tool name */
-    name: string;
-    /** Human-readable description */
-    description?: string;
-    /** JSON Schema for input parameters */
-    inputSchema: Record<string, unknown>;
-    /** Optional JSON Schema for output */
-    outputSchema?: Record<string, unknown>;
-}
-/**
- * Resource exposed by an MCP server.
- */
-export interface MCPResource {
-    /** Unique URI for this resource */
-    uri: string;
-    /** Human-readable name */
-    name?: string;
-    /** MIME type of the resource content */
-    mimeType?: string;
-    /** Description of the resource */
-    description?: string;
-}
-/**
- * Prompt template exposed by an MCP server.
- */
-export interface MCPPrompt {
-    /** Prompt name */
-    name: string;
-    /** Human-readable description */
-    description?: string;
-    /** Arguments the prompt accepts */
-    arguments?: Array<{
-        name: string;
-        description?: string;
-        required?: boolean;
-    }>;
-}
-/**
- * Result of MCP server initialization.
- */
-export interface MCPInitializeResult {
-    /** Protocol version supported by the server */
-    protocolVersion: string;
-    /** Server information */
-    serverInfo: {
-        name: string;
-        version?: string;
-    };
-    /** Server capabilities */
-    capabilities: Record<string, unknown>;
-}
-/**
- * Current state of an MCP client connection.
- */
-export interface MCPClientState {
-    /** Whether the client is connected */
-    connected: boolean;
-    /** Name of the connected server */
-    serverName: string;
-    /** Tools available from the server */
-    tools: MCPToolDefinition[];
-    /** Resources available from the server */
-    resources: MCPResource[];
-    /** Prompts available from the server */
-    prompts: MCPPrompt[];
-}
-/**
- * Request to call an MCP tool.
- */
-export interface MCPToolCallRequest {
-    /** Tool name */
-    name: string;
-    /** Tool arguments */
-    arguments: Record<string, unknown>;
-}
-/**
- * Content block in an MCP tool call result.
- */
-export type MCPContentBlock = {
-    type: "text";
-    text: string;
-} | {
-    type: "image";
-    data: string;
-    mimeType: string;
-} | {
-    type: "resource";
-    resource: MCPResource;
-};
-/**
- * Result of an MCP tool call.
- */
-export interface MCPToolCallResult {
-    /** Content blocks returned by the tool */
-    content: MCPContentBlock[];
-    /** Whether the tool execution resulted in an error */
-    isError?: boolean;
-    /** Structured content if the tool has an output schema */
-    structuredContent?: unknown;
-}
-/**
- * Server configuration in the MCP config file.
- */
-export interface MCPServerConfigEntry {
-    /** Unique name for this server */
-    name: string;
-    /** Command for stdio transport */
-    command?: string;
-    /** Arguments for stdio transport */
-    args?: string[];
-    /** Environment variables for stdio transport */
-    env?: Record<string, string>;
-    /** URL for HTTP transport */
-    url?: string;
-    /** Headers for HTTP transport */
-    headers?: Record<string, string>;
-    /** HTTP transport flavor ("http" = Streamable HTTP default, "sse" = legacy) */
-    transport?: "http" | "sse";
-    /** Timeout in milliseconds */
-    timeout?: number;
-    /** Whether this server is enabled (default: true) */
-    enabled?: boolean;
-}
-/**
- * Server configuration without name (for object format).
- */
-export interface MCPServerConfigValue {
-    /** Command for stdio transport */
-    command?: string;
-    /** Arguments for stdio transport */
-    args?: string[];
-    /** Environment variables for stdio transport */
-    env?: Record<string, string>;
-    /** URL for HTTP transport */
-    url?: string;
-    /** Headers for HTTP transport */
-    headers?: Record<string, string>;
-    /** HTTP transport flavor ("http" = Streamable HTTP default, "sse" = legacy) */
-    transport?: "http" | "sse";
-    /** Timeout in milliseconds */
-    timeout?: number;
-    /** Whether this server is enabled (default: true) */
-    enabled?: boolean;
-}
-/**
- * MCP configuration file structure.
- * Supports two formats:
- * - Array: { "servers": [{ "name": "github", "command": "npx", ... }] }
- * - Object: { "servers": { "github": { "command": "npx", ... } } }
- */
-export interface MCPConfigFile {
-    /** Server configurations (array or object with server names as keys) */
-    servers: MCPServerConfigEntry[] | Record<string, MCPServerConfigValue>;
-}
-/**
- * MCP logging levels.
- */
-export type MCPLoggingLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
-/**
- * Log message from an MCP server.
- */
-export interface MCPLogMessage {
-    /** Logging level */
-    level: MCPLoggingLevel;
-    /** Log message content */
-    message: string;
-    /** Timestamp */
-    timestamp: Date;
-    /** Server name */
-    serverName: string;
-    /** Additional details */
-    details?: Record<string, unknown>;
-}
-/**
- * Handler function for processing log messages from MCP servers.
- */
-export type MCPLogHandler = (logMessage: MCPLogMessage) => void;
-/**
- * Progress notification from an MCP server.
- */
-export interface MCPProgressNotification {
-    /** Progress token */
-    progressToken: string | number;
-    /** Current progress value */
-    progress: number;
-    /** Total value (optional) */
-    total?: number;
-    /** Human-readable message */
-    message?: string;
-}
-/**
- * Handler function for processing progress notifications.
- */
-export type MCPProgressHandler = (params: MCPProgressNotification) => void;
-/**
- * Elicitation request from an MCP server (requesting user input).
- */
-export interface MCPElicitRequest {
-    /** Message to display to the user */
-    message: string;
-    /** JSON Schema for the expected response */
-    requestedSchema: Record<string, unknown>;
-}
-/**
- * Response to an elicitation request.
- */
-export interface MCPElicitResult {
-    /** Action taken: accept, decline, or cancel */
-    action: "accept" | "decline" | "cancel";
-    /** Content if action is accept */
-    content?: Record<string, unknown>;
-}
-/**
- * Handler function for processing elicitation requests.
- */
-export type MCPElicitationHandler = (request: MCPElicitRequest) => Promise<MCPElicitResult>;
-/**
- * Filesystem root exposed to MCP servers.
- */
-export interface MCPRoot {
-    /** Unique URI (must be file://) */
-    uri: string;
-    /** Human-readable name */
-    name?: string;
-}
-/**
- * Base options common to all MCP server definitions.
- */
-export interface BaseServerOptions {
-    /** Optional handler for server log messages */
-    logger?: MCPLogHandler;
-    /** Optional timeout in milliseconds */
-    timeout?: number;
-    /** Whether to enable server log forwarding (default: true) */
-    enableServerLogs?: boolean;
-    /** Whether to enable progress tracking (default: false) */
-    enableProgressTracking?: boolean;
-    /** List of filesystem roots to expose to the MCP server */
-    roots?: MCPRoot[];
-}

package/dist/types/facade/mcp.d.ts

@@ -1 +0,0 @@
-export * from "./mcp-core/index";

package/dist/types/facade/memory.d.ts

@@ -1 +0,0 @@
-export {};