@axiom-lattice/protocols 2.1.9 → 2.1.11

package/dist/index.d.ts

@@ -122,9 +122,7 @@ interface ModelLatticeProtocol extends BaseLatticeProtocol<LLMConfig, BaseChatMo
  */
 declare enum AgentType {
     REACT = "react",
-    DEEP_AGENT = "deep_agent",
-    PLAN_EXECUTE = "plan_execute",
-    SEQUENTIAL = "sequential"
+    DEEP_AGENT = "deep_agent"
 }
 /**
  * Runtime configuration that will be injected into LangGraphRunnableConfig.configurable
@@ -151,6 +149,13 @@ interface BaseAgentConfig {
      * Will be available in tools via config.configurable.runConfig
      */
     runConfig?: AgentRunConfig;
+    skillCategories?: string[];
+    connectedSandbox?: ConnectedSandboxConfig;
+}
+type AvailableModule = "filesystem" | "code_eval" | "browser";
+interface ConnectedSandboxConfig {
+    isolatedLevel: "agent" | "thread" | "global";
+    availabledModules?: AvailableModule[];
 }
 /**
  * REACT agent configuration
@@ -168,28 +173,15 @@ interface DeepAgentConfig extends BaseAgentConfig {
     subAgents?: string[];
     internalSubAgents?: AgentConfig[];
 }
-/**
- * PLAN_EXECUTE agent configuration
- */
-interface PlanExecuteAgentConfig extends BaseAgentConfig {
-    type: AgentType.PLAN_EXECUTE;
-    tools?: string[];
-}
-/**
- * SEQUENTIAL agent configuration
- */
-interface SequentialAgentConfig extends BaseAgentConfig {
-    type: AgentType.SEQUENTIAL;
-}
 /**
  * Agent configuration union type
  * Different agent types have different configuration options
  */
-type AgentConfig = ReactAgentConfig | DeepAgentConfig | PlanExecuteAgentConfig | SequentialAgentConfig;
+type AgentConfig = ReactAgentConfig | DeepAgentConfig;
 /**
  * Agent configuration with tools property
  */
-type AgentConfigWithTools = ReactAgentConfig | DeepAgentConfig | PlanExecuteAgentConfig;
+type AgentConfigWithTools = ReactAgentConfig | DeepAgentConfig;
 /**
  * Type guard to check if config has tools property
  */
@@ -1081,6 +1073,441 @@ interface AssistantStore {
     hasAssistant(id: string): Promise<boolean>;
 }
 
