@axiom-lattice/protocols 2.1.5 → 2.1.7

package/src/AssistantStoreProtocol.ts

@@ -0,0 +1,113 @@
+/**
+ * AssistantStoreProtocol
+ *
+ * Assistant store protocol definitions for the Axiom Lattice framework
+ * Provides standardized interfaces for assistant management across all implementations
+ */
+
+/**
+ * Assistant type definition
+ */
+export interface Assistant {
+  /**
+   * Assistant identifier
+   */
+  id: string;
+
+  /**
+   * Assistant name
+   */
+  name: string;
+
+  /**
+   * Assistant description
+   */
+  description?: string;
+
+  /**
+   * Graph definition for the assistant
+   */
+  graphDefinition: any;
+
+  /**
+   * Assistant creation timestamp
+   */
+  createdAt: Date;
+
+  /**
+   * Assistant last update timestamp
+   */
+  updatedAt: Date;
+}
+
+/**
+ * Create assistant request type
+ */
+export interface CreateAssistantRequest {
+  /**
+   * Assistant name
+   */
+  name: string;
+
+  /**
+   * Assistant description
+   */
+  description?: string;
+
+  /**
+   * Graph definition for the assistant
+   */
+  graphDefinition: any;
+}
+
+/**
+ * AssistantStore interface
+ * Provides CRUD operations for assistant data
+ */
+export interface AssistantStore {
+  /**
+   * Get all assistants
+   * @returns Array of all assistants
+   */
+  getAllAssistants(): Promise<Assistant[]>;
+
+  /**
+   * Get assistant by ID
+   * @param id Assistant identifier
+   * @returns Assistant if found, undefined otherwise
+   */
+  getAssistantById(id: string): Promise<Assistant | null>;
+
+  /**
+   * Create a new assistant
+   * @param id Assistant identifier
+   * @param data Assistant creation data
+   * @returns Created assistant
+   */
+  createAssistant(id: string, data: CreateAssistantRequest): Promise<Assistant>;
+
+  /**
+   * Update an existing assistant
+   * @param id Assistant identifier
+   * @param updates Partial assistant data to update
+   * @returns Updated assistant if found, null otherwise
+   */
+  updateAssistant(
+    id: string,
+    updates: Partial<CreateAssistantRequest>
+  ): Promise<Assistant | null>;
+
+  /**
+   * Delete an assistant by ID
+   * @param id Assistant identifier
+   * @returns true if deleted, false otherwise
+   */
+  deleteAssistant(id: string): Promise<boolean>;
+
+  /**
+   * Check if assistant exists
+   * @param id Assistant identifier
+   * @returns true if assistant exists, false otherwise
+   */
+  hasAssistant(id: string): Promise<boolean>;
+}

package/src/EmbeddingsLatticeProtocol.ts

@@ -0,0 +1,30 @@
+/**
+ * EmbeddingsLatticeProtocol
+ *
+ * Embeddings Lattice protocol for defining unified interface for embedding models
+ */
+
+import { Embeddings } from "@langchain/core/embeddings";
+import { BaseLatticeProtocol } from "./BaseLatticeProtocol";
+
+/**
+ * Embeddings configuration interface
+ */
+export interface EmbeddingsConfig {
+  name: string; // Embeddings model name
+  description?: string; // Description of the embeddings model
+  dimensions?: number; // Embedding dimensions
+  maxChunkSize?: number; // Maximum chunk size for embedding
+}
+
+/**
+ * Embeddings Lattice protocol interface
+ */
+export interface EmbeddingsLatticeProtocol
+  extends BaseLatticeProtocol<EmbeddingsConfig, Embeddings> {
+  // Embed documents into vectors
+  embedDocuments: (texts: string[]) => Promise<number[][]>;
+
+  // Embed a single query into a vector
+  embedQuery: (text: string) => Promise<number[]>;
+}

package/src/ScheduleLatticeProtocol.ts

