@mastra/libsql 0.0.0-knowledge-studio-20261029065150 → 0.0.0-knowledge-alpha-studio-20261030162625

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

@@ -1,19 +1,5 @@
-//#region src/knowledge-compat/index.d.ts
-/**
- * Knowledge values that storage adapters bundle instead of importing from `@mastra/core`, so adapters keep
- * the same `@mastra/core` peer range as releases without Knowledge. Adapter tests assert these copies equal
- * the current core exports. Runtime behavior that must come from the
- * installed core (errors, sanitizers) is loaded lazily through {@link createKnowledgeCoreLoader} once core
- * advertises a matching Knowledge storage contract.
- */
-export declare const KNOWLEDGE_CORE_FEATURE = "knowledge-v2";
-export declare const KNOWLEDGE_STORAGE_CONTRACT_VERSION: 3;
-export declare const KNOWLEDGE_STORAGE_SCHEMA_VERSION: 3;
-/**
- * Marker version pre-release snapshots wrote for the same canonical layout before the version moved past
- * the released v2 contract; adapters rewrite it to {@link KNOWLEDGE_STORAGE_SCHEMA_VERSION} and keep the rows.
- */
-export declare const PRE_RELEASE_KNOWLEDGE_SCHEMA_VERSION: 1;
+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";
@@ -23,181 +9,318 @@ export declare const TABLE_KNOWLEDGE_NODE_ADDRESSES = "mastra_knowledge_node_add
 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 TABLE_KNOWLEDGE_SCHEMA = "mastra_knowledge_schema";
-/** Every table managed by canonical Knowledge storage, in creation order. */
-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", "mastra_knowledge_schema"];
-/** Knowledge v1 tables with no canonical equivalent; an explicit schema reset drops them. */
+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;
+};
 /**
- * Columns of the tables published v1 adapters created for every app, empty unless the app used
- * Knowledge. Every non-retired table must be present with only these columns before an adapter treats
- * the layout as safely replaceable.
- */
-export declare const PUBLISHED_KNOWLEDGE_V1_COLUMNS: ReadonlyMap<string, readonly string[]>;
-/**
- * True when `columnsByTable` (every Knowledge-prefixed table and its columns) is exactly a published
- * v1 layout: all non-retired v1 tables present, no other tables, and each with only published columns.
- * PostgreSQL adapters also created a `<column>Z` timestamptz shadow beside each timestamp column; pass
- * `timestampShadows` to accept those.
- */
-export declare function isPublishedKnowledgeV1Layout(columnsByTable: ReadonlyMap<string, readonly string[]>, { timestampShadows }?: {
-  timestampShadows?: boolean;
-}): boolean;
-/** Indexes published v1 adapters created on {@link PUBLISHED_KNOWLEDGE_V1_COLUMNS} tables. */
-export declare const PUBLISHED_KNOWLEDGE_V1_INDEX_NAMES: ReadonlySet<string>;
-/**
- * Columns of the Knowledge tables that the first canonical-model release (`@mastra/core` 1.76.0-alpha.3,
- * `@mastra/libsql`/`@mastra/pg` from the same commit) created. That release wrote no schema marker and
- * kept nullable v1 facade columns, so canonical storage cannot open it. Its data is not migrated.
- */
-export declare const INTERIM_KNOWLEDGE_COLUMNS: ReadonlyMap<string, readonly string[]>;
-/** Indexes the interim release created on {@link INTERIM_KNOWLEDGE_COLUMNS} tables. */
-export declare const INTERIM_KNOWLEDGE_INDEX_NAMES: ReadonlySet<string>;
-/**
- * Every column layout a published interim build created. Snapshots `0.0.0-knowledge-w1-20261008204450`
- * onward match {@link INTERIM_KNOWLEDGE_COLUMNS}. Earlier snapshots kept extra record columns, and
- * `0.0.0-knowledge-w1-20261006001735` also the v1 cursors table. Later builds never dropped those, so a
- * database first initialized by an early snapshot keeps its layout; it only gains the later indexes.
- */
-export declare const INTERIM_KNOWLEDGE_LAYOUTS: readonly ReadonlyMap<string, readonly string[]>[];
-/**
- * True when `columnsByTable` (every Knowledge-prefixed table and its columns) is exactly one of the
- * {@link INTERIM_KNOWLEDGE_LAYOUTS}: every table present, no other tables, and each with exactly those
- * columns. Pass `timestampShadows` for PostgreSQL, whose adapters add a `<column>Z` timestamptz shadow.
- */
-export declare function isInterimKnowledgeLayout(columnsByTable: ReadonlyMap<string, readonly string[]>, { timestampShadows }?: {
-  timestampShadows?: boolean;
-}): boolean;
-/**
- * Index names a replaceable non-canonical layout may carry, or `null` when `columnsByTable` is neither
- * the published v1 layout nor the interim layout.
+ * 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 replaceableKnowledgeLayoutIndexNames(columnsByTable: ReadonlyMap<string, readonly string[]>, options?: {
-  timestampShadows?: boolean;
-}): ReadonlySet<string> | null;
+export declare function inspectKnowledgePagesSchema(snapshot: {
+  tableNames: readonly string[];
+  schemaVersion?: number;
+}): KnowledgePagesSchemaInspection;
+/** Message for the error an adapter throws on `incompatible-reset-required`. */
+export declare function knowledgePagesResetMessage(reason: string): string;
 /**
- * The warning to log when replacing a non-canonical layout discards rows, or `null` when it held none.
- * The access-state row is bookkeeping every init writes, so it alone never warrants a warning.
+ * 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 declare function discardedKnowledgeRowsWarning(columnsByTable: ReadonlyMap<string, readonly string[]>, rowCounts: ReadonlyMap<string, number>, options?: {
-  timestampShadows?: boolean;
-}): {
-  message: string;
-  details: {
-    layout: 'published-v1' | 'interim';
-    discardedRows: Record<string, number>;
-  };
-} | null;
-/** Tables a replaceable non-canonical layout may contain. */
-export declare const REPLACEABLE_KNOWLEDGE_TABLE_NAMES: ReadonlySet<string>;
-/** Appended to schema errors so callers learn the one supported way forward. */
-export declare const KNOWLEDGE_RESET_GUIDANCE = "Existing Knowledge data is not migrated. To replace it, call `await storage.stores?.knowledge?.dangerouslyReset()`, which deletes every Knowledge row and nothing else.";
-/** Mirrors `StorageColumn` from `@mastra/core/storage`. */
-export interface KnowledgeStorageColumn {
-  type: 'text' | 'timestamp' | 'uuid' | 'jsonb' | 'integer' | 'float' | 'bigint' | 'boolean';
-  primaryKey?: boolean;
-  nullable?: boolean;
-  references?: {
-    table: string;
-    column: string;
-  };
+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;
 }
