@mastra/libsql 1.11.1 → 1.12.0-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,60 @@
 # @mastra/libsql
 
+## 1.12.0-alpha.0
+
+### Minor Changes
+
+- Added the `tool_provider_connections` storage domain. Stored agents can now persist per-agent ToolProvider config that round-trips on read/write/create. Runtime connection resolution (per-author, shared, caller-supplied) ships in a follow-up PR. ([#17247](https://github.com/mastra-ai/mastra/pull/17247))
+
+  **What you can do**
+  - Pin a connection on a stored agent's config and have it round-trip on read/write/create.
+  - Persist multiple connections per toolkit so a follow-up runtime PR can fan-out to the right one at execution time.
+
+  **Example**
+
+  ```ts
+  import { LibSQLStore } from '@mastra/libsql';
+
+  const storage = new LibSQLStore({ url: process.env.DATABASE_URL });
+
+  // Persist an OAuth connection that an agent can pin later
+  await storage.toolProviders.upsertConnection({
+    authorId: 'user-123',
+    providerId: 'composio',
+    connectionId: 'auth_abc',
+    toolkit: 'gmail',
+    label: 'Work inbox',
+    scope: 'per-author',
+  });
+
+  // List a user's own connections (admin can omit authorId to list across users)
+  const { items } = await storage.toolProviders.listConnectionsByAuthor({
+    authorId: 'user-123',
+    providerId: 'composio',
+  });
+  ```
+
+  Additive — existing stored agents continue to work unchanged. The runtime that consumes this domain ships in a follow-up PR.
+
+  PR 1 of 3 split from #17224.
+
+### Patch Changes
+
+- Added a public `close()` method to `LibSQLStore` that releases SQLite file handles and cleans up the WAL/shm sidecar files. Previously these handles stayed open until the process exited, which on Windows caused `EBUSY` errors when removing the storage directory after shutdown. `Mastra.shutdown()` now calls `close()` automatically, so you no longer need to reach into private fields. ([#17306](https://github.com/mastra-ai/mastra/pull/17306))
+
+  ```typescript
+  const storage = new LibSQLStore({ id: 'my-store', url: 'file:./dev.db' });
+
+  // Release all file handles, including WAL/shm sidecar files
+  await storage.close();
+
+  // Now safe to remove the storage directory on all platforms, including Windows
+  await fs.rm('./dev.db', { recursive: true, force: true });
+  ```
+
+- Updated dependencies [[`8ace89d`](https://github.com/mastra-ai/mastra/commit/8ace89df77f762e622d3b9f7f65ad7524350d050), [`fa63872`](https://github.com/mastra-ai/mastra/commit/fa6387280954e6b667bec5714b55ba082bc627ff), [`f07b646`](https://github.com/mastra-ai/mastra/commit/f07b64604ab7d25391179790b7fd4823df9e2dff), [`d8838ae`](https://github.com/mastra-ai/mastra/commit/d8838ae80b69780361693d27098f7f6684af12fe), [`40f9297`](https://github.com/mastra-ai/mastra/commit/40f9297003b921c62373d3e8d3a4bda76c9f6de3), [`0f0d1ba`](https://github.com/mastra-ai/mastra/commit/0f0d1ba67bfcb2204e571401662f1eceefc03357), [`8c31bcd`](https://github.com/mastra-ai/mastra/commit/8c31bcdb00e597880d5939b1b7d7566fbe5dacae), [`95b14cd`](https://github.com/mastra-ai/mastra/commit/95b14cdd820e86d97ac05fe568424c513a252e31), [`aa36be2`](https://github.com/mastra-ai/mastra/commit/aa36be23aa513b7dc53cb8ca16b7fab8f20e43ad), [`212c635`](https://github.com/mastra-ai/mastra/commit/212c635203e61d036ab41db8ff86c3893dc795b3), [`d8838ae`](https://github.com/mastra-ai/mastra/commit/d8838ae80b69780361693d27098f7f6684af12fe), [`9aa5a73`](https://github.com/mastra-ai/mastra/commit/9aa5a73e7e110f6e9365eec69364a33d5f03bb56), [`f73c789`](https://github.com/mastra-ai/mastra/commit/f73c789e8ef21561580395d2c410119cab5848c8), [`8bd16da`](https://github.com/mastra-ai/mastra/commit/8bd16da73a4cb874d739373643dbd6a6e7f88684), [`c8630f8`](https://github.com/mastra-ai/mastra/commit/c8630f80d4f40cb5d22e60ab162b618b1907167a), [`47f71dc`](https://github.com/mastra-ai/mastra/commit/47f71dc6fbcbd12d71e21a979e676e20a02bd77d), [`50ceae2`](https://github.com/mastra-ai/mastra/commit/50ceae270878e2f8fb2b2c6c2faab09df0007c8a), [`8cdde58`](https://github.com/mastra-ai/mastra/commit/8cdde5875bbba6702d9df226f2b20232b8d75d6c), [`847ff1e`](https://github.com/mastra-ai/mastra/commit/847ff1e0d94368d94b2e173e4e0908e115568ef3), [`259d409`](https://github.com/mastra-ai/mastra/commit/259d409a514174299dbde1ff5e1121209b3ba850), [`9e16c68`](https://github.com/mastra-ai/mastra/commit/9e16c6818b6485ccb43df28aba6f3a2219d28662), [`cefca33`](https://github.com/mastra-ai/mastra/commit/cefca33ae666e69810c935fedf95a929c173d1d7), [`d00e8c5`](https://github.com/mastra-ai/mastra/commit/d00e8c50daebe5bce5bf2f48bde39c86fc3d2fe4), [`36fa7e2`](https://github.com/mastra-ai/mastra/commit/36fa7e24d14e58a1eb46147097b32f583e5b8775), [`87e9774`](https://github.com/mastra-ai/mastra/commit/87e97741c1e493cd6d62f478eb810b49bda4d57c), [`65a72e7`](https://github.com/mastra-ai/mastra/commit/65a72e70c25eedea8ff985a6624b96be2850236b), [`0f77241`](https://github.com/mastra-ai/mastra/commit/0f7724108806703799a8ba80ad0f09414afd5066), [`92ff509`](https://github.com/mastra-ai/mastra/commit/92ff5098ef8a990438ca038077021a5f7541ec1d), [`3fce5e7`](https://github.com/mastra-ai/mastra/commit/3fce5e70d011d289043e75003ef3336ed4aa43c3), [`a763592`](https://github.com/mastra-ai/mastra/commit/a763592c3db46963ef1011cfe16fe372816e775e), [`80c7737`](https://github.com/mastra-ai/mastra/commit/80c7737e32d7917b5f356957d67c169d01744fd3), [`3f1cf47`](https://github.com/mastra-ai/mastra/commit/3f1cf476f74c1e4cc2df908837e05853a5347e31)]:
+  - @mastra/core@1.38.0-alpha.3
+
 ## 1.11.1
 
 ### Patch Changes

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.11.1"
+  version: "1.12.0-alpha.0"
 ---
 
 ## When to use
@@ -16,6 +16,8 @@ Read the individual reference documents for detailed explanations and code examp
 
 ### Docs
 
+- [Deploying](references/docs-agent-builder-deploying.md) - Swap local Agent Builder primitives for cloud-backed storage, filesystems, sandboxes, an EE license, auth, and a public channel URL for production.
+- [Agent Builder overview](references/docs-agent-builder-overview.md) - Let teammates create, configure, and operate Mastra agents from a browser, with admin-pinned defaults, RBAC, and channel integrations.
 - [Agent approval](references/docs-agents-agent-approval.md) - Learn how to require approvals, suspend tool execution, and automatically resume suspended tools while keeping humans in control of agent workflows.
 - [Agent networks](references/docs-agents-networks.md) - Coordinate multiple agents, workflows, and tools using agent networks for complex, non-deterministic task execution.
 - [Memory processors](references/docs-memory-memory-processors.md) - Learn how to use memory processors in Mastra to filter, trim, and transform messages before they're sent to the language model to manage context window limits.

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.11.1",
+  "version": "1.12.0-alpha.0",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-agent-builder-deploying.md

@@ -0,0 +1,121 @@
+# Deploying
+
+> **Note:** The Agent Builder is part of the Mastra Enterprise Edition. Production deployments require a valid EE license. [Contact sales](https://mastra.ai/contact) for more information.
+
+Production deployments swap the local primitives in the Quickstart for cloud-backed equivalents. The shape of the `Mastra` and `MastraEditor` config doesn't change — only the providers behind it.
+
+## What a production deployment needs
+
+1. **EE license** — a valid `MASTRA_EE_LICENSE` so the server will start with the Builder enabled.
+2. **Hosted storage** — a shared store for agents, skills, runs, and memory.
+3. **Shared workspace filesystem** — survives across instances; `local` is single-node only.
+4. **Cloud sandbox** — runs agent commands safely; `local` is unsafe in shared environments.
+5. **Auth and RBAC** — gates the Builder UI and `/agent-builder/*` routes.
+6. **Public base URL for channels** — Slack and other channel providers need a reachable URL.
+
+## EE license
+
+Set `MASTRA_EE_LICENSE` in the deployment environment. The server refuses to start when `builder.enabled` is truthy without a valid license. Treat the license key as a secret.
+
+## Storage
+
+Replace the file-backed LibSQL store with a hosted backend. LibSQL Cloud, PostgreSQL, and any other Mastra storage adapter all work.
+
+```typescript
+import { Mastra } from '@mastra/core/mastra'
+import { LibSQLStore } from '@mastra/libsql'
+
+new Mastra({
+  storage: new LibSQLStore({
+    url: process.env.DATABASE_URL!,
+    authToken: process.env.DATABASE_AUTH_TOKEN,
+  }),
+})
+```
+
+## Workspace filesystem and sandbox
+
+`local` filesystem works only on the node that owns the directory. For multi-instance deployments, register cloud filesystem and sandbox providers on `MastraEditor` and reference them by id in the inline workspace config.
+
+**npm**:
+
+```bash
+npm install @mastra/s3 @mastra/e2b
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/s3 @mastra/e2b
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/s3 @mastra/e2b
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/s3 @mastra/e2b
+```
+
+```typescript
+import { Mastra } from '@mastra/core/mastra'
+import { MastraEditor } from '@mastra/editor'
+import { s3FilesystemProvider } from '@mastra/s3'
+import { e2bSandboxProvider } from '@mastra/e2b'
+
+new Mastra({
+  editor: new MastraEditor({
+    filesystems: { [s3FilesystemProvider.id]: s3FilesystemProvider },
+    sandboxes: { [e2bSandboxProvider.id]: e2bSandboxProvider },
+    builder: {
+      enabled: true,
+      configuration: {
+        agent: {
+          workspace: {
+            type: 'inline',
+            config: {
+              name: 'builder-workspace',
+              filesystem: {
+                provider: s3FilesystemProvider.id,
+                config: {
+                  bucket: process.env.S3_BUCKET!,
+                  region: process.env.S3_REGION!,
+                },
+              },
+              sandbox: {
+                provider: e2bSandboxProvider.id,
+                config: { apiKey: process.env.E2B_API_KEY! },
+              },
+            },
+          },
+        },
+      },
+    },
+  }),
+})
+```
+
+`S3Filesystem` uses the default AWS credential chain (environment variables, `~/.aws` config, IAM roles, EC2 instance profile). For long-running deployments, use a credential provider function so credentials refresh automatically.
+
+`DockerSandbox` and `VercelSandbox` are alternative cloud sandbox providers — pick whichever matches your runtime.
+
+> **Warning:** A local sandbox can't run commands safely in a shared environment. Always register a cloud sandbox provider and reference it in the workspace config before deploying.
+
+## Auth and RBAC
+
+A production deployment without authentication exposes the Builder to the public internet. Register a `Mastra.server.auth` provider (for example, WorkOS or your own provider) and a `Mastra.server.rbac` provider to gate access.
+
+See [Access control](https://mastra.ai/docs/agent-builder/access-control) for the required role permissions and a WorkOS quickstart.
+
+## Public URL for channels
+
+Slack needs to reach your server through a public URL. Pass `baseUrl` to `SlackProvider` with the deployed URL (no trailing slash). See [Channels](https://mastra.ai/docs/agent-builder/channels) for the full setup.
+
+## Related
+
+- [Access control](https://mastra.ai/docs/agent-builder/access-control) — auth and RBAC setup.
+- [Channels](https://mastra.ai/docs/agent-builder/channels) — Slack `baseUrl` and channel-specific setup.

package/dist/docs/references/docs-agent-builder-overview.md

@@ -0,0 +1,97 @@
+# Agent Builder overview
+
+> **Note:** The Agent Builder is part of the Mastra Enterprise Edition. Production deployments require a valid EE license. [Contact sales](https://mastra.ai/contact) for more information.
+
+The Agent Builder lets you build, configure, and operate Mastra agents all within the UI. It runs inside your Mastra server, persists everything to `Mastra.storage`, and supports multi-tenant agent workflows with RBAC and channel integrations.
+
+- [**Configuration**](https://mastra.ai/docs/agent-builder/configuration): Toggle UI sections and pin admin-controlled defaults for every new agent.
+- [**Model policy**](https://mastra.ai/docs/agent-builder/model-policy): Restrict which providers and models the Builder exposes, and pin a default.
+- [**Memory**](https://mastra.ai/docs/agent-builder/memory): Configure the default memory shape for every Builder-created agent.
+- [**Access control**](https://mastra.ai/docs/agent-builder/access-control): Gate the Builder behind Mastra RBAC roles and permissions.
+- [**Channels**](https://mastra.ai/docs/agent-builder/channels): Connect Builder-created agents to Slack and other channels.
+- [**Skill registries**](https://mastra.ai/docs/agent-builder/skill-registries): Browse and install community skills from opt-in registries.
+- [**Deploying**](https://mastra.ai/docs/agent-builder/deploying): Swap local primitives for cloud-backed storage, filesystems, and sandboxes.
+
+For building agents entirely in code, see the [Agents overview](https://mastra.ai/docs/agents/overview). For editing code-defined agents through Studio, see the [Editor overview](https://mastra.ai/docs/editor/overview).
+
+## Get started
+
+Install `@mastra/editor` alongside a storage adapter:
+
+**npm**:
+
+```bash
+npm install @mastra/editor @mastra/libsql
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/editor @mastra/libsql
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/editor @mastra/libsql
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/editor @mastra/libsql
+```
+
+Wire the Agent Builder onto a `Mastra` instance:
+
+```typescript
+import { Mastra } from '@mastra/core/mastra'
+import { MastraEditor } from '@mastra/editor'
+import { createBuilderAgent } from '@mastra/editor/ee'
+import { LibSQLStore } from '@mastra/libsql'
+
+export const mastra = new Mastra({
+  storage: new LibSQLStore({ url: 'file:./mastra.db' }),
+  agents: { builderAgent: createBuilderAgent() },
+  editor: new MastraEditor({
+    builder: {
+      enabled: true,
+      configuration: {
+        agent: {
+          memory: { observationalMemory: true },
+        },
+      },
+    },
+  }),
+})
+```
+
+Start the dev server:
+
+```bash
+npx mastra dev
+```
+
+The Agent Builder is mounted at `http://localhost:4111/agent-builder`.
+
+## Prerequisites
+
+The Agent Builder requires:
+
+- **Storage**: An `@mastra/core` storage adapter on the `Mastra` instance. Agents, memory, and workspace state all persist through `Mastra.storage`.
+- **The Builder agent**: Register a Builder agent created with the `createBuilderAgent()` factory from `@mastra/editor/ee` on `Mastra.agents`. The chat-based editor invokes it through the same `Mastra.getAgent(id)` lookup as any other agent. Without this registration, the chat-based editor returns 404.
+- **`OPENAI_API_KEY`**: The Builder agent created by `createBuilderAgent()` runs on an OpenAI model, so an `OPENAI_API_KEY` environment variable is required.
+
+## Disabling the Builder
+
+Set `enabled: false` to keep the config in place but turn the surface off:
+
+```typescript
+new MastraEditor({
+  builder: {
+    enabled: false,
+  },
+})
+```
+
+Omitting the `builder` field has the same effect.

package/dist/docs/references/docs-agents-agent-approval.md

@@ -86,6 +86,20 @@ for await (const chunk of stream.fullStream) {
 }
 ```
 
+#### Conditional approval with a function
+
+Instead of a boolean, `requireToolApproval` accepts a function that decides per tool call. It receives the `toolName`, the `args` the model passed, the `requestContext`, and the `workspace`. Return `true` to require approval for that call, or `false` to allow it. This lets you gate approval dynamically — for example, only for tools whose name matches a pattern:
+
+```typescript
+const stream = await agent.stream('Clean up old records', {
+  requireToolApproval: ({ toolName }) => /^delete_/.test(toolName),
+})
+```
+
+A tool's own `requireApproval` setting still takes precedence: if a tool defines its own approval rule, that rule decides for that tool and the function above does not override it. If the function throws, the call requires approval (fail-safe).
+
+> **Note:** Function-based `requireToolApproval` is only available on regular `stream()` / `generate()` calls. Durable agents and stored agents persist their options, and a function can't be serialized, so they accept only a boolean. If you pass a function in those contexts it falls back to requiring approval for every tool call.
+
 ### Runtime suspension with `suspend()`
 
 A tool can also pause _during_ its `execute` function by calling `suspend()`. This is useful when the tool starts running and then discovers it needs additional user input or confirmation before it can finish.

package/dist/docs/references/docs-memory-multi-user-threads.md

@@ -65,7 +65,7 @@ const memory = new Memory({
 export const collabAgent = new Agent({
   id: 'collab',
   name: 'CollabAgent',
-  model: 'openai/gpt-5.4-mini',
+  model: '__OPENAI_MODEL_MINI__',
   memory,
   instructions: `
 You are a collaborative document assistant. Multiple users talk to you in the SAME thread.

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

@@ -247,7 +247,7 @@ const agent = new Agent({
 })
 ```
 
-The model router automatically handles API key detection from environment variables (`OPENAI_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY`, `OPENROUTER_API_KEY`).
+The model router automatically handles API key detection from environment variables (`OPENAI_API_KEY`, `GOOGLE_API_KEY`, `OPENROUTER_API_KEY`). Google models also fall back to `GOOGLE_GENERATIVE_AI_API_KEY`.
 
 ### Using AI SDK Packages
 

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

@@ -179,7 +179,7 @@ export const agent = new Agent({
   memory: new Memory({
     options: {
       generateTitle: {
-        model: 'openai/gpt-5-mini',
+        model: '__OPENAI_MODEL_MINI__',
         instructions: 'Generate a 1 word title',
       },
     },

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

@@ -472,7 +472,10 @@ const initialResults = await pgVector.query({
 })
 
 // Create a relevance scorer
-const relevanceProvider = new MastraAgentRelevanceScorer('relevance-scorer', 'openai/gpt-5.4')
+const relevanceProvider = new MastraAgentRelevanceScorer(
+  'relevance-scorer',
+  'openai/gpt-5.4',
+)
 
 // Re-rank the results
 const rerankedResults = await rerank({

package/dist/index.cjs

@@ -2275,7 +2275,15 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
     await this.#db.alterTable({
       tableName: storage.TABLE_AGENT_VERSIONS,
       schema: storage.AGENT_VERSIONS_SCHEMA,
-      ifNotExists: ["mcpClients", "requestContextSchema", "workspace", "skills", "skillsFormat", "browser"]
+      ifNotExists: [
+        "mcpClients",
+        "requestContextSchema",
+        "workspace",
+        "skills",
+        "skillsFormat",
+        "browser",
+        "toolProviders"
+      ]
     });
     await this.#migrateToolsToJsonbFormat();
     await this.#cleanupStaleDrafts();
@@ -2336,6 +2344,7 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
           workflows: row.workflows ?? null,
           agents: row.agents ?? null,
           integrationTools: row.integrationTools ?? null,
+          toolProviders: row.toolProviders ?? null,
           inputProcessors: row.inputProcessors ?? null,
           outputProcessors: row.outputProcessors ?? null,
           memory: row.memory ?? null,
@@ -2788,6 +2797,7 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
           workflows: input.workflows ?? null,
           agents: input.agents ?? null,
           integrationTools: input.integrationTools ?? null,
+          toolProviders: input.toolProviders ?? null,
           inputProcessors: input.inputProcessors ?? null,
           outputProcessors: input.outputProcessors ?? null,
           memory: input.memory ?? null,
@@ -3062,6 +3072,7 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
       workflows: this.parseJson(row.workflows, "workflows"),
       agents: this.parseJson(row.agents, "agents"),
       integrationTools: this.parseJson(row.integrationTools, "integrationTools"),
+      toolProviders: this.parseJson(row.toolProviders, "toolProviders"),
       inputProcessors: this.parseJson(row.inputProcessors, "inputProcessors"),
       outputProcessors: this.parseJson(row.outputProcessors, "outputProcessors"),
       memory: this.parseJson(row.memory, "memory"),
@@ -10980,6 +10991,197 @@ var SkillsLibSQL = class extends storage.SkillsStorage {
     };
   }
 };
+function normaliseScope(raw) {
+  const value = raw == null ? "per-author" : String(raw);
+  if (value === "shared") return "shared";
+  if (value === "caller-supplied") return "caller-supplied";
+  return "per-author";
+}
+function rowToToolProviderConnection(row) {
+  return {
+    authorId: String(row.authorId),
+    providerId: String(row.providerId),
+    toolkit: String(row.toolkit),
+    connectionId: String(row.connectionId),
+    label: row.label == null ? null : String(row.label),
+    scope: normaliseScope(row.scope),
+    createdAt: new Date(String(row.createdAt)),
+    updatedAt: new Date(String(row.updatedAt))
+  };
+}
+var ToolProviderConnectionsLibSQL = class extends storage.ToolProviderConnectionsStorage {
+  #db;
+  #client;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_TOOL_PROVIDER_CONNECTIONS,
+      schema: storage.TOOL_PROVIDER_CONNECTIONS_SCHEMA,
+      compositePrimaryKey: ["authorId", "providerId", "connectionId"]
+    });
+    await this.#client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_tool_provider_connections_author ON "${storage.TABLE_TOOL_PROVIDER_CONNECTIONS}" ("authorId", "providerId", "toolkit")`
+    );
+  }
+  async dangerouslyClearAll() {
+    await this.#client.execute(`DELETE FROM "${storage.TABLE_TOOL_PROVIDER_CONNECTIONS}"`);
+  }
+  async getConnectionById({
+    authorId,
+    providerId,
+    connectionId
+  }) {
+    try {
+      const result = await this.#client.execute({
+        sql: `SELECT * FROM "${storage.TABLE_TOOL_PROVIDER_CONNECTIONS}" WHERE "authorId" = ? AND "providerId" = ? AND "connectionId" = ? LIMIT 1`,
+        args: [authorId, providerId, connectionId]
+      });
+      const row = result.rows?.[0];
+      if (!row) return null;
+      return rowToToolProviderConnection(row);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "TOOL_PROVIDER_CONNECTION_GET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { authorId, providerId, connectionId }
+        },
+        error$1
+      );
+    }
+  }
+  async upsertConnection(input) {
+    const { authorId, providerId, toolkit, connectionId, label } = input;
+    const now = /* @__PURE__ */ new Date();
+    const nowIso = now.toISOString();
+    const labelValue = label == null ? null : label;
+    try {
+      const tx = await this.#client.transaction("write");
+      try {
+        const existing = await tx.execute({
+          sql: `SELECT "createdAt", "scope" FROM "${storage.TABLE_TOOL_PROVIDER_CONNECTIONS}" WHERE "authorId" = ? AND "providerId" = ? AND "connectionId" = ? LIMIT 1`,
+          args: [authorId, providerId, connectionId]
+        });
+        const existingRow = existing.rows?.[0];
+        const createdAt = existingRow ? String(existingRow.createdAt) : nowIso;
+        const existingScope = existingRow && existingRow.scope != null ? normaliseScope(existingRow.scope) : void 0;
+        const scope = input.scope ?? existingScope ?? "per-author";
+        if (existingRow) {
+          await tx.execute({
+            sql: `UPDATE "${storage.TABLE_TOOL_PROVIDER_CONNECTIONS}" SET "toolkit" = ?, "label" = ?, "scope" = ?, "updatedAt" = ? WHERE "authorId" = ? AND "providerId" = ? AND "connectionId" = ?`,
+            args: [toolkit, labelValue, scope, nowIso, authorId, providerId, connectionId]
+          });
+        } else {
+          await tx.execute({
+            sql: `INSERT INTO "${storage.TABLE_TOOL_PROVIDER_CONNECTIONS}" ("authorId", "providerId", "toolkit", "connectionId", "label", "scope", "createdAt", "updatedAt") VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [authorId, providerId, toolkit, connectionId, labelValue, scope, createdAt, nowIso]
+          });
+        }
+        await tx.commit();
+        return {
+          authorId,
+          providerId,
+          toolkit,
+          connectionId,
+          label: labelValue,
+          scope,
+          createdAt: new Date(createdAt),
+          updatedAt: now
+        };
+      } catch (error) {
+        if (!tx.closed) {
+          await tx.rollback();
+        }
+        throw error;
+      }
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "TOOL_PROVIDER_CONNECTION_UPSERT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { authorId, providerId, connectionId }
+        },
+        error$1
+      );
+    }
+  }
+  async listConnectionsByAuthor({
+    authorId,
+    providerId,
+    toolkit,
+    scope
+  }) {
+    try {
+      const clauses = [];
+      const args = [];
+      if (authorId !== void 0) {
+        clauses.push('"authorId" = ?');
+        args.push(authorId);
+      }
+      if (providerId) {
+        clauses.push('"providerId" = ?');
+        args.push(providerId);
+      }
+      if (toolkit) {
+        clauses.push('"toolkit" = ?');
+        args.push(toolkit);
+      }
+      if (scope) {
+        clauses.push('"scope" = ?');
+        args.push(scope);
+      }
+      const whereClause = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+      const result = await this.#client.execute({
+        sql: `SELECT * FROM "${storage.TABLE_TOOL_PROVIDER_CONNECTIONS}"${whereClause}`,
+        args
+      });
+      return (result.rows ?? []).map((row) => rowToToolProviderConnection(row));
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "TOOL_PROVIDER_CONNECTION_LIST", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { authorId: authorId ?? "", providerId: providerId ?? "", toolkit: toolkit ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteConnection({
+    authorId,
+    providerId,
+    connectionId
+  }) {
+    try {
+      await this.#client.execute({
+        sql: `DELETE FROM "${storage.TABLE_TOOL_PROVIDER_CONNECTIONS}" WHERE "authorId" = ? AND "providerId" = ? AND "connectionId" = ?`,
+        args: [authorId, providerId, connectionId]
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "TOOL_PROVIDER_CONNECTION_DELETE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { authorId, providerId, connectionId }
+        },
+        error$1
+      );
+    }
+  }
+};
 var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
   #db;
   #client;
@@ -11916,6 +12118,7 @@ var LibSQLStore = class extends storage.MastraCompositeStore {
     const blobs = new BlobsLibSQL(domainConfig);
     const backgroundTasks = new BackgroundTasksLibSQL(domainConfig);
     const schedules = new SchedulesLibSQL(domainConfig);
+    const toolProviderConnections = new ToolProviderConnectionsLibSQL(domainConfig);
     this.stores = {
       scores,
       workflows,
@@ -11934,7 +12137,8 @@ var LibSQLStore = class extends storage.MastraCompositeStore {
       favorites,
       blobs,
       backgroundTasks,
-      schedules
+      schedules,
+      toolProviderConnections
     };
   }
   async applyLocalPragmas() {
@@ -11994,6 +12198,34 @@ var LibSQLStore = class extends storage.MastraCompositeStore {
     }
     await this.initDomainsSequentially();
   }
+  /**
+   * Closes the underlying libsql client, releasing all OS file handles.
+   *
+   * For local file databases, first runs PRAGMA wal_checkpoint(TRUNCATE) and
+   * switches back to journal_mode=DELETE so that Windows releases the -wal
+   * and -shm sidecar files promptly. Without this, the handles stay open
+   * until process exit, causing EBUSY errors when callers try to fs.rm the
+   * storage directory after Mastra.shutdown().
+   *
+   * Remote (Turso) databases skip the WAL pragmas and just close the client.
+   *
+   * Safe to call more than once; subsequent calls are no-ops.
+   */
+  async close() {
+    if (this.client.closed) {
+      return;
+    }
+    const isLocalFileDb = this.isLocalDb || this.client.protocol === "file";
+    if (isLocalFileDb) {
+      try {
+        await this.client.execute("PRAGMA wal_checkpoint(TRUNCATE);");
+        await this.client.execute("PRAGMA journal_mode=DELETE;");
+      } catch (err) {
+        this.logger.warn("LibSQLStore: Failed to checkpoint WAL before close.", err);
+      }
+    }
+    this.client.close();
+  }
 };
 
 // src/vector/prompt.ts
@@ -12115,6 +12347,7 @@ exports.SchedulesLibSQL = SchedulesLibSQL;
 exports.ScorerDefinitionsLibSQL = ScorerDefinitionsLibSQL;
 exports.ScoresLibSQL = ScoresLibSQL;
 exports.SkillsLibSQL = SkillsLibSQL;
+exports.ToolProviderConnectionsLibSQL = ToolProviderConnectionsLibSQL;
 exports.WorkflowsLibSQL = WorkflowsLibSQL;
 exports.WorkspacesLibSQL = WorkspacesLibSQL;
 //# sourceMappingURL=index.cjs.map