@@ -0,0 +1,115 @@
+/**
+ * ScheduleLatticeProtocol
+ *
+ * Schedule Lattice protocol for delayed task execution management
+ */
+
+import { BaseLatticeProtocol } from "./BaseLatticeProtocol";
+
+/**
+ * Schedule service type enumeration
+ */
+export enum ScheduleType {
+  MEMORY = "memory",
+  // Future implementations can add more types like REDIS, DATABASE, etc.
+}
+
+/**
+ * Schedule configuration interface
+ */
+export interface ScheduleConfig {
+  name: string; // Schedule name
+  description: string; // Schedule description
+  type: ScheduleType; // Schedule service type
+  options?: Record<string, any>; // Additional options
+}
+
+/**
+ * Scheduled task information interface
+ */
+export interface ScheduledTaskInfo {
+  taskId: string;
+  scheduledAt: number;
+  timeoutMs: number;
+  remainingMs: number;
+}
+
+/**
+ * Schedule client interface
+ */
+export interface ScheduleClient {
+  /**
+   * Register a function to be executed after the specified timeout
+   * @param taskId - Unique identifier for the task
+   * @param callback - Function to execute when timeout expires
+   * @param timeoutMs - Delay in milliseconds before execution
+   * @returns true if registered successfully
+   */
+  register: (
+    taskId: string,
+    callback: () => void | Promise<void>,
+    timeoutMs: number
+  ) => boolean;
+
+  /**
+   * Cancel a scheduled task by its ID
+   * @param taskId - The task identifier to cancel
+   * @returns true if task was found and cancelled, false otherwise
+   */
+  cancel: (taskId: string) => boolean;
+
+  /**
+   * Check if a task is currently scheduled
+   * @param taskId - The task identifier to check
+   */
+  has: (taskId: string) => boolean;
+
+  /**
+   * Get the remaining time in milliseconds for a scheduled task
+   * @param taskId - The task identifier
+   * @returns Remaining time in ms, or -1 if task not found
+   */
+  getRemainingTime: (taskId: string) => number;
+
+  /**
+   * Get the count of currently scheduled tasks
+   */
+  getTaskCount: () => number;
+
+  /**
+   * Get all scheduled task IDs
+   */
+  getTaskIds: () => string[];
+
+  /**
+   * Cancel all scheduled tasks
+   */
+  cancelAll: () => void;
+
+  /**
+   * Get task information
+   * @param taskId - The task identifier
+   * @returns Task info or null if not found
+   */
+  getTaskInfo?: (taskId: string) => ScheduledTaskInfo | null;
+}
+
+/**
+ * Schedule Lattice protocol interface
+ */
+export interface ScheduleLatticeProtocol
+  extends BaseLatticeProtocol<ScheduleConfig, ScheduleClient> {
+  // Schedule operations
+  register: (
+    taskId: string,
+    callback: () => void | Promise<void>,
+    timeoutMs: number
+  ) => boolean;
+  cancel: (taskId: string) => boolean;
+  has: (taskId: string) => boolean;
+  getRemainingTime: (taskId: string) => number;
+  getTaskCount: () => number;
+  getTaskIds: () => string[];
+  cancelAll: () => void;
+  getTaskInfo?: (taskId: string) => ScheduledTaskInfo | null;
+}

package/src/ThreadStoreProtocol.ts

@@ -0,0 +1,113 @@
+/**
+ * ThreadStoreProtocol
+ *
+ * Thread store protocol definitions for the Axiom Lattice framework
+ * Provides standardized interfaces for thread management across all implementations
+ */
+
+/**
+ * Thread type definition
+ */
+export interface Thread {
+  /**
+   * Thread identifier
+   */
+  id: string;
+
+  /**
+   * Assistant identifier this thread belongs to
+   */
+  assistantId: string;
+
+  /**
+   * Thread metadata
+   */
+  metadata?: Record<string, any>;
+
+  /**
+   * Thread creation timestamp
+   */
+  createdAt: Date;
+
+  /**
+   * Thread last update timestamp
+   */
+  updatedAt: Date;
+}
+
+/**
+ * Create thread request type
+ */
+export interface CreateThreadRequest {
+  /**
+   * Thread metadata
+   */
+  metadata?: Record<string, any>;
+}
+
+/**
+ * ThreadStore interface
+ * Provides CRUD operations for thread data
+ * All operations are scoped to an assistant ID
+ */
+export interface ThreadStore {
+  /**
+   * Get all threads for a specific assistant
+   * @param assistantId Assistant identifier
+   * @returns Array of threads for the assistant
+   */
+  getThreadsByAssistantId(assistantId: string): Promise<Thread[]>;
+
+  /**
+   * Get a thread by ID for a specific assistant
+   * @param assistantId Assistant identifier
+   * @param threadId Thread identifier
+   * @returns Thread if found, undefined otherwise
+   */
+  getThreadById(
+    assistantId: string,
+    threadId: string
+  ): Promise<Thread | undefined>;
+
+  /**
+   * Create a new thread for an assistant
+   * @param assistantId Assistant identifier
+   * @param threadId Thread identifier
+   * @param data Thread creation data
+   * @returns Created thread
+   */
+  createThread(
+    assistantId: string,
+    threadId: string,
+    data: CreateThreadRequest
+  ): Promise<Thread>;
+
+  /**
+   * Update an existing thread
+   * @param assistantId Assistant identifier
+   * @param threadId Thread identifier
+   * @param updates Partial thread data to update
+   * @returns Updated thread if found, null otherwise
+   */
+  updateThread(
+    assistantId: string,
+    threadId: string,
+    updates: Partial<CreateThreadRequest>
+  ): Promise<Thread | null>;
+
+  /**
+   * Delete a thread by ID
+   * @param assistantId Assistant identifier
+   * @param threadId Thread identifier
+   * @returns true if deleted, false otherwise
+   */
+  deleteThread(assistantId: string, threadId: string): Promise<boolean>;
+
+  /**
+   * Check if thread exists
+   * @param assistantId Assistant identifier
+   * @param threadId Thread identifier
+   * @returns true if thread exists, false otherwise
+   */
+  hasThread(assistantId: string, threadId: string): Promise<boolean>;
+}

