@mastra/libsql 1.28.0 → 1.29.0-alpha.1

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

@@ -0,0 +1,348 @@
+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;
+  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>;
+/**
+ * Keyword-search words: the query split on whitespace, lowercased, deduplicated. 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. Pages rank by how many query words they match first; 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/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.28.0"
+  version: "1.29.0-alpha.1"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

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

package/dist/docs/references/docs-studio-editor.md

@@ -169,7 +169,7 @@ See the [Editor tools reference](https://mastra.ai/reference/editor/tools) for M
 
 ## Decide what collaborators can edit
 
-The `editor` field decides which fields Studio owns. When omitted, collaborators can change an agent's instructions and manage its tools, including their descriptions, starting from the values in code. The agent's `id`, `name`, and `model` always come from code.
+The `editor` field decides which fields Studio owns. When omitted, collaborators can change an agent's instructions and manage its tools, including their descriptions, starting from the values in code. The agent's `id`, `name`, and model configuration come from code unless you explicitly enable model editing.
 
 ```typescript
 import { Agent } from '@mastra/core/agent'
@@ -206,15 +206,18 @@ export const supportAgent = new Agent({
 
 Here Studio owns the instructions, while tool membership stays in code: collaborators can only improve the descriptions of `searchOrders`.
 
-| `editor` value                     | What collaborators can change               | What code must provide                |
-| ---------------------------------- | ------------------------------------------- | ------------------------------------- |
-| Omitted                            | Instructions, tools, and tool descriptions  | `instructions`; tools are optional    |
-| `false`                            | Nothing                                     | `instructions`                        |
-| `{ instructions: true }`           | Instructions                                | No `instructions`; tools are optional |
-| `{ tools: true }`                  | Tools and tool descriptions                 | `instructions`; no `tools`            |
-| `{ tools: { description: true } }` | Descriptions of tools already added in code | `instructions`; the tools to describe |
+| `editor` value                     | What collaborators can change               | What code must provide                           |
+| ---------------------------------- | ------------------------------------------- | ------------------------------------------------ |
+| Omitted                            | Instructions, tools, and tool descriptions  | `instructions`; tools are optional               |
+| `false`                            | Nothing                                     | `instructions`                                   |
+| `{ instructions: true }`           | Instructions                                | No `instructions`; tools are optional            |
+| `{ tools: true }`                  | Tools and tool descriptions                 | `instructions`; no `tools`                       |
+| `{ tools: { description: true } }` | Descriptions of tools already added in code | `instructions`; the tools to describe            |
+| `{ model: true }`                  | A static model fallback list                | A static fallback array with immutable entry IDs |
 
-Studio shows everything else as read-only. See [editor overrides](https://mastra.ai/reference/agents/agent) for the complete configuration.
+To edit models in Studio, set `editor: { model: true }` and define `model` as a static array in code. Give every entry a stable `id` so Editor can match saved values to the corresponding code-defined model settings. Studio can reorder entries, change their provider and model, and enable or disable them.
+
+Function-valued model configuration remains code-owned and can't be edited in Studio. See [editor overrides](https://mastra.ai/reference/agents/agent) for the complete configuration.
 
 ## Choose where changes are stored