indusagi 0.12.32 → 0.12.34

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

@@ -0,0 +1,67 @@
+/**
+ * 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

@@ -0,0 +1,110 @@
+/**
+ * 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

@@ -0,0 +1,62 @@
+/**
+ * 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

@@ -0,0 +1,288 @@
+/**
+ * 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>;
+    /** 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>;
+    /** 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>;
+    /** 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

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

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

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

package/dist/types/facade/ml/adapters/amazon-bedrock.d.ts

@@ -0,0 +1,32 @@
+import { type Message, type SystemContentBlock, type ToolConfiguration } from "@aws-sdk/client-bedrock-runtime";
+import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions, ThinkingBudgets, ThinkingLevel } from "../types.js";
+export interface BedrockOptions extends StreamOptions {
+    region?: string;
+    profile?: string;
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+    reasoning?: ThinkingLevel;
+    thinkingBudgets?: ThinkingBudgets;
+    interleavedThinking?: boolean;
+}
+export declare class BedrockRequestBuilder {
+    private readonly model;
+    private readonly context;
+    private readonly options;
+    constructor(model: Model<"bedrock-converse-stream">, context: Context, options: BedrockOptions);
+    build(): {
+        modelId: string;
+        messages: Message[];
+        system: SystemContentBlock[] | undefined;
+        inferenceConfig: {
+            maxTokens: number | undefined;
+            temperature: number | undefined;
+        };
+        toolConfig: ToolConfiguration | undefined;
+        additionalModelRequestFields: Record<string, any> | undefined;
+    };
+}
+export declare const streamBedrock: StreamFunction<"bedrock-converse-stream", BedrockOptions>;
+export declare const streamSimpleBedrock: StreamFunction<"bedrock-converse-stream", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/anthropic.d.ts

@@ -0,0 +1,61 @@
+import type { MessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/messages.js";
+import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
+import { BaseStreamHandler } from "../kit/base-stream-handler.js";
+import { type ProviderLifecycleHooks } from "./simple-options.js";
+export interface AnthropicOptions extends StreamOptions {
+    thinkingEnabled?: boolean;
+    thinkingBudgetTokens?: number;
+    interleavedThinking?: boolean;
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+}
+export interface AnthropicExecutionOptions {
+    hooks?: ProviderLifecycleHooks<MessageCreateParamsStreaming, unknown>;
+    retryPolicy?: {
+        maxAttempts?: number;
+        baseDelayMs?: number;
+    };
+}
+/**
+ * Assembles the streaming request payload for the Anthropic Messages API.
+ *
+ * Acts as the single place that turns a generic model/context/options triple
+ * into a concrete `MessageCreateParamsStreaming` object.
+ */
+export declare class AnthropicRequestBuilder {
+    private readonly model;
+    private readonly context;
+    private readonly isOAuthToken;
+    private readonly options?;
+    constructor(model: Model<"anthropic-messages">, context: Context, isOAuthToken: boolean, options?: AnthropicOptions | undefined);
+    /**
+     * Produce the parameters passed to the Anthropic streaming endpoint.
+     *
+     * @returns The fully populated SDK streaming request.
+     */
+    build(): MessageCreateParamsStreaming;
+}
+/**
+ * Stream handler tailored to Anthropic.
+ *
+ * Drives the Anthropic SDK stream and forwards normalized assistant events.
+ */
+export declare class AnthropicStreamHandler extends BaseStreamHandler {
+    private readonly executeFn?;
+    constructor(executeFn?: (() => Promise<void>) | undefined);
+    /**
+     * Run the supplied executor, if any, to consume the Anthropic stream.
+     */
+    protected processStream(): Promise<void>;
+    /**
+     * Walk the raw SDK stream, handing each event to the supplied callback.
+     *
+     * @param anthropicStream - Raw async iterable produced by the Anthropic SDK.
+     * @param onEvent - Invoked once per streamed event.
+     */
+    process(anthropicStream: AsyncIterable<unknown>, onEvent: (event: any) => void): Promise<void>;
+}
+export declare const streamAnthropic: StreamFunction<"anthropic-messages", AnthropicOptions>;
+export declare const streamSimpleAnthropic: StreamFunction<"anthropic-messages", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/azure-openai-responses.d.ts

@@ -0,0 +1,14 @@
+import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
+export interface AzureOpenAIResponsesOptions extends StreamOptions {
+    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoningSummary?: "auto" | "detailed" | "concise" | null;
+    azureApiVersion?: string;
+    azureResourceName?: string;
+    azureBaseUrl?: string;
+    azureDeploymentName?: string;
+}
+/**
+ * Streaming entry point for Azure OpenAI Responses deployments.
+ */
+export declare const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses", AzureOpenAIResponsesOptions>;
+export declare const streamSimpleAzureOpenAIResponses: StreamFunction<"azure-openai-responses", SimpleStreamOptions>;