@mastra/libsql 1.27.1 → 1.28.0

package/README.md

@@ -49,7 +49,7 @@ const results = await vectorStore.query({
 
 ## Documentation
 
-- [@mastra/libsql documentation](https://mastra.ai/reference/vectors/libsql)
+- [@mastra/libsql documentation](https://mastra.ai/integrations/vectors/libsql)
 
 ## Changelog
 

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-libsql
 description: Documentation for @mastra/libsql. Use when working with @mastra/libsql APIs, configuration, or implementation.
 metadata:
   package: "@mastra/libsql"
-  version: "1.27.1"
+  version: "1.28.0"
 ---
 
 ## When to use
@@ -35,6 +35,7 @@ Read the individual reference documents for detailed explanations and code examp
 - [GitHub](references/integrations-channels-github.md) - Subscribe Mastra agents to GitHub pull requests with @mastra/github-signals, polling modes, notification signals, and subscription management tools.
 - [DynamoDB](references/integrations-databases-dynamodb.md) - Persist Mastra data in Amazon DynamoDB with a single-table ElectroDB design, configurable indexes, TTL support, credentials, and table initialization.
 - [libSQL](references/integrations-databases-libsql.md) - Persist Mastra messages, workflow snapshots, traces, and eval scores in local or remote libSQL with managed tables and initialization options.
+- [libSQL](references/integrations-vectors-libsql.md) - Store embeddings in a local libSQL database or Turso and run similarity search with metadata filtering from Mastra.
 
 ### Reference
 
@@ -48,7 +49,6 @@ Read the individual reference documents for detailed explanations and code examp
 - [Retrieval, semantic search, reranking](references/reference-rag-retrieval.md) - After storing embeddings, you need to retrieve relevant chunks to answer user queries.
 - [Reference: Composite storage](references/reference-storage-composite.md) - MastraCompositeStore can compose storage domains from different providers. Use it when you need different databases for different purposes.
 - [Reference: Storage retention (prune)](references/reference-storage-retention.md) - prune() deletes rows. It caps growth and is safe to run against large tables (batched, bounded, resumable, cancellable).
-- [Reference: libSQL vector store](references/reference-vectors-libsql.md) - Configure LibSQLVector for similarity search and metadata filtering with local libSQL, SQLite-compatible vector extensions, or Turso databases.
 
 
 Read [assets/SOURCE_MAP.json](assets/SOURCE_MAP.json) for source code references.

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.27.1",
+  "version": "1.28.0",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-agents-human-in-the-loop.md

@@ -116,7 +116,7 @@ const stream = await agent.stream('Clean up old records', {
 })
 ```
 
-The function can be asynchronous. For decisions that depend on the tool name and arguments, use a [classifier](https://mastra.ai/reference/classifier/classifier) to estimate whether the call needs human review:
+The function can be asynchronous. For decisions that depend on the tool name and arguments, use a [classifier](https://mastra.ai/docs/classifier) to estimate whether the call needs human review:
 
 ```typescript
 import { Classifier } from '@mastra/core/classifier'
@@ -589,6 +589,31 @@ A [supervisor agent](https://mastra.ai/docs/subagents) coordinates multiple suba
 
 Tool approvals also propagate through multiple levels of delegation. If a supervisor delegates to subagent A, which delegates to subagent B that has a tool with `requireApproval: true`, the approval request still surfaces at the top-level supervisor.
 
+### Identify which subagent tool paused
+
+The supervisor raises a subagent's pause on its own delegation call, so `toolCallId` on the `tool-call-approval` or `tool-call-suspended` chunk is the supervisor's call to the subagent. Always pass that `toolCallId` when you approve, decline, or resume.
+
+To show which of the subagent's tool calls paused, read these fields from the same payload:
+
+- `delegatedToolCallId`: The ID of the subagent's tool call that paused. Use it to tell apart two pauses from the same delegation, such as a question followed by an approval.
+- `delegatedToolName`: The name of the subagent's tool that paused.
+
+With several levels of delegation, both fields name the deepest tool call, the one that actually paused. Memory saves them with the pause, so they're still there when you reload the conversation, and `generate()` returns them on `suspendPayload`.
+
+```typescript
+const stream = await supervisorAgent.stream('Draft and publish the report')
+
+for await (const chunk of stream.fullStream) {
+  if (chunk.type === 'tool-call-approval' || chunk.type === 'tool-call-suspended') {
+    // Label the pause with the subagent tool call that caused it
+    console.log('Paused:', chunk.payload.delegatedToolName, chunk.payload.delegatedToolCallId)
+
+    // Pass the supervisor's delegation call when you approve, decline, or resume
+    console.log('Resume with:', chunk.payload.toolCallId)
+  }
+}
+```
+
 ### Approve and decline in supervisor agents
 
 The example below creates a subagent with a tool requiring approval. When the tool triggers an approval request, it surfaces in the supervisor's stream as a `tool-call-approval` chunk:

package/dist/docs/references/docs-memory-memory-processors.md

@@ -12,13 +12,13 @@ Memory processors are [processors](https://mastra.ai/docs/agents/processors) tha
 
 ## Built-in memory processors
 
-Mastra automatically adds these processors when memory is enabled:
+Mastra automatically adds these processors when memory is enabled. `MemoryInputFilter` is added only when a memory store is available and stored history will be loaded:
 
 ### `MemoryInputFilter`
 
-Trims client-echoed history before memory loaders run. For an existing thread, it keeps only the current user turn or new tool results. For an empty thread, it keeps the full initial input and removes provider item metadata from assistant parts that could refer to items that don't exist in storage.
+Trims client-echoed history before memory loaders run. For an existing thread, it keeps only the current user turn or new tool results. For an empty thread, it keeps the full initial input and removes provider item metadata from assistant parts that could refer to items that don't exist in storage. When `retainFullInput: true` is set, it skips both the trim and the metadata strip and processes the input exactly as supplied, while stored history still loads.
 
-This processor runs first so `MessageHistory`, `SemanticRecall`, and Observational Memory receive only the new input they need.
+By default, this processor runs first so `MessageHistory`, `SemanticRecall`, and Observational Memory receive only the new input they need.
 
 ### `MessageHistory`
 
@@ -320,6 +320,52 @@ const agent = new Agent({
 
 Both scenarios are safe - guardrails prevent inappropriate content from being persisted to memory
 
+## Aborted runs and saved messages
+
+Cancelling a run and blocking it with a processor `abort()` both stop generation, but they save different things:
+
+| What stops the run            | Memory processors | What's persisted                                             |
+| ----------------------------- | ----------------- | ------------------------------------------------------------ |
+| `abortSignal` from the caller | Still run         | The user message and the assistant text the user already saw |
+| `abort()` inside a processor  | Skipped           | Nothing; the tripwire blocks the save                        |
+
+A caller cancellation goes through output processors like any other run, so the built-in `MessageHistory` processor saves the thread. The partial answer is stored as an ordinary assistant message with no error part, which means the next turn starts from what the user actually read.
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+
+const memory = new Memory({ options: { lastMessages: 20 } })
+const agent = new Agent({
+  id: 'writer',
+  name: 'writer',
+  instructions: 'You write step-by-step migration guides.',
+  model: 'openai/gpt-6.1-sol',
+  memory,
+})
+
+const controller = new AbortController()
+const stream = await agent.stream('Write the migration guide.', {
+  memory: { thread: 'thread-1', resource: 'user-1' },
+  abortSignal: controller.signal,
+  onAbort: ({ steps, text }) => {
+    console.log(`Aborted after ${steps.length} steps with ${text?.length ?? 0} characters streamed`)
+  },
+})
+
+let streamed = ''
+for await (const chunk of stream.fullStream) {
+  if (chunk.type !== 'text-delta') continue
+  streamed += chunk.payload.text
+  if (streamed.length > 200) controller.abort()
+}
+
+// The partial answer is already in the thread
+const { messages } = await memory.recall({ threadId: 'thread-1', resourceId: 'user-1' })
+```
+
+`onAbort` receives the steps that completed before the cancellation and the assistant text streamed for the in-flight step. For the abort lifecycle itself, including durable runs aborted by `runId`, see the [`stream()` reference](https://mastra.ai/reference/streaming/agents/stream).
+
 ## Handling large attachments
 
 Some storage providers enforce record size limits that base64-encoded file attachments can exceed:

package/dist/docs/references/docs-memory-semantic-recall.md

@@ -141,24 +141,24 @@ const agent = new Agent({
 
 Each vector store page below includes installation instructions, configuration parameters, and usage examples:
 
-- [Astra](https://mastra.ai/reference/vectors/astra)
-- [Chroma](https://mastra.ai/reference/vectors/chroma)
-- [Cloudflare Vectorize](https://mastra.ai/reference/vectors/vectorize)
-- [Convex](https://mastra.ai/reference/vectors/convex)
-- [Couchbase](https://mastra.ai/reference/vectors/couchbase)
-- [DuckDB](https://mastra.ai/reference/vectors/duckdb)
-- [Elasticsearch](https://mastra.ai/reference/vectors/elasticsearch)
-- [LanceDB](https://mastra.ai/reference/vectors/lance)
-- [libSQL](https://mastra.ai/reference/vectors/libsql)
-- [MongoDB](https://mastra.ai/reference/vectors/mongodb)
-- [OpenSearch](https://mastra.ai/reference/vectors/opensearch)
-- [OracleDB](https://mastra.ai/reference/vectors/oracledb)
-- [Pinecone](https://mastra.ai/reference/vectors/pinecone)
-- [PostgreSQL](https://mastra.ai/reference/vectors/pg)
-- [Qdrant](https://mastra.ai/reference/vectors/qdrant)
-- [S3 Vectors](https://mastra.ai/reference/vectors/s3vectors)
-- [Turbopuffer](https://mastra.ai/reference/vectors/turbopuffer)
-- [Upstash](https://mastra.ai/reference/vectors/upstash)
+- [Astra](https://mastra.ai/integrations/vectors/astra)
+- [Chroma](https://mastra.ai/integrations/vectors/chroma)
+- [Cloudflare Vectorize](https://mastra.ai/integrations/vectors/vectorize)
+- [Convex](https://mastra.ai/integrations/vectors/convex)
+- [Couchbase](https://mastra.ai/integrations/vectors/couchbase)
+- [DuckDB](https://mastra.ai/integrations/vectors/duckdb)
+- [Elasticsearch](https://mastra.ai/integrations/vectors/elasticsearch)
+- [LanceDB](https://mastra.ai/integrations/vectors/lance)
+- [libSQL](https://mastra.ai/integrations/vectors/libsql)
+- [MongoDB](https://mastra.ai/integrations/vectors/mongodb)
+- [OpenSearch](https://mastra.ai/integrations/vectors/opensearch)
+- [OracleDB](https://mastra.ai/integrations/vectors/oracledb)
+- [Pinecone](https://mastra.ai/integrations/vectors/pinecone)
+- [PostgreSQL](https://mastra.ai/integrations/vectors/pg)
+- [Qdrant](https://mastra.ai/integrations/vectors/qdrant)
+- [S3 Vectors](https://mastra.ai/integrations/vectors/s3vectors)
+- [Turbopuffer](https://mastra.ai/integrations/vectors/turbopuffer)
+- [Upstash](https://mastra.ai/integrations/vectors/upstash)
 
 ## Recall configuration
 
@@ -250,7 +250,7 @@ const options = {
 
 Some vector stores generate the embeddings themselves. With one of those, semantic recall runs without an `embedder`: the database embeds each message on write and the search string on arrival. The embedding provider stays out of your application entirely.
 
-MongoDB does this through [Automated Embedding](https://mastra.ai/reference/vectors/mongodb): name a Voyage AI model on the vector store and leave the `embedder` out.
+MongoDB does this through [Automated Embedding](https://mastra.ai/integrations/vectors/mongodb): name a Voyage AI model on the vector store and leave the `embedder` out.
 
 ```typescript
 import { Memory } from '@mastra/memory'
@@ -435,6 +435,8 @@ When using PostgreSQL as your vector store, you can optimize semantic recall per
 
 PostgreSQL supports both IVFFlat and HNSW indexes. By default, Mastra creates an IVFFlat index, but HNSW indexes typically provide better performance, especially with OpenAI embeddings which use inner product distance.
 
+Semantic recall always filters by thread or resource. PgVector uses the vector index for these searches only with HNSW on pgvector 0.8.0 or newer. With IVFFlat, each search compares the query against every message in the thread or resource.
+
 ```typescript
 import { Memory } from '@mastra/memory'
 import { PostgresStore, PgVector } from '@mastra/pg'
@@ -467,7 +469,7 @@ const agent = new Agent({
 })
 ```
 
-For detailed information about index configuration options and performance tuning, see the [PgVector configuration guide](https://mastra.ai/reference/vectors/pg).
+For detailed information about index configuration options and performance tuning, see the [PgVector configuration guide](https://mastra.ai/integrations/vectors/pg).
 
 ## Disable semantic recall
 

package/dist/docs/references/integrations-databases-libsql.md

@@ -6,7 +6,7 @@
 
 [libSQL](https://docs.turso.tech/libsql) is an open-source, SQLite-compatible database that supports both local and remote deployments. It can be used to store message history, workflow snapshots, traces, and eval scores.
 
-For vectors like semantic recall or traditional RAG, use [libSQL Vector](https://mastra.ai/reference/vectors/libsql) which covers embeddings and vector search.
+For vectors like semantic recall or traditional RAG, use [libSQL Vector](https://mastra.ai/integrations/vectors/libsql) which covers embeddings and vector search.
 
 ## Installation
 

package/dist/docs/references/{reference-vectors-libsql.md → integrations-vectors-libsql.md}

@@ -75,6 +75,8 @@ const results = await store.query({
 
 ## Constructor options
 
+**id** (`string`): Unique identifier for this vector store instance
+
 **url** (`string`): libSQL database URL. Use ':memory:' for in-memory database, 'file:dbname.db' for local file, or a libSQL-compatible connection string like 'libsql://your-database.turso.io'.
 
 **authToken** (`string`): Authentication token for Turso cloud databases
@@ -83,6 +85,12 @@ const results = await store.query({
 
 **syncInterval** (`number`): Interval in milliseconds for database sync (Turso specific)
 
+**maxRetries** (`number`): Total attempts allowed for a write that hits a database lock (SQLITE_BUSY, SQLITE_LOCKED, or a "database is locked" error). The default of 5 means one attempt plus at most four retries. Use at least 1: with 0 the write is never attempted and the call throws (Default: `5`)
+
+**initialBackoffMs** (`number`): Backoff before the first retry, in milliseconds. Each later retry waits twice as long (Default: `100`)
+
+**vectorTopKOverFetchMultiplier** (`number`): Over-fetch multiplier for vector_top_k queries that have metadata filters. Higher values improve recall at the cost of scanning more rows. Must be a positive integer, or the constructor throws (Default: `10`)
+
 ## Methods
 
 ### `createIndex()`
@@ -191,6 +199,14 @@ Delete multiple vectors by IDs or by metadata filter. Either `ids` or `filter` m
 
 **filter** (`Record<string, any>`): Metadata filter to identify vectors to delete (mutually exclusive with ids)
 
+### `close()`
+
+Closes the underlying libSQL client and releases the file handles this vector store holds. Calling it more than once is a no-op.
+
+```typescript
+await store.close()
+```
+
 ## Response types
 
 Query results are returned in this format:

package/dist/docs/references/reference-core-mastra-class.md

@@ -77,7 +77,7 @@ Visit the [Configuration reference](https://mastra.ai/reference/configuration) f
 
 **environment** (`string`): Deployment environment name (e.g. production, staging, development). When set, automatically attached to all observability signals so they can be filtered by environment without passing tracingOptions.metadata.environment on each call. When unset, resolves to development for mastra dev runs, then falls back to process.env.NODE_ENV; left undefined if none are set. Per-call tracingOptions.metadata.environment always takes precedence.
 
-**deployer** (`MastraDeployer`): An instance of a MastraDeployer for managing deployments.
+**deployer** (`IDeployer`): A deployer for managing deployments, such as VercelDeployer from @mastra/deployer-vercel.
 
 **server** (`ServerConfig`): Server configuration including port, host, timeout, API routes, middleware, CORS settings, and build options for Swagger UI, API request logging, and OpenAPI docs.
 
@@ -123,6 +123,8 @@ Visit the [Configuration reference](https://mastra.ai/reference/configuration) f
 
 **backgroundTasks.perAgentConcurrency** (`number`): Max concurrent tasks per agent.
 
+**backgroundTasks.perOwnerConcurrency** (`Record<string, number>`): Per-owner overrides of perAgentConcurrency, keyed by agentId. Overridden owners still count toward globalConcurrency.
+
 **backgroundTasks.backpressure** (`'queue' | 'reject' | 'fallback-sync'`): Behavior when concurrency limit is reached.
 
 **backgroundTasks.defaultTimeoutMs** (`number`): Default task timeout in milliseconds.

package/dist/docs/references/reference-memory-memory-class.md

@@ -61,6 +61,83 @@ export const agent = new Agent({
 
 **memory** (`Memory`): A new Memory instance with the specified configuration.
 
+## `saveMessages()`
+
+`agent.generate()` and `agent.stream()` persist messages for you. Call `memory.saveMessages()` when you need to write messages yourself, for example to seed a thread, to import a transcript, or to store messages that originated outside Mastra. Each message needs a `threadId` and a `resourceId`, so create the thread with [`createThread()`](https://mastra.ai/reference/memory/createThread) before saving into it.
+
+```typescript
+await memory.saveMessages({
+  messages: [
+    {
+      id: 'msg-1',
+      threadId: 'thread-123',
+      resourceId: 'user-456',
+      role: 'user',
+      createdAt: new Date(),
+      content: {
+        format: 2,
+        parts: [{ type: 'text', text: 'Where is my order?' }],
+      },
+    },
+  ],
+})
+```
+
+### Parameters
+
+**messages** (`MastraDBMessage[]`): The messages to save. Every message must include a threadId and a resourceId.
+
+**memoryConfig** (`MemoryConfig`): Per-call memory options. Merged over the options passed to the constructor.
+
+**observabilityContext** (`Partial<ObservabilityContext>`): Tracing context attached to the save operation.
+
+Returns `Promise<{ messages: MastraDBMessage[]; usage?: { tokens: number } }>`. `usage` is present when the embedder reports token usage while indexing messages for semantic recall.
+
+### `MastraDBMessage`
+
+Storage uses a single message shape, `MastraDBMessage`. The methods that hand messages back or take them in use this shape, including `saveMessages()` and [`recall()`](https://mastra.ai/reference/memory/recall).
+
+**id** (`string`): Message identifier.
+
+**role** (`'user' | 'assistant' | 'system' | 'signal'`): Who produced the message. System messages and transient signals are not persisted.
+
+**threadId** (`string`): Thread the message belongs to. Required when saving.
+
+**resourceId** (`string`): Resource (usually a user or tenant) the message belongs to. Required when saving.
+
+**createdAt** (`Date`): Message timestamp.
+
+**content** (`MastraMessageContentV2`): The message body. Its parts array holds the text, reasoning, tool calls, and attachments.
+
+`content.parts` is the part the agent actually reads. `content.format` is always `2` for stored messages, and `content.metadata` carries arbitrary custom data. `content.toolInvocations`, `content.reasoning`, and `content.experimental_attachments` are flat mirrors kept for AI SDK v4 compatibility; write to `parts` instead.
+
+```typescript
+const assistantMessage = {
+  id: 'msg-2',
+  threadId: 'thread-123',
+  resourceId: 'user-456',
+  role: 'assistant',
+  createdAt: new Date(),
+  content: {
+    format: 2,
+    parts: [
+      { type: 'text', text: 'It ships tomorrow.' },
+      {
+        type: 'tool-invocation',
+        toolInvocation: {
+          state: 'result',
+          toolCallId: 'call-1',
+          toolName: 'lookupOrder',
+          args: { orderId: 'A-1' },
+          result: { eta: '2026-10-30' },
+        },
+      },
+    ],
+    metadata: { source: 'import' },
+  },
+}
+```
+
 ## Extended usage example
 
 ```typescript

package/dist/docs/references/reference-rag-retrieval.md

@@ -251,7 +251,11 @@ const results = await pgVector.query({
 })
 ```
 
-Postgres vector indexes (HNSW and IVFFlat) can't restrict that search to rows matching a condition. When a filter is present, pgVector instead compares the query vector against every matching row and returns the closest `topK`. Results are exact, but the work grows with the number of rows the filter matches. Indexing the metadata column speeds up row retrieval. The distance comparisons still happen per row.
+With an HNSW index on pgvector 0.8.0 or newer, PostgreSQL searches the index and skips rows that don't match the filter. When the index search can't fill `topK`, pgVector reruns the query as an exact search.
+
+With IVFFlat, or HNSW on older pgvector versions, pgVector compares the query vector against every matching row. Results are exact, but the work grows with the number of matching rows.
+
+Indexing the metadata fields you filter on speeds up both cases and gives PostgreSQL the row counts it needs to choose between them.
 
 ### Vector Query Tool
 

package/dist/index.cjs

@@ -3426,10 +3426,13 @@ function rowToTask(row) {
 		suspendedAt: row.suspendedAt ? new Date(String(row.suspendedAt)) : void 0,
 		completedAt: row.completedAt ? new Date(String(row.completedAt)) : void 0,
 		ownerId: row.ownerId != null ? String(row.ownerId) : void 0,
-		leaseExpiresAt: row.leaseExpiresAt ? new Date(String(row.leaseExpiresAt)) : void 0
+		leaseExpiresAt: row.leaseExpiresAt ? new Date(String(row.leaseExpiresAt)) : void 0,
+		expiresAt: row.expiresAt ? new Date(String(row.expiresAt)) : void 0,
+		metadata: parseJson$4(row.metadata)
 	};
 }
 var BackgroundTasksLibSQL = class BackgroundTasksLibSQL extends _mastra_core_storage.BackgroundTasksStorage {
+	supportsTaskExpiry = true;
 	/**
 	* Completed/failed task records accumulate. Anchored on `completedAt`, which
 	* is NULL while a task is in-flight (pending/running/suspended) — so `completedAt
@@ -3464,7 +3467,9 @@ var BackgroundTasksLibSQL = class BackgroundTasksLibSQL extends _mastra_core_sto
 				"suspend_payload",
 				"suspendedAt",
 				"ownerId",
-				"leaseExpiresAt"
+				"leaseExpiresAt",
+				"expiresAt",
+				"metadata"
 			]
 		});
 	}
@@ -3510,7 +3515,9 @@ var BackgroundTasksLibSQL = class BackgroundTasksLibSQL extends _mastra_core_sto
 				suspendedAt: task.suspendedAt?.toISOString() ?? null,
 				completedAt: task.completedAt?.toISOString() ?? null,
 				ownerId: task.ownerId ?? null,
-				leaseExpiresAt: task.leaseExpiresAt?.toISOString() ?? null
+				leaseExpiresAt: task.leaseExpiresAt?.toISOString() ?? null,
+				expiresAt: task.expiresAt?.toISOString() ?? null,
+				metadata: task.metadata ?? null
 			}
 		});
 	}
@@ -3557,6 +3564,14 @@ var BackgroundTasksLibSQL = class BackgroundTasksLibSQL extends _mastra_core_sto
 			setClauses.push("leaseExpiresAt = ?");
 			params.push(update.leaseExpiresAt?.toISOString() ?? null);
 		}
+		if ("expiresAt" in update) {
+			setClauses.push("expiresAt = ?");
+			params.push(update.expiresAt?.toISOString() ?? null);
+		}
+		if ("metadata" in update) {
+			setClauses.push("metadata = jsonb(?)");
+			params.push(serializeJson(update.metadata));
+		}
 		if (setClauses.length === 0) return false;
 		params.push(taskId);
 		let where = "id = ?";
@@ -3578,6 +3593,13 @@ var BackgroundTasksLibSQL = class BackgroundTasksLibSQL extends _mastra_core_sto
 				params.push(options.expectedLeaseExpiresAt.toISOString());
 			}
 		}
+		if (options?.expectedSuspendedAt !== void 0) {
+			if (options.expectedSuspendedAt === null) where += " AND suspendedAt IS NULL";
+			else {
+				where += " AND suspendedAt = ?";
+				params.push(options.expectedSuspendedAt.toISOString());
+			}
+		}
 		return (await this.#client.execute({
 			sql: `UPDATE ${_mastra_core_storage.TABLE_BACKGROUND_TASKS} SET ${setClauses.join(", ")} WHERE ${where}`,
 			args: params
@@ -3622,7 +3644,8 @@ var BackgroundTasksLibSQL = class BackgroundTasksLibSQL extends _mastra_core_sto
 			conditions.push("tool_call_id = ?");
 			params.push(filter.toolCallId);
 		}
-		const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "suspendedAt" ? "suspendedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : "createdAt";
+		const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "suspendedAt" ? "suspendedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : filter.dateFilterBy === "expiresAt" ? "expiresAt" : "createdAt";
+		if (filter.hasExpiresAt !== void 0) conditions.push(filter.hasExpiresAt ? "expiresAt IS NOT NULL" : "expiresAt IS NULL");
 		if (filter.fromDate) {
 			conditions.push(`${dateCol} >= ?`);
 			params.push(filter.fromDate.toISOString());
@@ -3670,7 +3693,8 @@ var BackgroundTasksLibSQL = class BackgroundTasksLibSQL extends _mastra_core_sto
 			conditions.push(`status IN (${statuses.map(() => "?").join(", ")})`);
 			params.push(...statuses);
 		}
-		const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "suspendedAt" ? "suspendedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : "createdAt";
+		const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "suspendedAt" ? "suspendedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : filter.dateFilterBy === "expiresAt" ? "expiresAt" : "createdAt";
+		if (filter.hasExpiresAt !== void 0) conditions.push(filter.hasExpiresAt ? "expiresAt IS NOT NULL" : "expiresAt IS NULL");
 		if (filter.fromDate) {
 			conditions.push(`${dateCol} >= ?`);
 			params.push(filter.fromDate.toISOString());