@mastra/clickhouse 0.0.0-trigger-playground-ui-package-20250506151043 → 0.0.0-update-stores-peerDeps-20250723031338

package/dist/_tsup-dts-rollup.d.ts

@@ -1,15 +1,32 @@
 import type { ClickHouseClient } from '@clickhouse/client';
 import type { EvalRow } from '@mastra/core/storage';
+import { LegacyEvalsStorage } from '@mastra/core/storage';
+import type { MastraMessageContentV2 } from '@mastra/core/agent';
+import type { MastraMessageV1 } from '@mastra/core/memory';
+import type { MastraMessageV2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
-import type { MessageType } from '@mastra/core/memory';
+import { MemoryStorage } from '@mastra/core/storage';
+import type { PaginationArgs } from '@mastra/core/storage';
+import type { PaginationInfo } from '@mastra/core/storage';
+import type { ScoreRowData } from '@mastra/core/scores';
+import { ScoresStorage } from '@mastra/core/storage';
 import type { StorageColumn } from '@mastra/core/storage';
+import type { StorageDomains } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageGetTracesArg } from '@mastra/core/storage';
+import type { StorageGetTracesPaginatedArg } from '@mastra/core/storage';
+import type { StoragePagination } from '@mastra/core/storage';
+import type { StorageResourceType } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
+import { StoreOperations } from '@mastra/core/storage';
 import type { TABLE_NAMES } from '@mastra/core/storage';
-import { TABLE_SCHEMAS } from '@mastra/core/storage';
+import type { TABLE_SCHEMAS } from '@mastra/core/storage';
+import type { Trace } from '@mastra/core/telemetry';
+import { TracesStorage } from '@mastra/core/storage';
 import type { WorkflowRun } from '@mastra/core/storage';
 import type { WorkflowRuns } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