+/**
+ * SkillStoreProtocol
+ *
+ * Skill store protocol definitions for the Axiom Lattice framework
+ * Provides standardized interfaces for skill management across all implementations
+ */
+/**
+ * Skill type definition
+ */
+interface Skill {
+    /**
+     * Skill identifier (key)
+     */
+    id: string;
+    /**
+     * Skill name
+     */
+    name: string;
+    /**
+     * Skill description
+     */
+    description: string;
+    /**
+     * License information (optional)
+     */
+    license?: string;
+    /**
+     * Compatibility information (optional)
+     */
+    compatibility?: string;
+    /**
+     * Additional metadata as string-to-string map (optional)
+     */
+    metadata?: Record<string, string>;
+    /**
+     * Skill detailed content description (optional)
+     * This is the markdown body content after the frontmatter
+     */
+    content?: string;
+    /**
+     * Sub-skills (optional)
+     * Array of skill names that are sub-skills of this skill
+     * Creates a hierarchical tree structure for organizing skills
+     */
+    subSkills?: string[];
+    /**
+     * Skill creation timestamp
+     */
+    createdAt: Date;
+    /**
+     * Skill last update timestamp
+     */
+    updatedAt: Date;
+}
+/**
+ * Create skill request type
+ */
+interface CreateSkillRequest {
+    /**
+     * Skill name
+     */
+    name: string;
+    /**
+     * Skill description
+     */
+    description: string;
+    /**
+     * License information (optional)
+     */
+    license?: string;
+    /**
+     * Compatibility information (optional)
+     */
+    compatibility?: string;
+    /**
+     * Additional metadata as string-to-string map (optional)
+     */
+    metadata?: Record<string, string>;
+    /**
+     * Skill detailed content description (optional)
+     * This is the markdown body content after the frontmatter
+     */
+    content?: string;
+    /**
+     * Sub-skills (optional)
+     * Array of skill names that are sub-skills of this skill
+     * Creates a hierarchical tree structure for organizing skills
+     */
+    subSkills?: string[];
+}
+/**
+ * SkillStore interface
+ * Provides CRUD operations for skill data
+ */
+interface SkillStore {
+    /**
+     * Get all skills
+     * @returns Array of all skills
+     */
+    getAllSkills(): Promise<Skill[]>;
+    /**
+     * Get skill by ID
+     * @param id Skill identifier
+     * @returns Skill if found, null otherwise
+     */
+    getSkillById(id: string): Promise<Skill | null>;
+    /**
+     * Create a new skill
+     * @param id Skill identifier
+     * @param data Skill creation data
+     * @returns Created skill
+     */
+    createSkill(id: string, data: CreateSkillRequest): Promise<Skill>;
+    /**
+     * Update an existing skill
+     * @param id Skill identifier
+     * @param updates Partial skill data to update
+     * @returns Updated skill if found, null otherwise
+     */
+    updateSkill(id: string, updates: Partial<CreateSkillRequest>): Promise<Skill | null>;
+    /**
+     * Delete a skill by ID
+     * @param id Skill identifier
+     * @returns true if deleted, false otherwise
+     */
+    deleteSkill(id: string): Promise<boolean>;
+    /**
+     * Check if skill exists
+     * @param id Skill identifier
+     * @returns true if skill exists, false otherwise
+     */
+    hasSkill(id: string): Promise<boolean>;
+    /**
+     * Search skills by metadata
+     * @param metadataKey Metadata key to search for
+     * @param metadataValue Metadata value to match
+     * @returns Array of matching skills
+     */
+    searchByMetadata(metadataKey: string, metadataValue: string): Promise<Skill[]>;
+    /**
+     * Filter skills by compatibility
+     * @param compatibility Compatibility string to filter by
+     * @returns Array of matching skills
+     */
+    filterByCompatibility(compatibility: string): Promise<Skill[]>;
+    /**
+     * Filter skills by license
+     * @param license License string to filter by
+     * @returns Array of matching skills
+     */
+    filterByLicense(license: string): Promise<Skill[]>;
+    /**
+     * Get sub-skills of a parent skill
+     * @param parentSkillName Parent skill name
+     * @returns Array of sub-skills if found, empty array otherwise
+     */
+    getSubSkills(parentSkillName: string): Promise<Skill[]>;
+}
+
+/**
+ * SkillLatticeProtocol
+ *
+ * Skill Lattice protocol for defining reusable skill components
+ */
+
+/**
+ * Skill configuration interface
+ */
+interface SkillConfig {
+    /** Skill name (required) */
+    name: string;
+    /** Skill description (required) */
+    description: string;
+    /** License information (optional) */
+    license?: string;
+    /** Compatibility information (optional) */
+    compatibility?: string;
+    /** Additional metadata as string-to-string map (optional) */
+    metadata?: Record<string, string>;
+    /** Skill detailed content description (optional) */
+    content?: string;
+    /** Sub-skills (optional) - Array of skill names that are sub-skills of this skill */
+    subSkills?: string[];
+}
+/**
+ * Skill client interface
+ * Clients can optionally implement setStore to receive store access
+ * Supports both interface implementation and any type for backward compatibility
+ */
+interface SkillClient {
+    /**
+     * Optional method to set the store instance
+     * Called by SkillLatticeManager when registering a skill
+     */
+    setStore?: (store: SkillStore) => void;
+    /**
+     * Optional store property
+     * Can be set directly or via setStore method
+     */
+    store?: SkillStore;
+    /**
+     * Additional client-specific properties and methods
+     */
+    [key: string]: any;
+}
+/**
+ * Skill client type (supports both interface and any for backward compatibility)
+ */
+type SkillClientType = SkillClient | any;
+/**
+ * Skill Lattice protocol interface
+ */
+interface SkillLatticeProtocol extends BaseLatticeProtocol<SkillConfig, SkillClientType> {
+    execute?: (input: any, config?: any) => Promise<any>;
+}
+
+/**
+ * McpLatticeProtocol
+ *
+ * Model Context Protocol (MCP) lattice protocol for integrating MCP servers
+ * with the Lattice framework. Provides standardized interfaces for MCP
+ * client connections, tool discovery, and remote execution.
+ */
+
+/**
+ * MCP transport type
+ */
+type McpTransportType = "stdio" | "streamable_http" | "sse";
+/**
+ * MCP server configuration
+ */
+interface McpServerConfig {
+    /** Server name */
+    name: string;
+    /** Server version */
+    version: string;
+    /** Transport type */
+    transport: McpTransportType;
+    /** Command for stdio transport (e.g., "npx", "python") */
+    command?: string;
+    /** Arguments for stdio transport */
+    args?: string[];
+    /** URL for HTTP/SSE transport */
+    url?: string;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Connection timeout in milliseconds */
+    timeout?: number;
+    /** Retry attempts on connection failure */
+    retryAttempts?: number;
+}
+/**
+ * MCP tool definition
+ */
+interface McpTool {
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** Input schema */
+    inputSchema: {
+        type: "object";
+        properties: Record<string, any>;
+        required?: string[];
+    };
+    /** Tool metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * MCP tool call result
+ */
+interface McpToolResult {
+    /** Whether the call was successful */
+    success: boolean;
+    /** Result content */
+    content: Array<{
+        type: "text" | "image" | "audio" | "resource";
+        data: any;
+        mimeType?: string;
+    }>;
+    /** Error message if failed */
+    error?: string;
+    /** Execution metadata */
+    metadata?: {
+        duration: number;
+        tokens?: number;
+        model?: string;
+    };
+}
+/**
+ * MCP client interface
+ */
+interface McpClient {
+    /** Client name */
+    name: string;
+    /** Client version */
+    version: string;
+    /** Server configuration */
+    serverConfig: McpServerConfig;
+    /**
+     * Connect to MCP server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from MCP server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * List available tools
+     */
+    listTools(): Promise<McpTool[]>;
+    /**
+     * Call a tool
+     */
+    callTool(name: string, arguments_: Record<string, any>): Promise<McpToolResult>;
+    /**
+     * Subscribe to server notifications
+     */
+    subscribe(topic: string, handler: (data: any) => void): void;
+    /**
+     * Unsubscribe from server notifications
+     */
+    unsubscribe(topic: string): void;
+    /**
+     * Get client statistics
+     */
+    getStats(): McpStats;
+    /**
+     * Get connection status
+     */
+    getStatus(): McpConnectionStatus;
+}
+/**
+ * MCP client options
+ */
+interface McpClientOptions {
+    /** Client name */
+    name: string;
+    /** Client version */
+    version: string;
+    /** Server configuration */
+    serverConfig: McpServerConfig;
+    /** Auto-connect on initialization */
+    autoConnect?: boolean;
+    /** Error handler */
+    onError?: (error: Error) => void;
+    /** Connection status handler */
+    onStatusChange?: (status: McpConnectionStatus) => void;
+}
+/**
+ * MCP Lattice protocol interface
+ */
+interface McpLatticeProtocol extends BaseLatticeProtocol<McpServerConfig, McpClient> {
+    /**
+     * Server configuration
+     */
+    config: McpServerConfig;
+    /**
+     * MCP client instance
+     */
+    client: McpClient;
+    /**
+     * Connect to MCP server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from MCP server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get available tools
+     */
+    getTools(): Promise<McpTool[]>;
+    /**
+     * Execute a tool
+     */
+    executeTool(name: string, arguments_: Record<string, any>): Promise<McpToolResult>;
+    /**
+     * Execute with automatic retries
+     */
+    executeToolWithRetry(name: string, arguments_: Record<string, any>, maxRetries?: number): Promise<McpToolResult>;
+    /**
+     * Get protocol version
+     */
+    getProtocolVersion(): string;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<boolean>;
+}
+/**
+ * MCP message types
+ */
+declare enum McpMessageType {
+    CONNECT = "mcp:connect",
+    DISCONNECT = "mcp:disconnect",
+    LIST_TOOLS = "mcp:list_tools",
+    CALL_TOOL = "mcp:call_tool",
+    TOOL_RESULT = "mcp:tool_result",
+    NOTIFICATION = "mcp:notification",
+    ERROR = "mcp:error",
+    HEALTH_CHECK = "mcp:health_check"
+}
+/**
+ * MCP Lattice message
+ */
+interface McpLatticeMessage extends LatticeMessage {
+    type: McpMessageType;
+    payload: {
+        toolName?: string;
+        arguments?: Record<string, any>;
+        result?: McpToolResult;
+        tools?: McpTool[];
+        error?: string;
+    };
+}
+/**
+ * MCP connection status
+ */
+type McpConnectionStatus = "disconnected" | "connecting" | "connected" | "reconnecting" | "error";
+/**
+ * MCP statistics
+ */
+interface McpStats {
+    totalCalls: number;
+    successfulCalls: number;
+    failedCalls: number;
+    averageLatency: number;
+    lastCallTimestamp: number;
+}
+
 /**
  * 通用类型定义
  *
@@ -1144,4 +1571,4 @@ type Timestamp = number;
  */
 type Callback<T = any, R = void> = (data: T) => R | Promise<R>;
 
-export { type AgentClient, type AgentConfig, type AgentConfigWithTools, type AgentLatticeProtocol, type AgentRunConfig, AgentType, type Assistant, type AssistantMessage, type AssistantStore, type BaseLatticeProtocol, type BaseMessage, type Callback, type CreateAssistantRequest, type CreateThreadRequest, type DeepAgentConfig, type DeveloperMessage, type EmbeddingsConfig, type EmbeddingsLatticeProtocol, type FilterCondition, type GraphBuildOptions, type ID, type InterruptMessage, type LLMConfig, type LatticeError, type LatticeEventBus, type LatticeMessage, type LoggerClient, type LoggerConfig, type LoggerContext, type LoggerLatticeProtocol, LoggerType, type MemoryClient, type MemoryConfig, type MemoryLatticeProtocol, MemoryType, type Message, type MessageChunk, type ModelLatticeProtocol, type PaginatedResult, type PaginationParams, type PinoFileOptions, type PlanExecuteAgentConfig, type QueryParams, type QueueClient, type QueueConfig, type QueueLatticeProtocol, type QueueResult, QueueType, type ReactAgentConfig, type Result, type ScheduleClient, type ScheduleConfig, type ScheduleCronOptions, ScheduleExecutionType, type ScheduleLatticeProtocol, type ScheduleOnceOptions, type ScheduleStorage, ScheduleType, type ScheduledTaskDefinition, ScheduledTaskStatus, type SequentialAgentConfig, type SystemMessage, type TaskHandler, type Thread, type ThreadStore, type Timestamp, type ToolCall, type ToolConfig, type ToolExecutor, type ToolLatticeProtocol, type ToolMessage, type UIComponent, UIComponentType, type UIConfig, type UILatticeProtocol, type UserMessage, type VectorStoreConfig, type VectorStoreLatticeProtocol, getSubAgentsFromConfig, getToolsFromConfig, hasTools, isDeepAgentConfig };
+export { type AgentClient, type AgentConfig, type AgentConfigWithTools, type AgentLatticeProtocol, type AgentRunConfig, AgentType, type Assistant, type AssistantMessage, type AssistantStore, type AvailableModule, type BaseLatticeProtocol, type BaseMessage, type Callback, type ConnectedSandboxConfig, type CreateAssistantRequest, type CreateSkillRequest, type CreateThreadRequest, type DeepAgentConfig, type DeveloperMessage, type EmbeddingsConfig, type EmbeddingsLatticeProtocol, type FilterCondition, type GraphBuildOptions, type ID, type InterruptMessage, type LLMConfig, type LatticeError, type LatticeEventBus, type LatticeMessage, type LoggerClient, type LoggerConfig, type LoggerContext, type LoggerLatticeProtocol, LoggerType, type McpClient, type McpClientOptions, type McpConnectionStatus, type McpLatticeMessage, type McpLatticeProtocol, McpMessageType, type McpServerConfig, type McpStats, type McpTool, type McpToolResult, type McpTransportType, type MemoryClient, type MemoryConfig, type MemoryLatticeProtocol, MemoryType, type Message, type MessageChunk, type ModelLatticeProtocol, type PaginatedResult, type PaginationParams, type PinoFileOptions, type QueryParams, type QueueClient, type QueueConfig, type QueueLatticeProtocol, type QueueResult, QueueType, type ReactAgentConfig, type Result, type ScheduleClient, type ScheduleConfig, type ScheduleCronOptions, ScheduleExecutionType, type ScheduleLatticeProtocol, type ScheduleOnceOptions, type ScheduleStorage, ScheduleType, type ScheduledTaskDefinition, ScheduledTaskStatus, type Skill, type SkillClient, type SkillClientType, type SkillConfig, type SkillLatticeProtocol, type SkillStore, type SystemMessage, type TaskHandler, type Thread, type ThreadStore, type Timestamp, type ToolCall, type ToolConfig, type ToolExecutor, type ToolLatticeProtocol, type ToolMessage, type UIComponent, UIComponentType, type UIConfig, type UILatticeProtocol, type UserMessage, type VectorStoreConfig, type VectorStoreLatticeProtocol, getSubAgentsFromConfig, getToolsFromConfig, hasTools, isDeepAgentConfig };

package/dist/index.js

@@ -22,6 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   AgentType: () => AgentType,
   LoggerType: () => LoggerType,
+  McpMessageType: () => McpMessageType,
   MemoryType: () => MemoryType,
   QueueType: () => QueueType,
   ScheduleExecutionType: () => ScheduleExecutionType,
@@ -39,12 +40,10 @@ module.exports = __toCommonJS(index_exports);
 var AgentType = /* @__PURE__ */ ((AgentType2) => {
   AgentType2["REACT"] = "react";
   AgentType2["DEEP_AGENT"] = "deep_agent";
-  AgentType2["PLAN_EXECUTE"] = "plan_execute";
-  AgentType2["SEQUENTIAL"] = "sequential";
   return AgentType2;
 })(AgentType || {});
 function hasTools(config) {
-  return config.type !== "sequential" /* SEQUENTIAL */;
+  return true;
 }
 function isDeepAgentConfig(config) {
   return config.type === "deep_agent" /* DEEP_AGENT */;
@@ -123,10 +122,24 @@ var LoggerType = /* @__PURE__ */ ((LoggerType2) => {
   LoggerType2["CUSTOM"] = "custom";
   return LoggerType2;
 })(LoggerType || {});
+
+// src/McpLatticeProtocol.ts
+var McpMessageType = /* @__PURE__ */ ((McpMessageType2) => {
+  McpMessageType2["CONNECT"] = "mcp:connect";
+  McpMessageType2["DISCONNECT"] = "mcp:disconnect";
+  McpMessageType2["LIST_TOOLS"] = "mcp:list_tools";
+  McpMessageType2["CALL_TOOL"] = "mcp:call_tool";
+  McpMessageType2["TOOL_RESULT"] = "mcp:tool_result";
+  McpMessageType2["NOTIFICATION"] = "mcp:notification";
+  McpMessageType2["ERROR"] = "mcp:error";
+  McpMessageType2["HEALTH_CHECK"] = "mcp:health_check";
+  return McpMessageType2;
+})(McpMessageType || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentType,
   LoggerType,
+  McpMessageType,
   MemoryType,
   QueueType,
   ScheduleExecutionType,