@mastra/libsql 0.0.0-createToolOptions-20250926094418 → 0.0.0-credential-handoff-20261106225933

package/LICENSE.md

@@ -1,3 +1,20 @@
+Portions of this software are licensed as follows:
+
+- All content that resides under any directory named `ee/` within this
+  repository, including but not limited to:
+  - `@mastra/core/auth/ee`
+  - `@mastra/core/agent-builder/ee`
+  - `@mastra/editor/ee`
+
+  is licensed under the license defined in [`ee/LICENSE`](https://github.com/mastra-ai/mastra/blob/main/ee/LICENSE).
+
+- All third-party components incorporated into the Mastra Software are
+  licensed under the original license provided by the owner of the
+  applicable component.
+
+- Content outside of the above-mentioned directories or restrictions is
+  available under the "Apache License 2.0" as defined below.
+
 # Apache License 2.0
 
 Copyright (c) 2025 Kepler Software, Inc.

package/README.md

@@ -1,4 +1,4 @@
-# @mastra/pg
+# @mastra/libsql
 
 SQLite implementation for Mastra, providing both vector similarity search and general storage capabilities with connection pooling and transaction support.
 
@@ -16,27 +16,30 @@ npm install @mastra/libsql
 import { LibSQLVector } from '@mastra/libsql';
 
 const vectorStore = new LibSQLVector({
-  url: 'file:./my-db.db'
+  url: 'file:./my-db.db',
 });
 
 // Create a new table with vector support
 await vectorStore.createIndex({
   indexName: 'my_vectors',
-  dimension: 1536,
+  dimension: 3,
   metric: 'cosine',
 });
 
 // Add vectors
 const ids = await vectorStore.upsert({
   indexName: 'my_vectors',
-  vectors: [[0.1, 0.2, ...], [0.3, 0.4, ...]],
+  vectors: [
+    [0.1, 0.2, 0.3],
+    [0.3, 0.4, 0.5],
+  ],
   metadata: [{ text: 'doc1' }, { text: 'doc2' }],
 });
 
 // Query vectors
 const results = await vectorStore.query({
   indexName: 'my_vectors',
-  queryVector: [0.1, 0.2, ...],
+  queryVector: [0.1, 0.2, 0.3],
   topK: 10, // topK
   filter: { text: 'doc1' }, // filter
   includeVector: false, // includeVector
@@ -44,101 +47,14 @@ const results = await vectorStore.query({
 });
 ```
 
-### Storage
-
-```typescript
-import { LibSQLStore } from '@mastra/pg';
-
-const store = new LibSQLStore({
-  url: 'file:./my-db.db',
-});
-
-// Create a thread
-await store.saveThread({
-  id: 'thread-123',
-  resourceId: 'resource-456',
-  title: 'My Thread',
-  metadata: { key: 'value' },
-});
-
-// Add messages to thread
-await store.saveMessages([
-  {
-    id: 'msg-789',
-    threadId: 'thread-123',
-    role: 'user',
-    type: 'text',
-    content: [{ type: 'text', text: 'Hello' }],
-  },
-]);
-
-// Query threads and messages
-const savedThread = await store.getThread('thread-123');
-const messages = await store.getMessages('thread-123');
-```
-
-## Configuration
-
-The LibSQLStore store can be initialized with:
-
-- Configuration object with url and auth. Auth is only necessary when using a provider like [Turso](https://turso.tech/)
-
-## Features
-
-### Vector Store Features
-
-- Vector similarity search with cosine, euclidean, and dot product metrics
-- Advanced metadata filtering with MongoDB-like query syntax
-- Minimum score threshold for queries
-- Automatic UUID generation for vectors
-- Table management (create, list, describe, delete, truncate)
-
-### Storage Features
-
-- Thread and message storage with JSON support
-- Atomic transactions for data consistency
-- Efficient batch operations
-- Rich metadata support
-- Timestamp tracking
-- Cascading deletes
-
-## Supported Filter Operators
-
-The following filter operators are supported for metadata queries:
-
-- Comparison: `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`
-- Logical: `$and`, `$or`
-- Array: `$in`, `$nin`
-- Text: `$regex`, `$like`
-
-Example filter:
-
-```typescript
-{
-  $and: [{ age: { $gt: 25 } }, { tags: { $in: ['tag1', 'tag2'] } }];
-}
-```
-
-## Vector Store Methods
+## Documentation
 
-- `createIndex({indexName, dimension, metric?, indexConfig?, defineIndex?})`: Create a new table with vector support
-- `upsert({indexName, vectors, metadata?, ids?})`: Add or update vectors
-- `query({indexName, queryVector, topK?, filter?, includeVector?, minScore?})`: Search for similar vectors
-- `defineIndex({indexName, metric?, indexConfig?})`: Define an index
-- `listIndexes()`: List all vector-enabled tables
-- `describeIndex(indexName)`: Get table statistics
-- `deleteIndex(indexName)`: Delete a table
-- `truncateIndex(indexName)`: Remove all data from a table
+- [@mastra/libsql documentation](https://mastra.ai/integrations/vectors/libsql)
 
-## Storage Methods
+## Changelog
 
-- `saveThread(thread)`: Create or update a thread
-- `getThread(threadId)`: Get a thread by ID
-- `deleteThread(threadId)`: Delete a thread and its messages
-- `saveMessages(messages)`: Save multiple messages in a transaction
-- `getMessages(threadId)`: Get all messages for a thread
-- `deleteMessages(messageIds)`: Delete specific messages
+See the [package changelog](https://github.com/mastra-ai/mastra/blob/main/stores/libsql/CHANGELOG.md) for version history and release notes.
 
-## Related Links
+## Support
 
-- [LibSQL Documentation](https://docs.turso.tech/sdk/introductionh)
+We have an [open community Discord](https://discord.gg/mastra-ai). Come and say hello and let us know if you have any questions or need any help getting things running.

package/dist/_types/@internal_core@0.1.4/dist/knowledge-compat/index.d.ts

@@ -0,0 +1,353 @@
+export declare const KNOWLEDGE_STORAGE_CONTRACT_VERSION: 4;
+export declare const KNOWLEDGE_STORAGE_SCHEMA_VERSION: 4;
+export declare const TABLE_KNOWLEDGE_NODE_SCOPES = "mastra_knowledge_node_scopes";
+export declare const TABLE_KNOWLEDGE_RECORD_SCOPES = "mastra_knowledge_record_scopes";
+export declare const TABLE_KNOWLEDGE_SCOPE_GRANTS = "mastra_knowledge_scope_grants";
+export declare const TABLE_KNOWLEDGE_ACCESS_STATE = "mastra_knowledge_access_state";
+export declare const TABLE_KNOWLEDGE_SCOPE_ADDRESSES = "mastra_knowledge_scope_addresses";
+export declare const TABLE_KNOWLEDGE_NODE_ADDRESSES = "mastra_knowledge_node_addresses";
+export declare const TABLE_KNOWLEDGE_IMPORT_STATE = "mastra_knowledge_import_state";
+export declare const TABLE_KNOWLEDGE_IMPORT_RUNS = "mastra_knowledge_import_runs";
+export declare const TABLE_KNOWLEDGE_PROPOSALS = "mastra_knowledge_proposals";
+export declare const KNOWLEDGE_TABLE_NAMES: readonly ["mastra_knowledge_nodes", "mastra_knowledge_records", "mastra_knowledge_mentions", "mastra_knowledge_activity", "mastra_knowledge_semantic_outbox", "mastra_knowledge_node_scopes", "mastra_knowledge_record_scopes", "mastra_knowledge_scope_grants", "mastra_knowledge_access_state", "mastra_knowledge_scope_addresses", "mastra_knowledge_node_addresses", "mastra_knowledge_import_state", "mastra_knowledge_import_runs", "mastra_knowledge_proposals"];
+/** Knowledge v1 tables with no v2 equivalent; an explicit schema reset drops them. */
+export declare const RETIRED_KNOWLEDGE_TABLE_NAMES: readonly ['mastra_knowledge_cursors'];
+export declare const KNOWLEDGE_PAGES_CORE_FEATURE = "knowledge-pages";
+export declare const KNOWLEDGE_PAGES_SCHEMA_VERSION: 4;
+export declare const TABLE_KNOWLEDGE_PAGES = "mastra_knowledge_pages";
+export declare const TABLE_KNOWLEDGE_NOTES = "mastra_knowledge_notes";
+export declare const TABLE_KNOWLEDGE_NOTE_STAMPS = "mastra_knowledge_note_stamps";
+/** Same name as the schema-2 table; schema 4 re-keys it to note → page. */
+export declare const TABLE_KNOWLEDGE_PAGE_MENTIONS = "mastra_knowledge_mentions";
+export declare const TABLE_KNOWLEDGE_PINS = "mastra_knowledge_pins";
+/** Same name as schema 2; schema 4 re-keys it to scope/page/note. */
+export declare const TABLE_KNOWLEDGE_PAGE_ACTIVITY = "mastra_knowledge_activity";
+/** Holds `{ id: 'knowledge', schemaVersion: 4 }`, written when the schema-4 tables are created. */
+export declare const TABLE_KNOWLEDGE_PAGES_STATE = "mastra_knowledge_access_state";
+export declare const KNOWLEDGE_PAGES_TABLE_NAMES: readonly ["mastra_knowledge_pages", "mastra_knowledge_notes", "mastra_knowledge_note_stamps", "mastra_knowledge_mentions", "mastra_knowledge_pins", "mastra_knowledge_activity", "mastra_knowledge_access_state"];
+/** Every Knowledge table any schema version created. Reset drops these and nothing else. */
+export declare const KNOWLEDGE_RESETTABLE_TABLE_NAMES: readonly string[];
+/** Schema-1/2 tables whose presence means the store needs a reset before schema 4 can run. */
+export declare const LEGACY_KNOWLEDGE_TABLE_NAMES: ReadonlySet<string>;
+/** Pages and scope pages. `scopeId` equals `id` on scope pages; `address`/`declaration` only on scope pages. */
+export declare const KNOWLEDGE_PAGES_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly scopeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly parentId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly isScope: {
+    readonly type: 'boolean';
+    readonly nullable: false;
+  };
+  readonly address: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly declaration: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly key: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly position: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly name: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly canonicalName: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly description: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly body: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly version: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly mergedInto: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly createdBy: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly updatedBy: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly deletedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly deletedBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+export declare const KNOWLEDGE_NOTES_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly pageId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_pages";
+      readonly column: 'id';
+    };
+  };
+  readonly text: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly when: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly provenance: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly version: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly deletedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly deletedBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+/** One row per (note, stamp scope). Primary key is the pair. */
+export declare const KNOWLEDGE_NOTE_STAMPS_SCHEMA: {
+  readonly noteId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_notes";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_pages";
+      readonly column: 'id';
+    };
+  };
+};
+/** One row per (note, mentioned page). Primary key is the pair. */
+export declare const KNOWLEDGE_PAGE_MENTIONS_SCHEMA: {
+  readonly noteId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_notes";
+      readonly column: 'id';
+    };
+  };
+  readonly pageId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_pages";
+      readonly column: 'id';
+    };
+  };
+};
+/** `audience` is a JSON array of scope addresses (PG may store it as `text[]`, Mongo as an array). */
+export declare const KNOWLEDGE_PINS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly pageId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_pages";
+      readonly column: 'id';
+    };
+  };
+  readonly audience: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly createdBy: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+export declare const KNOWLEDGE_PAGE_ACTIVITY_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly action: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly scopeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly pageId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly noteId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly provenance: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+export declare const KNOWLEDGE_PAGES_STATE_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly schemaVersion: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+};
+export type KnowledgePagesSchemaInspection = {
+  status: 'compatible';
+  schemaVersion: typeof KNOWLEDGE_PAGES_SCHEMA_VERSION;
+} | {
+  status: 'uninitialized';
+  schemaVersion: null;
+} | {
+  status: 'incompatible-reset-required';
+  schemaVersion: number | null;
+  reason: string;
+};
+/**
+ * Classifies what an adapter found before creating schema-4 tables. `tableNames` is every
+ * `mastra_knowledge_*` table present; `schemaVersion` is the state row's version, if any.
+ */
+export declare function inspectKnowledgePagesSchema(snapshot: {
+  tableNames: readonly string[];
+  schemaVersion?: number;
+}): KnowledgePagesSchemaInspection;
+/**
+ * The old Knowledge tables an adapter drops on init, rows included: Knowledge before schema 4 was an
+ * experimental store with no migration. Every schema-1/2-only table present is dropped. The table
+ * names schema 4 reuses (mentions, activity, the state table) are dropped too, but only when an old
+ * table is present and no schema-4 state row exists, so they are old-shaped. Schema-4-only tables
+ * are never listed. On a schema-4 store this lists only tables an older process recreated during a
+ * rolling deploy. Drop order is safe for adapters that enforce references.
+ */
+export declare function legacyKnowledgeTablesToDrop(snapshot: {
+  tableNames: readonly string[];
+  schemaVersion?: number;
+}): string[];
+/** Message for the error an adapter throws on `incompatible-reset-required`. */
+export declare function knowledgePagesResetMessage(reason: string): string;
+/**
+ * The page-store runtime pieces adapters take from `@mastra/core/storage`. They are loaded through
+ * `createKnowledgePagesCoreLoader` instead of static imports so adapters keep loading on cores
+ * older than the `knowledge-pages` feature without raising their `@mastra/core` peer floor.
+ */
+export interface KnowledgePagesCore {
+  assertKnowledgePageDescriptionWithinBound(description: string | undefined): void;
+  assertKnowledgeNoteTextWithinBound(text: string): void;
+  canonicalKnowledgeName(name: string): string;
+  knowledgePositionBetween(before?: string, after?: string): string;
+  MAX_KNOWLEDGE_MOVE_PAGES: number;
+  MAX_KNOWLEDGE_PAGE_DEPTH: number;
+  MAX_KNOWLEDGE_PAGE_LIST_LIMIT: number;
+  MAX_KNOWLEDGE_PAGE_LINKS: number;
+  KnowledgeMoveTooLargeError: new (pageId: string, pages: number) => Error;
+  KnowledgePageDepthError: new (pageId: string) => Error;
+  KnowledgePageHasChildrenError: new (pageId: string) => Error;
+  KnowledgePageKeyConflictError: new (key: string, parentId: string) => Error;
+}
+/** Loads core's page-store runtime once, after checking core advertises `knowledge-pages`. */
+export declare function createKnowledgePagesCoreLoader(features: ReadonlySet<string>, loadStorageModule: () => Promise<unknown>): () => Promise<KnowledgePagesCore>;
+/** Most words one keyword search uses; every word adds a substring check per page in each store. */
+export declare const KNOWLEDGE_SEARCH_MAX_WORDS = 16;
+/**
+ * Keyword-search words: the query split on whitespace, lowercased, deduplicated, keeping the first
+ * {@link KNOWLEDGE_SEARCH_MAX_WORDS}. A hit needs at least one of them (as a case-insensitive
+ * substring); an empty list means the search returns nothing.
+ */
+export declare function knowledgeSearchWords(query: string): string[];
+/**
+ * Points one matched search word earns on a page, by the best field it appears in: name, then
+ * description, then body. A page whose name contains the whole query ranks first; below that, pages
+ * rank by how many query words they match, and these points only break ties between pages that
+ * match the same number of words.
+ */
+export declare const KNOWLEDGE_SEARCH_WEIGHTS: {
+  readonly name: 3;
+  readonly description: 2;
+  readonly body: 1;
+};
+/**
+ * Why `key` can't be a Knowledge page key, or undefined when it can. Keys are one path segment:
+ * non-empty, with no `/` (path separator), `#` (scope/path separator) or `%` (escape character).
+ */
+export declare function knowledgePageKeyProblem(key: string): string | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/@internal_core@0.1.4/dist/memory/index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Shared rules for observational memory lifecycle writes. Every storage adapter applies
+ * these inside its own atomic section (lock, transaction, or conditional update), so the
+ * decisions are identical across adapters.
+ */
+/**
+ * Observational memory columns that lifecycle writes depend on. Storage adapters merge these
+ * into the table schema they get from `@mastra/core`, so the columns exist even when the
+ * installed core predates them.
+ */
+export declare const OBSERVATIONAL_MEMORY_LIFECYCLE_COLUMNS: {
+  readonly supersededBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+/** `schema` plus {@link OBSERVATIONAL_MEMORY_LIFECYCLE_COLUMNS}; `undefined` when `schema` is. */
+export declare function withObservationalMemoryLifecycleColumns<T extends object>(schema: T | undefined): (T & typeof OBSERVATIONAL_MEMORY_LIFECYCLE_COLUMNS) | undefined;
+/**
+ * Result of `commitActiveObservations`.
+ */
+export interface UpdateActiveObservationsResult {
+  /** Whether the observations were written. */
+  applied: boolean;
+  /**
+   * Why nothing was written: `retired` — the target record was superseded by a newer
+   * generation; `conflict` — `expectedActiveObservations` no longer matches the stored text.
+   */
+  reason?: 'retired' | 'conflict';
+}
+/**
+ * Result of `appendBufferedObservations`.
+ *
+ * The append targets the head generation: when `input.id` was superseded, the chunk is
+ * appended to the current head instead. The append is skipped (`persisted: false`) when the
+ * head already holds a chunk with the same `cycleId`, or when the chunk is wholly covered by
+ * the head's cursor. Chunks carry `lastObservedAt = max message time + 1ms`, so a chunk is
+ * wholly covered iff `head.lastObservedAt >= chunk.lastObservedAt - 1ms`.
+ */
+export interface UpdateBufferedObservationsResult {
+  /** Whether the chunk was stored. */
+  persisted: boolean;
+  /** The record the chunk was written to (or would have been written to). */
+  recordId: string;
+}
+/** The fields of an observational memory record that decide head order. */
+export interface ObservationalMemoryHeadOrderFields {
+  generationCount: number;
+  createdAt: Date | string;
+  id: string;
+}
+/**
+ * Canonical head order: `generationCount DESC, createdAt ASC, id ASC`.
+ * Returns a negative number when `a` sorts before `b` (i.e. `a` is the better head candidate).
+ */
+export declare function compareObservationalMemoryHeadOrder(a: ObservationalMemoryHeadOrderFields, b: ObservationalMemoryHeadOrderFields): number;
+/**
+ * A buffered chunk stores `lastObservedAt = max message time + 1ms`. It is wholly covered
+ * (every message it observed is already at or before the cursor) iff
+ * `cursor >= chunk.lastObservedAt - 1ms`.
+ */
+export declare function isBufferedChunkCoveredByCursor(chunkLastObservedAt: Date | string, cursor: Date | string | null | undefined): boolean;
+/** The later of two cursors; `undefined` only when both are absent. */
+export declare function maxObservationCursor(a: Date | string | null | undefined, b: Date | string | null | undefined): Date | undefined;
+export interface ReflectionTextPlan {
+  /** `equal`: stored text equals the snapshot. `append`: observations were appended after the snapshot. */
+  mode: 'equal' | 'append';
+  observations: string;
+  tokenCount: number;
+}
+/**
+ * Decide the new generation's text when a reflection built from `snapshot` commits against
+ * the stored record.
+ *
+ * - Stored text equals the snapshot: the reflection replaces it.
+ * - Stored text extends the snapshot (activation only appends): the appended tail is kept
+ *   after the reflection, and its tokens are added.
+ * - Anything else (a non-append rewrite): `null` — the reflection must not be applied.
+ */
+export declare function planReflectionGenerationText(input: {
+  storedObservations: string;
+  storedObservationTokenCount: number;
+  snapshotObservations: string;
+  snapshotObservationTokenCount: number;
+  reflection: string;
+  tokenCount: number;
+}): ReflectionTextPlan | null;
+/**
+ * Backs `updateActiveObservations` in adapters that implement `commitActiveObservations`.
+ * Callers of `updateActiveObservations` (which resolves `void`) can't see a commit result, so a
+ * write that was not applied throws instead of resolving as if it had committed.
+ */
+export declare function assertActiveObservationsApplied(result: UpdateActiveObservationsResult, id: string): void;
+/**
+ * Whether the stored text can still accept a reflection built from `snapshot`
+ * (equal, or only appended to since).
+ */
+export declare function isAppendOnlySince(storedObservations: string, snapshotObservations: string): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/@internal_core@0.1.4/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/docs/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: mastra-libsql
+description: Documentation for @mastra/libsql. Use when working with @mastra/libsql APIs, configuration, or implementation.
+metadata:
+  package: "@mastra/libsql"
+  version: "0.0.0-credential-handoff-20261106225933"
+---
+
+## When to use
+
+Use this skill whenever you are working with @mastra/libsql to obtain the domain-specific knowledge.
+
+## How to use
+
+Read the individual reference documents for detailed explanations and code examples.
+
+### Docs
+
+- [Human-in-the-loop](references/docs-agents-human-in-the-loop.md) - Add human-in-the-loop controls to Mastra agents with tool approval and suspended execution, so people can provide input before a run resumes or stops.
+- [Agent networks](references/docs-agents-networks.md) - Understand deprecated Mastra agent networks, including multi-agent routing, structured output, tool approvals, and migration to supervisor agents.
+- [Load your content](references/docs-knowledge-load-your-content.md) - Load your own content, such as product docs or policies, into Knowledge so agents can search and read it.
+- [Knowledge](references/docs-knowledge-overview.md) - Give agents shared pages and notes they search, read and write, with access decided by your configuration rather than by the model.
+- [Search](references/docs-knowledge-search.md) - How Knowledge search ranks results, and how to add search by meaning.
+- [Message history](references/docs-memory-message-history.md) - Store and retrieve recent Mastra conversation messages, configure history limits and thread titles, and query threads for chat interfaces.
+- [Multi-user threads](references/docs-memory-multi-user-threads.md) - Share one Mastra memory thread across multiple users by preserving speaker identity in messages and combining history with observational or working memory.
+- [Memory](references/docs-memory-overview.md) - Add memory to Mastra agents with message history, observational memory, and working memory across threads and multi-agent delegation.
+- [Signals](references/docs-signals-overview.md) - Send asynchronous input into a Mastra agent thread while Mastra manages whether the agent is active or idle.
+- [Editor](references/docs-studio-editor.md) - Use Mastra Studio Editor so collaborators can change agent instructions and tools without modifying source code, from draft testing through publication.
+- [Snapshots](references/docs-workflows-snapshots.md) - Store and retrieve Mastra workflow snapshots so suspended executions preserve step results and state and can resume reliably across processes.
+
+### Integrations
+
+- [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.
+- [Ring](references/integrations-channels-ring.md) - Send Ring doorbell and camera events to Mastra agents as notification signals with @mastra/ring-signals, and fetch snapshots and video clips with agent 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
+
+- [AI SDK overview](references/reference-ai-sdk-overview.md) - Wrap Vercel AI SDK models with Mastra processors and memory using withMastra(), while retaining existing AI SDK generation, streaming, and UI integrations.
+- [Reference: Mastra.getMemory()](references/reference-core-getMemory.md) - The .getMemory() method retrieves a memory instance from the Mastra registry by its key.
+- [Reference: Mastra.listMemory()](references/reference-core-listMemory.md) - The .listMemory() method returns all memory instances registered with the Mastra instance.
+- [Reference: Mastra class](references/reference-core-mastra-class.md) - The Mastra class is the central orchestrator in any Mastra application, managing agents, workflows, storage, logging, observability, and more.
+- [Memory](references/reference-file-based-agents-memory.md) - A file-based agent gets memory from a memory.ts file that default-exports a Memory instance.
+- [Storage](references/reference-file-based-agents-storage.md) - Mastra sets the project's default storage from a storage.ts file directly under src/mastra/.
+- [Reference: Memory class](references/reference-memory-memory-class.md) - The Memory class provides a reliable system for managing conversation history and thread-based message storage in Mastra.
+
+
+Read [assets/SOURCE_MAP.json](assets/SOURCE_MAP.json) for source code references.