@axiom-lattice/protocols 2.1.19 → 2.1.21

package/src/MetricsServerConfigStoreProtocol.ts

@@ -28,6 +28,8 @@ export interface MetricsServerConfig {
   headers?: Record<string, string>;
   /** Optional timeout in milliseconds (default: 30000) */
   timeout?: number;
+  /** Optional tenant ID for multi-tenant isolation */
+  tenantId?: string;
 }
 
 /**
@@ -220,6 +222,19 @@ export interface SemanticMetricsFilter {
   values: (string | number | boolean)[];
 }
 
+/**
+ * Query result format options
+ */
+export type QueryResultFormat = 'array' | 'object' | 'both';
+
+/**
+ * Column definition
+ */
+export interface MetricColumn {
+  name: string;
+  type: string;  // 'date', 'numeric', 'string', 'varchar', 'boolean', etc.
+}
+
 /**
  * Request body for semantic metrics query
  */
@@ -234,67 +249,45 @@ export interface SemanticMetricsQueryRequest {
   filters?: SemanticMetricsFilter[];
   /** Optional result limit */
   limit?: number;
-}
-
-/**
- * Single data point in semantic metrics query response
- */
-export interface SemanticMetricDataPoint {
-  /** Timestamp in milliseconds */
-  timestamp?: number;
-  /** Metric value */
-  value: number;
-  /** Metric name */
-  metricName?: string;
-  /** Additional dimension values */
-  labels?: Record<string, string>;
-  /** Group by dimension values */
-  groupByValues?: Record<string, string>;
-}
-
-/**
- * AI Hints for a single metric result
- */
-export interface SemanticMetricAiHints {
-  polarity: string;
-  valueInterpretation: string;
-  thresholds?: Array<{
-    metric: string;
-    operator: string;
-    value: number;
-    level: string;
-  }>;
-  suggestedFollowup?: string[];
-}
-
-/**
- * Single metric result from semantic metrics query
- */
-export interface SemanticMetricResult {
-  metricName: string;
-  displayName: string;
-  dataType: string;
-  format: string;
-  polarity: string;
-  columns: string[];
-  rows: Array<Record<string, unknown>>;
-  rowCount: number;
-  executionTimeMs: number;
-  aiHints: SemanticMetricAiHints;
+  /** Optional format specification - defaults to 'array' */
+  format?: QueryResultFormat;
 }
 
 /**
  * Response from semantic metrics query
+ * 
+ * Note: The actual API response format has changed from the original design.
+ * It now returns a flat structure with columns and rows arrays.
+ * 
+ * Based on format parameter:
+ * - 'array' (default): returns rows as array of arrays
+ * - 'object': returns rowsObject as array of objects  
+ * - 'both': returns both formats
  */
 export interface SemanticMetricsQueryResponse {
-  /** Data source ID that was queried */
-  datasourceId: string | number;
-  /** Data source name */
-  datasourceName?: string;
-  /** Query results for each metric */
-  results: SemanticMetricResult[];
-  /** Total execution time in ms */
-  totalExecutionTimeMs?: number;
+  /** Semantic model name that was queried */
+  semanticModel: string;
+  /** Column definitions with name and type */
+  columns: MetricColumn[];
+  /** Number of rows returned */
+  rowCount: number;
+  /** Execution time in milliseconds */
+  executionTimeMs?: number;
+  /** 
+   * Data rows as arrays (each row is an array of values corresponding to columns)
+   * Present when format is 'array' or 'both'
+   */
+  rows?: Array<Array<unknown>>;
+  /**
+   * Data rows as objects (each row is {columnName: value})
+   * Present when format is 'object' or 'both'
+   */
+  rowsObject?: Array<Record<string, unknown>>;
+  /** Debug information (optional) */
+  debug?: {
+    sql?: string;
+    params?: unknown;
+  };
 }
 
 /**
@@ -309,23 +302,86 @@ export interface ExecuteSqlQueryRequest {
   params?: Record<string, string | number | boolean>;
   /** Optional result limit */
   limit?: number;