package/src/VectorStoreLatticeProtocol.ts

@@ -0,0 +1,73 @@
+/**
+ * VectorStoreLatticeProtocol
+ *
+ * VectorStore Lattice protocol for defining unified interface for vector store implementations
+ */
+
+import { VectorStore } from "@langchain/core/vectorstores";
+import { DocumentInterface } from "@langchain/core/documents";
+import { BaseLatticeProtocol } from "./BaseLatticeProtocol";
+
+/**
+ * VectorStore configuration interface
+ */
+export interface VectorStoreConfig {
+  name: string; // VectorStore name
+  description?: string; // Description of the vector store
+  type?: string; // Vector store type (e.g., "pinecone", "chroma", "pgvector")
+  config?: Record<string, any>; // Configuration for the vector store
+}
+
+/**
+ * VectorStore Lattice protocol interface
+ */
+export interface VectorStoreLatticeProtocol
+  extends BaseLatticeProtocol<VectorStoreConfig, VectorStore> {
+  // Add precomputed vectors and documents
+  addVectors: (
+    vectors: number[][],
+    documents: DocumentInterface[],
+    options?: Record<string, any>
+  ) => Promise<string[] | void>;
+
+  // Add documents (will be embedded automatically)
+  addDocuments: (
+    documents: DocumentInterface[],
+    options?: Record<string, any>
+  ) => Promise<string[] | void>;
+
+  // Delete documents by parameters
+  delete: (params?: Record<string, any>) => Promise<void>;
+
+  // Similarity search with vector query
+  similaritySearchVectorWithScore: (
+    query: number[],
+    k: number,
+    filter?: VectorStore["FilterType"]
+  ) => Promise<[DocumentInterface, number][]>;
+
+  // Similarity search with text query
+  similaritySearch: (
+    query: string,
+    k?: number,
+    filter?: VectorStore["FilterType"]
+  ) => Promise<DocumentInterface[]>;
+
+  // Similarity search with text query and scores
+  similaritySearchWithScore: (
+    query: string,
+    k?: number,
+    filter?: VectorStore["FilterType"]
+  ) => Promise<[DocumentInterface, number][]>;
+
+  // Maximal marginal relevance search (optional)
+  maxMarginalRelevanceSearch?: (
+    query: string,
+    options: {
+      k: number;
+      fetchK?: number;
+      lambda?: number;
+      filter?: VectorStore["FilterType"];
+    }
+  ) => Promise<DocumentInterface[]>;
+}

package/src/index.ts

@@ -9,10 +9,14 @@ export * from "./ToolLatticeProtocol";
 export * from "./ModelLatticeProtocol";
 export * from "./AgentLatticeProtocol";
 export * from "./MemoryLatticeProtocol";
-export * from "./StorageLatticeProtocol";
 export * from "./UILatticeProtocol";
 export * from "./QueueLatticeProtocol";
+export * from "./ScheduleLatticeProtocol";
+export * from "./EmbeddingsLatticeProtocol";
+export * from "./VectorStoreLatticeProtocol";
 export * from "./MessageProtocol";
+export * from "./ThreadStoreProtocol";
+export * from "./AssistantStoreProtocol";
 
 // 导出通用类型
 export * from "./types";

package/src/StorageLatticeProtocol.ts

@@ -1,55 +0,0 @@
-/**
- * StorageLatticeProtocol
- *
- * 存储Lattice的协议，用于数据持久化和状态管理
- */
-
-import { BaseLatticeProtocol } from "./BaseLatticeProtocol";
-
-/**
- * 存储类型枚举
- */
-export enum StorageType {
-  MEMORY = "memory",
-  LOCAL = "local",
-  DATABASE = "database",
-  CLOUD = "cloud",
-  DISTRIBUTED = "distributed",
-}
-
-/**
- * 存储配置接口
- */
-export interface StorageConfig {
-  name: string; // 名称
-  description: string; // 描述
-  type: StorageType; // 存储类型
-  connectionString?: string; // 连接字符串
-  options?: Record<string, any>; // 其他选项
-}
-
-/**
- * 存储客户端接口
- */
-export interface StorageClient {
-  set: (key: string, value: any) => Promise<void>;
-  get: (key: string) => Promise<any>;
-  has: (key: string) => Promise<boolean>;
-  delete: (key: string) => Promise<boolean>;
-  clear: () => Promise<void>;
-  transaction: <T>(operations: () => Promise<T>) => Promise<T>;
-}
-
-/**
- * 存储Lattice协议接口
- */
-export interface StorageLatticeProtocol
-  extends BaseLatticeProtocol<StorageConfig, StorageClient> {
-  // 存储操作方法
-  set: (key: string, value: any) => Promise<void>;
-  get: (key: string) => Promise<any>;
-  has: (key: string) => Promise<boolean>;
-  delete: (key: string) => Promise<boolean>;
-  clear: () => Promise<void>;
-  transaction: <T>(operations: () => Promise<T>) => Promise<T>;
-}