-export declare const KNOWLEDGE_NODE_SCOPES_SCHEMA: Record<string, KnowledgeStorageColumn>;
-export declare const KNOWLEDGE_RECORD_SCOPES_SCHEMA: Record<string, KnowledgeStorageColumn>;
-export declare const KNOWLEDGE_SCOPE_GRANTS_SCHEMA: Record<string, KnowledgeStorageColumn>;
-export declare const KNOWLEDGE_ACCESS_STATE_SCHEMA: Record<string, KnowledgeStorageColumn>;
-export declare const KNOWLEDGE_SCHEMA_SCHEMA: Record<string, KnowledgeStorageColumn>;
-export declare const KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA: Record<string, KnowledgeStorageColumn>;
-export declare const KNOWLEDGE_NODE_ADDRESSES_SCHEMA: Record<string, KnowledgeStorageColumn>;
-export declare const KNOWLEDGE_IMPORT_STATE_SCHEMA: Record<string, KnowledgeStorageColumn>;
-export declare const KNOWLEDGE_IMPORT_RUNS_SCHEMA: Record<string, KnowledgeStorageColumn>;
-export declare const KNOWLEDGE_PROPOSALS_SCHEMA: Record<string, KnowledgeStorageColumn>;
-/** Canonicalizes a node UUID. */
-export declare function canonicalizeKnowledgeNodeId(id: string): string;
-/** Canonicalizes a set of scope-node UUIDs. */
-export declare function canonicalizeKnowledgeScopeIds(scopeIds: string[]): string[];
-export declare function knowledgeScopeIdsKey(scopeIds: string[]): string;
-/** Canonicalizes a stored `[source, scope]` importer binding key. */
-export declare function canonicalizeKnowledgeImporterBindingKey(binding: string): string;
-/** Scope nodes are visible through their own identity as well as their direct parent memberships. */
-export declare function isKnowledgeNodeVisible(node: {
-  id: string;
-  isScope: boolean;
-}, nodeScopeIds: string[], visibleScopeIds: string[]): boolean;
-/** Knowledge runtime values adapters take from the installed `@mastra/core`. */
-export interface KnowledgeCore {
-  KnowledgeSchemaError: new (message: string) => Error;
-  KnowledgeUnsupportedError: new (adapter?: string) => Error;
-  sanitizeKnowledgeImportError(error: unknown): string;
-}
-export declare function assertKnowledgeCoreSupport(features: ReadonlySet<string>): void;
-/**
- * Returns a coalesced loader for core's Knowledge runtime. It rejects cores without the Knowledge feature
- * before importing anything, and retries after a failed import.
- */
-export declare function createKnowledgeCoreLoader(features: ReadonlySet<string>, loadStorageModule: () => Promise<unknown>): () => Promise<KnowledgeCore>;
+/** 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>;
 /**
- * Importer claims (mirrors `@mastra/core/storage` so adapters run against any core with Knowledge).
- * A claim is one importer binding's contribution to a node's memberships or a record, stored in that
- * binding's import state and written in the same transaction as the change it describes.
+ * Keyword-search words: the query split on whitespace, lowercased, deduplicated. Every word must
+ * appear (as a case-insensitive substring) in a hit; an empty list means the search returns nothing.
  */
