@mastra/upstash 0.0.0-vnextWorkflows-20250422142014 → 0.0.0-workflow-deno-20250616115451

package/PAGINATION.md

@@ -0,0 +1,397 @@
+# Upstash Store Pagination Features
+
+This document describes the pagination capabilities added to the UpstashStore class for efficient data retrieval from Upstash Redis.
+
+## Overview
+
+The UpstashStore now supports comprehensive pagination across all major data retrieval methods. Pagination helps manage large datasets by:
+
+- Reducing memory usage by loading data in chunks
+- Improving response times for large collections
+- Supporting both cursor-based and offset-based pagination patterns
+- Providing total count information for UI pagination controls
+
+## Pagination Patterns
+
+The implementation supports two pagination patterns to match different use cases:
+
+### 1. Page-based Pagination (page/perPage)
+
+```typescript
+const result = await store.getEvals({
+  agentName: 'my-agent',
+  page: 0, // First page (0-based)
+  perPage: 20, // 20 items per page
+});
+```
+
+### 2. Offset-based Pagination (limit/offset)
+
+```typescript
+const result = await store.getEvals({
+  agentName: 'my-agent',
+  limit: 20, // Maximum items to return
+  offset: 40, // Skip first 40 items
+});
+```
+
+## Enhanced Methods
+
+### 1. getEvals() - New Comprehensive Evaluation Retrieval
+
+```typescript
+const result = await store.getEvals({
+  agentName?: string;           // Filter by agent name
+  type?: 'test' | 'live';       // Filter by evaluation type
+  page?: number;                // Page number (0-based)
+  perPage?: number;             // Items per page
+  limit?: number;               // Alternative: max items
+  offset?: number;              // Alternative: items to skip
+  fromDate?: Date;              // Filter by date range
+  toDate?: Date;
+});
+
+// Returns:
+{
+  evals: EvalRow[];             // Evaluation results
+  total: number;                // Total count (before pagination)
+  page?: number;                // Current page (page-based)
+  perPage?: number;             // Items per page (page-based)
+  hasMore: boolean;             // Whether more data exists
+}
+```
+
+### 2. getMessages() - Enhanced with Pagination Support
+
+The existing `getMessages` function now supports pagination while maintaining full backward compatibility:
+
+```typescript
+// Original usage (backward compatible) - returns message array
+const messages = await store.getMessages({
+  threadId: 'thread-id',
+  format: 'v2'
+});
+
+// New paginated usage - returns pagination object
+const result = await store.getMessages({
+  threadId: 'thread-id',
+  page: 0,                      // Page number (0-based)
+  perPage: 20,                  // Items per page (default: 40)
+  format: 'v2',                 // Message format
+  fromDate?: Date,              // Filter by creation date
+  toDate?: Date,                // Filter by creation date
+});
+
+// Paginated result format:
+{
+  messages: MastraMessageV1[] | MastraMessageV2[];
+  total: number;                // Total count
+  page: number;                 // Current page
+  perPage: number;              // Items per page
+  hasMore: boolean;             // Whether more data exists
+}
+```
+
+**Key Features:**
+
+- **Backward Compatible**: Existing code continues to work unchanged
+- **Conditional Return Type**: Returns array when no pagination params, object when paginated
+- **Date Filtering**: Combine pagination with date range filtering
+- **Maintains Message Order**: Preserves chronological order from Redis sorted sets
+- **Efficient Pipelines**: Uses Redis pipelines for batch operations
+
+### 3. getThreads() - New Comprehensive Thread Retrieval
+
+```typescript
+const result = await store.getThreads({
+  resourceId?: string;          // Filter by resource ID
+  page?: number;                // Page number (0-based)
+  perPage?: number;             // Items per page
+  limit?: number;               // Alternative: max items
+  offset?: number;              // Alternative: items to skip
+  fromDate?: Date;              // Filter by creation date
+  toDate?: Date;
+});
+
+// Returns:
+{
+  threads: StorageThreadType[]; // Thread results
+  total: number;                // Total count
+  page?: number;
+  perPage?: number;
+  hasMore: boolean;
+}
+```
+
+### 4. getTracesWithCount() - Enhanced Trace Retrieval
+
+```typescript
+const result = await store.getTracesWithCount({
+  name?: string;                // Filter by trace name
+  scope?: string;               // Filter by scope
+  page?: number;                // Page number (0-based)
+  perPage?: number;             // Items per page (default: 100)
+  attributes?: Record<string, string>; // Filter by attributes
+  filters?: Record<string, any>; // Custom filters
+  fromDate?: Date;              // Date range filtering
+  toDate?: Date;
+});
+
+// Returns:
+{
+  traces: any[];                // Trace results
+  total: number;                // Total count
+  page: number;
+  perPage: number;
+  hasMore: boolean;
+}
+```
+
+## Enhanced Existing Methods
+
+### 1. getEvalsByAgentName() - Now with Pagination
+
+```typescript
+const evals = await store.getEvalsByAgentName(
+  'agent-name',
+  'test' | 'live',
+  {
+    page?: number;
+    perPage?: number;
+    limit?: number;
+    offset?: number;
+  }
+);
+```
+
+### 2. getThreadsByResourceId() - Now with Pagination
+
+```typescript
+const threads = await store.getThreadsByResourceId({
+  resourceId: 'resource-id',
+  page?: number;
+  perPage?: number;
+  limit?: number;
+  offset?: number;
+});
+```
+
+### 3. getWorkflowRuns() - Improved Performance
+
+The existing method now uses Redis pipelines for better performance:
+
+```typescript
+const result = await store.getWorkflowRuns({
+  namespace?: string;           // Default: 'workflows'
+  workflowName?: string;
+  fromDate?: Date;
+  toDate?: Date;
+  limit?: number;
+  offset?: number;
+  resourceId?: string;
+});
+```
+
+## Utility Methods
+
+### 1. scanWithCursor() - Cursor-based Key Scanning
+
+```typescript
+const result = await store.scanWithCursor(
+  'pattern:*',     // Redis key pattern
+  '0',             // Cursor (use '0' for first scan)
+  1000             // Count hint
+);
+
+// Returns:
+{
+  keys: string[];       // Found keys
+  nextCursor: string;   // Cursor for next iteration
+  hasMore: boolean;     // Whether more keys exist
+}
+```
+
+### 2. getPaginatedResults() - Generic Pagination Utility
+
+```typescript
+const result = await store.getPaginatedResults<TransformedType>(
+  'pattern:*',          // Redis key pattern
+  0,                    // Page number
+  20,                   // Items per page
+  (record) => ({        // Optional transformer function
+    // Transform raw record to desired format
+    id: record.id,
+    name: record.name
+  })
+);
+
+// Returns:
+{
+  data: TransformedType[];
+  total: number;
+  page: number;
+  perPage: number;
+  hasMore: boolean;
+}
+```
+
+## Performance Optimizations
+
+### Redis Pipeline Usage
+
+All pagination methods use Redis pipelines to batch multiple GET operations, significantly improving performance when retrieving multiple records.
+
+```typescript
+// Instead of multiple individual calls:
+// const result1 = await redis.get(key1);
+// const result2 = await redis.get(key2);
+
+// We use pipelines:
+const pipeline = redis.pipeline();
+keys.forEach(key => pipeline.get(key));
+const results = await pipeline.exec();
+```
+
+### Efficient Scanning
+
+The implementation uses Redis SCAN operations with cursor-based iteration to efficiently handle large key spaces without blocking the Redis server.
+
+### Memory Management
+
+- Results are filtered and transformed only after pagination is applied
+- Large datasets are processed in chunks to prevent memory issues
+- Unnecessary data transformations are avoided for better performance
+
+## Example Usage
+
+### Basic Message Pagination
+
+```typescript
+// Get first page of messages with pagination metadata
+const page1 = await store.getMessages({
+  threadId: 'thread-123',
+  page: 0,
+  perPage: 20,
+  format: 'v2',
+});
+
+console.log(`Showing ${page1.messages.length} of ${page1.total} messages`);
+console.log(`Has more: ${page1.hasMore}`);
+
+// Backward compatible usage (no pagination metadata)
+const allMessages = await store.getMessages({
+  threadId: 'thread-123',
+  format: 'v2',
+});
+console.log(`Retrieved ${allMessages.length} messages`);
+```
+
+### Basic Evaluation Pagination
+
+```typescript
+// Get first page of evaluations for an agent
+const page1 = await store.getEvals({
+  agentName: 'my-agent',
+  page: 0,
+  perPage: 20,
+});
+
+console.log(`Showing ${page1.evals.length} of ${page1.total} evaluations`);
+console.log(`Has more: ${page1.hasMore}`);
+```
+
+### Date Range with Pagination
+
+```typescript
+// Get recent threads with pagination
+const recentThreads = await store.getThreads({
+  fromDate: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000), // Last 7 days
+  page: 0,
+  perPage: 10,
+});
+```
+
+### Filtered Traces with Pagination
+
+```typescript
+// Get production traces with specific attributes
+const prodTraces = await store.getTracesWithCount({
+  scope: 'production',
+  attributes: { environment: 'prod', service: 'api' },
+  page: 1,
+  perPage: 50,
+});
+```
+
+### Message Date Filtering
+
+```typescript
+// Get recent messages from a thread
+const recentMessages = await store.getMessages({
+  threadId: 'thread-123',
+  page: 0,
+  perPage: 10,
+  fromDate: new Date(Date.now() - 24 * 60 * 60 * 1000), // Last 24 hours
+  format: 'v2',
+});
+```
+
+## Best Practices
+
+1. **Use appropriate page sizes**: Start with 20-100 items per page depending on data size
+2. **Implement client-side caching**: Cache paginated results to reduce server load
+3. **Handle empty results**: Always check if the returned array is empty
+4. **Use date filters**: Combine pagination with date filters for better performance
+5. **Monitor total counts**: Use the `total` field to implement proper pagination UI
+6. **Choose the right pattern**: Use page/perPage for UI pagination, limit/offset for data processing
+7. **Leverage backward compatibility**: Existing `getMessages` calls work unchanged
+8. **Check return types**: Use TypeScript overloads to get proper type inference
+
+## Migration Guide
+
+The enhanced `getMessages` function is fully backward compatible. No changes are required for existing code, but you can opt into pagination features:
+
+### For Messages
+
+```typescript
+// Existing code (continues to work unchanged)
+const messages = await store.getMessages({
+  threadId: 'thread-123',
+  format: 'v2',
+});
+
+// Enhanced with pagination (new functionality)
+const result = await store.getMessages({
+  threadId: 'thread-123',
+  page: 0,
+  perPage: 20,
+  format: 'v2',
+});
+const messages = result.messages;
+const total = result.total;
+```
+
+### For Other Methods
+
+If you're using existing methods, they remain backward compatible. To take advantage of new pagination features:
+
+1. **Replace** `getEvalsByAgentName()` calls with `getEvals()` for better filtering and pagination
+2. **Replace** `getThreadsByResourceId()` calls with `getThreads()` for date filtering and total counts
+3. **Use** `getMessages()` with pagination parameters instead of complex `selectBy` logic when appropriate
+4. **Use** `getTracesWithCount()` instead of `getTraces()` when you need total counts
+
+Example migration:
+
+```typescript
+// Before:
+const evals = await store.getEvalsByAgentName('agent-name');
+
+// After:
+const result = await store.getEvals({
+  agentName: 'agent-name',
+  page: 0,
+  perPage: 20,
+});
+const evals = result.evals;
+const total = result.total;
+```

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