+import { WorkflowsStorage } from '@mastra/core/storage';
 
 declare type ClickhouseConfig = {
     url: string;
@@ -19,13 +36,13 @@ declare type ClickhouseConfig = {
         [TableKey in TABLE_NAMES]?: {
             row?: {
                 interval: number;
-                unit: IntervalUnit;
+                unit: IntervalUnit_2;
                 ttlKey?: string;
             };
             columns?: Partial<{
                 [ColumnKey in keyof (typeof TABLE_SCHEMAS)[TableKey]]: {
                     interval: number;
-                    unit: IntervalUnit;
+                    unit: IntervalUnit_2;
                     ttlKey?: string;
                 };
             }>;
@@ -35,26 +52,50 @@ declare type ClickhouseConfig = {
 export { ClickhouseConfig }
 export { ClickhouseConfig as ClickhouseConfig_alias_1 }
 
+export declare type ClickhouseConfig_alias_2 = {
+    url: string;
+    username: string;
+    password: string;
+    ttl?: {
+        [TableKey in TABLE_NAMES]?: {
+            row?: {
+                interval: number;
+                unit: IntervalUnit;
+                ttlKey?: string;
+            };
+            columns?: Partial<{
+                [ColumnKey in keyof (typeof TABLE_SCHEMAS)[TableKey]]: {
+                    interval: number;
+                    unit: IntervalUnit;
+                    ttlKey?: string;
+                };
+            }>;
+        };
+    };
+};
+
 declare class ClickhouseStore extends MastraStorage {
     protected db: ClickHouseClient;
     protected ttl: ClickhouseConfig['ttl'];
+    stores: StorageDomains;
     constructor(config: ClickhouseConfig);
-    private transformEvalRow;
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+        resourceWorkingMemory: boolean;
+        hasColumn: boolean;
+        createTable: boolean;
+    };
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
     batchInsert({ tableName, records }: {
         tableName: TABLE_NAMES;
         records: Record<string, any>[];
     }): Promise<void>;
-    getTraces({ name, scope, page, perPage, attributes, filters, fromDate, toDate, }: {
-        name?: string;
-        scope?: string;
-        page: number;
-        perPage: number;
-        attributes?: Record<string, string>;
-        filters?: Record<string, any>;
-        fromDate?: Date;
-        toDate?: Date;
-    }): Promise<any[]>;
     optimizeTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
@@ -65,6 +106,14 @@ declare class ClickhouseStore extends MastraStorage {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
@@ -76,6 +125,34 @@ declare class ClickhouseStore extends MastraStorage {
         tableName: TABLE_NAMES;
         keys: Record<string, string>;
     }): Promise<R | null>;
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
+    getTraces(args: StorageGetTracesArg): Promise<any[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    batchTraceInsert(args: {
+        records: Trace[];
+    }): Promise<void>;
     getThreadById({ threadId }: {
         threadId: string;
     }): Promise<StorageThreadType | null>;
@@ -93,10 +170,287 @@ declare class ClickhouseStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]>;
-    saveMessages({ messages }: {
-        messages: MessageType[];
-    }): Promise<MessageType[]>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
+    updateMessages(args: {
+        messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            threadId?: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2[]>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(_score: ScoreRowData): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByScorerId({ scorerId, pagination, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    close(): Promise<void>;
+}
+export { ClickhouseStore }
+export { ClickhouseStore as ClickhouseStore_alias_1 }
+
+export declare const COLUMN_TYPES: Record<StorageColumn['type'], string>;
+
+export declare type IntervalUnit = 'NANOSECOND' | 'MICROSECOND' | 'MILLISECOND' | 'SECOND' | 'MINUTE' | 'HOUR' | 'DAY' | 'WEEK' | 'MONTH' | 'QUARTER' | 'YEAR';
+
+declare type IntervalUnit_2 = 'NANOSECOND' | 'MICROSECOND' | 'MILLISECOND' | 'SECOND' | 'MINUTE' | 'HOUR' | 'DAY' | 'WEEK' | 'MONTH' | 'QUARTER' | 'YEAR';
+
+export declare class LegacyEvalsStorageClickhouse extends LegacyEvalsStorage {
+    protected client: ClickHouseClient;
+    protected operations: StoreOperationsClickhouse;
+    constructor({ client, operations }: {
+        client: ClickHouseClient;
+        operations: StoreOperationsClickhouse;
+    });
+    private transformEvalRow;
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options?: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+}
+
+export declare class MemoryStorageClickhouse extends MemoryStorage {
+    protected client: ClickHouseClient;
+    protected operations: StoreOperationsClickhouse;
+    constructor({ client, operations }: {
+        client: ClickHouseClient;
+        operations: StoreOperationsClickhouse;
+    });
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    saveThread({ thread }: {
+        thread: StorageThreadType;
+    }): Promise<StorageThreadType>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType>;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
+    updateMessages(args: {
+        messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            threadId?: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2[]>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
+}
+
+export declare class ScoresStorageClickhouse extends ScoresStorage {
+    protected client: ClickHouseClient;
+    protected operations: StoreOperationsClickhouse;
+    constructor({ client, operations }: {
+        client: ClickHouseClient;
+        operations: StoreOperationsClickhouse;
+    });
+    private transformScoreRow;
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: ScoreRowData): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByScorerId({ scorerId, pagination, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+}
+
+export declare class StoreOperationsClickhouse extends StoreOperations {
+    protected ttl: ClickhouseConfig_alias_2['ttl'];
+    protected client: ClickHouseClient;
+    constructor({ client, ttl }: {
+        client: ClickHouseClient;
+        ttl: ClickhouseConfig_alias_2['ttl'];
+    });
+    hasColumn(table: string, column: string): Promise<boolean>;
+    protected getSqlType(type: StorageColumn['type']): string;
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+}
+
+export declare const TABLE_ENGINES: Record<TABLE_NAMES, string>;
+
+export declare class TracesStorageClickhouse extends TracesStorage {
+    protected client: ClickHouseClient;
+    protected operations: StoreOperationsClickhouse;
+    constructor({ client, operations }: {
+        client: ClickHouseClient;
+        operations: StoreOperationsClickhouse;
+    });
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    getTraces({ name, scope, page, perPage, attributes, filters, fromDate, toDate, }: StorageGetTracesArg): Promise<any[]>;
+    batchTraceInsert(args: {
+        records: Trace[];
+    }): Promise<void>;
+}
+
+export declare function transformRow<R>(row: any): R;
+
+export declare function transformRows<R>(rows: any[]): R[];
+
+export declare class WorkflowsStorageClickhouse extends WorkflowsStorage {
+    protected client: ClickHouseClient;
+    protected operations: StoreOperationsClickhouse;
+    constructor({ client, operations }: {
+        client: ClickHouseClient;
+        operations: StoreOperationsClickhouse;
+    });
     persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
         workflowName: string;
         runId: string;
@@ -119,20 +473,6 @@ declare class ClickhouseStore extends MastraStorage {
         runId: string;
         workflowName?: string;
     }): Promise<WorkflowRun | null>;
-    private hasColumn;
-    close(): Promise<void>;
 }
-export { ClickhouseStore }
-export { ClickhouseStore as ClickhouseStore_alias_1 }
-
-declare const COLUMN_TYPES: Record<StorageColumn['type'], string>;
-export { COLUMN_TYPES }
-export { COLUMN_TYPES as COLUMN_TYPES_alias_1 }
-
-declare type IntervalUnit = 'NANOSECOND' | 'MICROSECOND' | 'MILLISECOND' | 'SECOND' | 'MINUTE' | 'HOUR' | 'DAY' | 'WEEK' | 'MONTH' | 'QUARTER' | 'YEAR';
-
-declare const TABLE_ENGINES: Record<TABLE_NAMES, string>;
-export { TABLE_ENGINES }
-export { TABLE_ENGINES as TABLE_ENGINES_alias_1 }
 
 export { }