-export interface KnowledgeImportClaimCompat {
-  importerId: string;
-  binding: string;
-  source: string;
-  targetType: 'node' | 'record';
-  targetId: string;
-  scopeIds: string[];
-  version: number;
-}
-export declare function knowledgeImportClaimKey(targetType: 'node' | 'record', targetId: string): string;
-export declare function parseKnowledgeImportClaim(state: {
-  importerId: string;
-  binding: string;
-  key: string;
-  value: string;
-}): KnowledgeImportClaimCompat | null;
-export declare function serializeKnowledgeImportClaim(claim: {
-  source: string;
-  scopeIds: string[];
-  version: number;
-}): string;
-/** Memberships after one claimant replaces its claim, keeping what other claims (or no claim) hold. */
-export declare function reconcileKnowledgeClaimScopes(input: {
-  current: string[];
-  previous: string[];
-  next: string[];
-  others: string[];
-}): string[];
+export declare function knowledgeSearchWords(query: string): string[];
 /**
- * Version for the scope-less claim a release leaves on a node when no claim from the same importer and source
- * remains, or `null` when one does. While the importer still owned the node, the marker follows the node so a moved
- * or re-added binding can adopt it; after an outside edit it keeps the importer's last version, so the edit is still
- * detected and never becomes importer-owned by being released.
+ * 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 knowledgeReleaseMarkerVersion(released: {
-  importerId: string;
-  source: string;
-  version: number;
-}, remaining: readonly {
-  importerId: string;
-  source: string;
-}[], versionBefore: number, versionAfter: number): number | null;
-export declare function isSameKnowledgeClaimant(left: {
-  importerId: string;
-  binding: string;
-}, right: {
-  importerId: string;
-  binding: string;
-}): boolean;
-/** Most sources one `listSourcesWithVisibleRecords` call may ask about. Mirrors the current core export. */
-export declare const KNOWLEDGE_SOURCE_PROBE_LIMIT = 1000;
-export declare function assertKnowledgeSourceProbeLimit(sources: unknown[]): void;
-/** Most node plus record ids one `listVisibleKnowledgeIds` call may ask about. Mirrors the current core export. */
-export declare const KNOWLEDGE_VISIBILITY_PROBE_LIMIT = 1000;
-export declare function assertKnowledgeVisibilityProbeLimit(input: {
-  nodeIds: string[];
-  recordIds: string[];
-}): void;
-//#endregion
+export declare function knowledgePageKeyProblem(key: string): string | undefined;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,4 +1,3 @@
-//#region src/memory/index.d.ts
 /**
  * Shared rules for observational memory lifecycle writes. Every storage adapter applies
  * these inside its own atomic section (lock, transaction, or conditional update), so the
@@ -97,5 +96,4 @@ export declare function assertActiveObservationsApplied(result: UpdateActiveObse
  * (equal, or only appended to since).
  */
 export declare function isAppendOnlySince(storedObservations: string, snapshotObservations: string): boolean;
-//#endregion
 //# 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: "0.0.0-knowledge-studio-20261029065150"
+  version: "0.0.0-knowledge-alpha-studio-20261030162625"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.0-knowledge-studio-20261029065150",
+  "version": "0.0.0-knowledge-alpha-studio-20261030162625",
   "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'
@@ -311,6 +311,9 @@ Instead of pausing every tool call at the agent level, you can mark individual t
 Set `requireApproval: true` on a tool definition. The tool pauses before execution regardless of whether `requireToolApproval` is set on the agent:
 
 ```typescript
+import { createTool } from '@mastra/core/tools'
+import { z } from 'zod'
+
 export const testTool = createTool({
   id: 'test-tool',
   description: 'Fetches weather for a location',
@@ -359,6 +362,9 @@ const handleApproval = async () => {
 With this approach, neither the agent nor the tool uses `requireApproval`. Instead, the tool's `execute` function calls `suspend()` to pause at a specific point and return context or confirmation prompts to the user. This is useful when approval depends on runtime conditions rather than being unconditional.
 
 ```typescript
+import { createTool } from '@mastra/core/tools'
+import { z } from 'zod'
+
 export const testToolB = createTool({
   id: 'test-tool-b',
   description: 'Fetches weather for a location',
@@ -662,6 +668,9 @@ for await (const chunk of stream.fullStream) {
 Tools can also use [`suspend()`](#approval-using-suspend) to pause execution and return context to the user. This approach works through the supervisor delegation chain the same way `requireApproval` does: the suspension surfaces at the supervisor level:
 
 ```typescript
+import { createTool } from '@mastra/core/tools'
+import { z } from 'zod'
+
 const conditionalTool = createTool({
   id: 'conditional-operation',
   description: 'Performs an operation that may require confirmation',

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-message-history.md

@@ -138,6 +138,9 @@ If you assemble the request input yourself and need it processed exactly as sent
 Message count is a poor proxy for context size: a tool result can be a few tokens or thousands. Use `messageHistory` to keep recent history within a token budget instead:
 
 ```typescript
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+
 export const agent = new Agent({
   id: 'test-agent',
   memory: new Memory({