@@ -1,21 +1,39 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 import type { CreateIndexParams } from '@mastra/core/vector';
+import type { DeleteIndexParams } from '@mastra/core/vector';
+import type { DeleteVectorParams } from '@mastra/core/vector';
+import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { EvalRow } from '@mastra/core/storage';
+import type { IndexStats } from '@mastra/core/vector';
+import type { MastraMessageV1 } from '@mastra/core/memory';
+import type { MastraMessageV2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
-import type { MessageType } from '@mastra/core/memory';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
-import type { ParamsToArgs } from '@mastra/core/vector';
+import type { PaginationArgs } from '@mastra/core/storage';
+import type { PaginationInfo } from '@mastra/core/storage';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
 import type { StorageColumn } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageGetTracesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import type { TABLE_NAMES } from '@mastra/core/storage';
+import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
+import type { WorkflowRun } from '@mastra/core/storage';
+import type { WorkflowRuns } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 
+/**
+ * Vector store specific prompt that details supported operators and examples.
+ * This prompt helps users construct valid filters for Upstash Vector.
+ */
+declare const UPSTASH_PROMPT = "When querying Upstash Vector, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n\nLogical Operators:\n- $and: Logical AND (can be implicit or explicit)\n  Implicit Example: { \"price\": { \"$gt\": 100 }, \"category\": \"electronics\" }\n  Explicit Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nRestrictions:\n- Regex patterns are not supported\n- Only $and and $or logical operators are supported at the top level\n- Empty arrays in $in/$nin will return no results\n- Nested fields are supported using dot notation\n- Multiple conditions on the same field are supported with both implicit and explicit $and\n- At least one key-value pair is required in filter object\n- Empty objects and undefined values are treated as no filter\n- Invalid types in comparison operators will throw errors\n- All non-logical operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- Logical operators ($and, $or):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\n\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"rating\": { \"$exists\": true, \"$gt\": 4 } },\n    { \"$or\": [\n      { \"stock\": { \"$gt\": 0 } },\n      { \"preorder\": true }\n    ]}\n  ]\n}";
+export { UPSTASH_PROMPT }
+export { UPSTASH_PROMPT as UPSTASH_PROMPT_alias_1 }
+
 declare interface UpstashConfig {
     url: string;
     token: string;
@@ -38,30 +56,61 @@ export declare class UpstashFilterTranslator extends BaseFilterTranslator {
 }
 
 declare class UpstashStore extends MastraStorage {
-    batchInsert(_input: {
-        tableName: TABLE_NAMES;
-        records: Record<string, any>[];
-    }): Promise<void>;
-    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    private redis;
+    constructor(config: UpstashConfig);
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+    };
     private transformEvalRecord;
-    getTraces({ name, scope, page, perPage, attributes, filters, }?: {
+    private parseJSON;
+    private getKey;
+    /**
+     * Scans for keys matching the given pattern using SCAN and returns them as an array.
+     * @param pattern Redis key pattern, e.g. "table:*"
+     * @param batchSize Number of keys to scan per batch (default: 1000)
+     */
+    private scanKeys;
+    /**
+     * Deletes all keys matching the given pattern using SCAN and DEL in batches.
+     * @param pattern Redis key pattern, e.g. "table:*"
+     * @param batchSize Number of keys to delete per batch (default: 1000)
+     */
+    private scanAndDelete;
+    private getMessageKey;
+    private getThreadMessagesKey;
+    private parseWorkflowRun;
+    private processRecord;
+    /**
+     * @deprecated Use getEvals instead
+     */
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    /**
+     * @deprecated use getTracesPaginated instead
+     */
+    getTraces(args: StorageGetTracesArg): Promise<any[]>;
+    getTracesPaginated(args: {
         name?: string;
         scope?: string;
-        page: number;
-        perPage: number;
         attributes?: Record<string, string>;
         filters?: Record<string, any>;
-    }): Promise<any[]>;
-    private parseJSON;
-    private redis;
-    constructor(config: UpstashConfig);
-    private getKey;
-    private ensureDate;
-    private serializeDate;
+    } & PaginationArgs): Promise<PaginationInfo & {
+        traces: any[];
+    }>;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
+    /**
+     * No-op: This backend is schemaless and does not require schema changes.
+     * @param tableName Name of the table
+     * @param schema Schema of the table
+     * @param ifNotExists Array of column names to add if they don't exist
+     */
+    alterTable(_args: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
@@ -69,6 +118,10 @@ declare class UpstashStore extends MastraStorage {
         tableName: TABLE_NAMES;
         record: Record<string, any>;
     }): Promise<void>;
+    batchInsert(input: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
     load<R>({ tableName, keys }: {
         tableName: TABLE_NAMES;
         keys: Record<string, string>;
@@ -76,9 +129,17 @@ declare class UpstashStore extends MastraStorage {
     getThreadById({ threadId }: {
         threadId: string;
     }): Promise<StorageThreadType | null>;
+    /**
+     * @deprecated use getThreadsByResourceIdPaginated instead
+     */
     getThreadsByResourceId({ resourceId }: {
         resourceId: string;
     }): Promise<StorageThreadType[]>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+    } & PaginationArgs): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
     saveThread({ thread }: {
         thread: StorageThreadType;
     }): Promise<StorageThreadType>;
@@ -90,12 +151,29 @@ declare class UpstashStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    private getMessageKey;
-    private getThreadMessagesKey;
-    saveMessages({ messages }: {
-        messages: MessageType[];
-    }): Promise<MessageType[]>;
-    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    private _getIncludedMessages;
+    /**
+     * @deprecated use getMessagesPaginated instead
+     */
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
     persistWorkflowSnapshot(params: {
         namespace: string;
         workflowName: string;
@@ -107,23 +185,31 @@ declare class UpstashStore extends MastraStorage {
         workflowName: string;
         runId: string;
     }): Promise<WorkflowRunState | null>;
-    getWorkflowRuns({ namespace, workflowName, fromDate, toDate, limit, offset, }?: {
+    /**
+     * Get all evaluations with pagination and total count
+     * @param options Pagination and filtering options
+     * @returns Object with evals array and total count
+     */
+    getEvals(options?: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+    getWorkflowRuns({ namespace, workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
         namespace: string;
         workflowName?: string;
         fromDate?: Date;
         toDate?: Date;
         limit?: number;
         offset?: number;
-    }): Promise<{
-        runs: Array<{
-            workflowName: string;
-            runId: string;
-            snapshot: WorkflowRunState | string;
-            createdAt: Date;
-            updatedAt: Date;
-        }>;
-        total: number;
-    }>;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById({ namespace, runId, workflowName, }: {
+        namespace: string;
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
     close(): Promise<void>;
 }
 export { UpstashStore }
@@ -135,22 +221,38 @@ declare class UpstashVector extends MastraVector {
         url: string;
         token: string;
     });
-    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    upsert({ indexName, vectors, metadata, ids }: UpsertVectorParams): Promise<string[]>;
     transformFilter(filter?: VectorFilter): string | undefined;
-    createIndex(..._args: ParamsToArgs<CreateIndexParams>): Promise<void>;
-    query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]>;
+    createIndex(_params: CreateIndexParams): Promise<void>;
+    query({ indexName, queryVector, topK, filter, includeVector, }: QueryVectorParams): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
-    describeIndex(indexName: string): Promise<{
-        dimension: number;
-        count: number;
-        metric: "cosine" | "euclidean" | "dotproduct";
-    }>;
-    deleteIndex(indexName: string): Promise<void>;
-    updateIndexById(indexName: string, id: string, update: {
-        vector?: number[];
-        metadata?: Record<string, any>;
-    }): Promise<void>;
-    deleteIndexById(indexName: string, id: string): Promise<void>;
+    /**
+     * Retrieves statistics about a vector index.
+     *
+     * @param {string} indexName - The name of the index to describe
+     * @returns A promise that resolves to the index statistics including dimension, count and metric
+     */
+    describeIndex({ indexName }: DescribeIndexParams): Promise<IndexStats>;
+    deleteIndex({ indexName }: DeleteIndexParams): Promise<void>;
+    /**
+     * Updates a vector by its ID with the provided vector and/or metadata.
+     * @param indexName - The name of the index containing the vector.
+     * @param id - The ID of the vector to update.
+     * @param update - An object containing the vector and/or metadata to update.
+     * @param update.vector - An optional array of numbers representing the new vector.
+     * @param update.metadata - An optional record containing the new metadata.
+     * @returns A promise that resolves when the update is complete.
+     * @throws Will throw an error if no updates are provided or if the update operation fails.
+     */
+    updateVector({ indexName, id, update }: UpdateVectorParams): Promise<void>;
+    /**
+     * Deletes a vector by its ID.
+     * @param indexName - The name of the index containing the vector.
+     * @param id - The ID of the vector to delete.
+     * @returns A promise that resolves when the deletion is complete.
+     * @throws Will throw an error if the deletion operation fails.
+     */
+    deleteVector({ indexName, id }: DeleteVectorParams): Promise<void>;
 }
 export { UpstashVector }
 export { UpstashVector as UpstashVector_alias_1 }