+  /** Optional format specification - defaults to 'object' */
+  format?: QueryResultFormat;
 }
 
 /**
  * Response from custom SQL query execution
+ *
+ * Based on format parameter:
+ * - 'object' (default): returns rowsObject as array of objects
+ * - 'array': returns rows as array of arrays
+ * - 'both': returns both formats
  */
 export interface ExecuteSqlQueryResponse {
   /** Data source ID that was queried */
   datasourceId: string | number;
   /** Data source name */
   datasourceName?: string;
-  result: {
-    executedSql: string;
-    columns: string[];
-    rows: Array<Record<string, unknown>>;
-    rowCount: number;
-    executionTimeMs: number;
-  }
+  /** Name of the queried table (if applicable) */
+  tableName?: string;
+  /** Column names in order */
+  columns: string[];
+  /** Number of rows returned */
+  rowCount: number;
+  /** Execution time in milliseconds */
+  executionTimeMs: number;
+  /** Executed SQL query */
+  executedSql: string;
+  /**
+   * Data rows as arrays
+   * Present when format is 'array' or 'both'
+   */
+  rows?: Array<Array<unknown>>;
+  /**
+   * Data rows as objects (each row is {columnName: value})
+   * Present when format is 'object' or 'both'
+   */
+  rowsObject?: Array<Record<string, unknown>>;
+}
+
+/**
+ * Request body for table query
+ */
+export interface TableQueryRequest {
+  /** Table name to query */
+  tableName: string;
+  /** Optional result limit */
+  limit?: number;
+  /** Optional format specification - defaults to 'object' */
+  format?: QueryResultFormat;
+}
+
+/**
+ * Response from table query
+ *
+ * Based on format parameter:
+ * - 'object' (default): returns rowsObject as array of objects (API native format)
+ * - 'array': returns rows as array of arrays
+ * - 'both': returns both formats
+ */
+export interface TableQueryResponse {
+  /** Name of the queried table */
+  tableName: string;
+  /** Column names in order */
+  columns: string[];
+  /** Number of rows returned */
+  rowCount: number;
+  /** Execution time in milliseconds */
+  executionTimeMs: number;
+  /** Executed SQL query */
+  executedSql: string;
+  /**
+   * Data rows as arrays
+   * Present when format is 'array' or 'both'
+   */
+  rows?: Array<Array<unknown>>;
+  /**
+   * Data rows as objects (each row is {columnName: value})
+   * Present when format is 'object' or 'both' (API native format)
+   */
+  rowsObject?: Array<Record<string, unknown>>;
 }
 
 /**

package/src/ModelLatticeProtocol.ts

@@ -24,6 +24,8 @@ export interface LLMConfig {
   apiKeyEnvName?: string;
   apiKey?: string;
   baseURL?: string;
+  modelKwargs?: Record<string, any>;
+  extra?: Record<string, any>
 }
 
 /**

package/src/ScheduleLatticeProtocol.ts

@@ -194,6 +194,7 @@ export interface ScheduleStorage {
    * Get all tasks (with optional filters)
    */
   getAllTasks(filters?: {
+    tenantId?: string;
     status?: ScheduledTaskStatus;
     executionType?: ScheduleExecutionType;
     taskType?: string;
@@ -207,6 +208,7 @@ export interface ScheduleStorage {
    * Count tasks (with optional filters)
    */
   countTasks(filters?: {
+    tenantId?: string;
     status?: ScheduledTaskStatus;
     executionType?: ScheduleExecutionType;
     taskType?: string;

package/src/SkillStoreProtocol.ts

@@ -16,6 +16,11 @@ export interface Skill {
    */
   id: string;
 
+  /**
+   * Tenant identifier
+   */
+  tenantId: string;
+
   /**
    * Skill name
    */
@@ -114,95 +119,109 @@ export interface CreateSkillRequest {
  */
 export interface SkillStore {
   /**
-   * Get all skills
-   * @returns Array of all skills
+   * Get all skills for a tenant
+   * @param tenantId Tenant identifier
+   * @returns Array of all skills for the tenant
    */
-  getAllSkills(): Promise<Skill[]>;
+  getAllSkills(tenantId: string): Promise<Skill[]>;
 
   /**
    * Get skill by ID
+   * @param tenantId Tenant identifier
    * @param id Skill identifier
    * @returns Skill if found, null otherwise
    */
-  getSkillById(id: string): Promise<Skill | null>;
+  getSkillById(tenantId: string, id: string): Promise<Skill | null>;
 
   /**
    * Create a new skill
+   * @param tenantId Tenant identifier
    * @param id Skill identifier
    * @param data Skill creation data
    * @returns Created skill
    */
-  createSkill(id: string, data: CreateSkillRequest): Promise<Skill>;
+  createSkill(tenantId: string, id: string, data: CreateSkillRequest): Promise<Skill>;
 
   /**
    * Update an existing skill
+   * @param tenantId Tenant identifier
    * @param id Skill identifier
    * @param updates Partial skill data to update
    * @returns Updated skill if found, null otherwise
    */
   updateSkill(
+    tenantId: string,
     id: string,
     updates: Partial<CreateSkillRequest>
   ): Promise<Skill | null>;
 
   /**
    * Delete a skill by ID
+   * @param tenantId Tenant identifier
    * @param id Skill identifier
    * @returns true if deleted, false otherwise
    */
-  deleteSkill(id: string): Promise<boolean>;
+  deleteSkill(tenantId: string, id: string): Promise<boolean>;
 
   /**
    * Check if skill exists
+   * @param tenantId Tenant identifier
    * @param id Skill identifier
    * @returns true if skill exists, false otherwise
    */
-  hasSkill(id: string): Promise<boolean>;
+  hasSkill(tenantId: string, id: string): Promise<boolean>;
 
   /**
-   * Search skills by metadata
+   * Search skills by metadata within a tenant
+   * @param tenantId Tenant identifier
    * @param metadataKey Metadata key to search for
    * @param metadataValue Metadata value to match
    * @returns Array of matching skills
    */
   searchByMetadata(
+    tenantId: string,
     metadataKey: string,
     metadataValue: string
   ): Promise<Skill[]>;
 
   /**
-   * Filter skills by compatibility
+   * Filter skills by compatibility within a tenant
+   * @param tenantId Tenant identifier
    * @param compatibility Compatibility string to filter by
    * @returns Array of matching skills
    */
-  filterByCompatibility(compatibility: string): Promise<Skill[]>;
+  filterByCompatibility(tenantId: string, compatibility: string): Promise<Skill[]>;
 
   /**
-   * Filter skills by license
+   * Filter skills by license within a tenant
+   * @param tenantId Tenant identifier
    * @param license License string to filter by
    * @returns Array of matching skills
    */
-  filterByLicense(license: string): Promise<Skill[]>;
+  filterByLicense(tenantId: string, license: string): Promise<Skill[]>;
 
   /**
-   * Get sub-skills of a parent skill
+   * Get sub-skills of a parent skill within a tenant
+   * @param tenantId Tenant identifier
    * @param parentSkillName Parent skill name
    * @returns Array of sub-skills if found, empty array otherwise
    */
-  getSubSkills(parentSkillName: string): Promise<Skill[]>;
+  getSubSkills(tenantId: string, parentSkillName: string): Promise<Skill[]>;
 
   /**
    * List all resources in a skill's resources directory
+   * @param tenantId Tenant identifier
    * @param id Skill identifier
    * @returns Array of resource paths relative to resources/ directory
    */
-  listSkillResources?(id: string): Promise<string[]>;
+  listSkillResources?(tenantId: string, id: string): Promise<string[]>;
 
   /**
    * Load a specific resource from a skill's resources directory
+   * @param tenantId Tenant identifier
    * @param id Skill identifier
    * @param resourcePath Path to the resource relative to resources/ directory
    * @returns The resource content as string, or null if not found
    */
-  loadSkillResource?(id: string, resourcePath: string): Promise<string | null>;
+  loadSkillResource?(tenantId: string, id: string, resourcePath: string): Promise<string | null>;
 }

package/src/ThreadStoreProtocol.ts

@@ -14,6 +14,11 @@ export interface Thread {
    */
   id: string;
 
+  /**
+   * Tenant identifier
+   */
+  tenantId: string;
+
   /**
    * Assistant identifier this thread belongs to
    */
@@ -48,35 +53,38 @@ export interface CreateThreadRequest {
 /**
  * ThreadStore interface
  * Provides CRUD operations for thread data
- * All operations are scoped to an assistant ID
+ * All operations are scoped to a tenant ID and assistant ID
  */
 export interface ThreadStore {
   /**
-   * Get all threads for a specific assistant
+   * Get all threads for a specific tenant and assistant
+   * @param tenantId Tenant identifier
    * @param assistantId Assistant identifier
    * @returns Array of threads for the assistant
    */
-  getThreadsByAssistantId(assistantId: string): Promise<Thread[]>;
+  getThreadsByAssistantId(tenantId: string, assistantId: string): Promise<Thread[]>;
 
   /**
-   * Get a thread by ID for a specific assistant
-   * @param assistantId Assistant identifier
+   * Get a thread by ID for a specific tenant
+   * @param tenantId Tenant identifier
    * @param threadId Thread identifier
    * @returns Thread if found, undefined otherwise
    */
   getThreadById(
-    assistantId: string,
+    tenantId: string,
     threadId: string
   ): Promise<Thread | undefined>;
 
   /**
-   * Create a new thread for an assistant
+   * Create a new thread for a tenant and assistant
+   * @param tenantId Tenant identifier
    * @param assistantId Assistant identifier
    * @param threadId Thread identifier
    * @param data Thread creation data
    * @returns Created thread
    */
   createThread(
+    tenantId: string,
     assistantId: string,
     threadId: string,
     data: CreateThreadRequest
@@ -84,30 +92,30 @@ export interface ThreadStore {
 
   /**
    * Update an existing thread
-   * @param assistantId Assistant identifier
+   * @param tenantId Tenant identifier
    * @param threadId Thread identifier
    * @param updates Partial thread data to update
    * @returns Updated thread if found, null otherwise
    */
   updateThread(
-    assistantId: string,
+    tenantId: string,
     threadId: string,
     updates: Partial<CreateThreadRequest>
   ): Promise<Thread | null>;
 
   /**
    * Delete a thread by ID
-   * @param assistantId Assistant identifier
+   * @param tenantId Tenant identifier
    * @param threadId Thread identifier
    * @returns true if deleted, false otherwise
    */
-  deleteThread(assistantId: string, threadId: string): Promise<boolean>;
+  deleteThread(tenantId: string, threadId: string): Promise<boolean>;
 
   /**
    * Check if thread exists
-   * @param assistantId Assistant identifier
+   * @param tenantId Tenant identifier
    * @param threadId Thread identifier
    * @returns true if thread exists, false otherwise
    */
-  hasThread(assistantId: string, threadId: string): Promise<boolean>;
+  hasThread(tenantId: string, threadId: string): Promise<boolean>;
 }