@mastra/libsql 1.25.2-alpha.1 → 1.26.0-alpha.2

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

@@ -0,0 +1,594 @@
+//#region src/knowledge-compat/index.d.ts
+declare const KNOWLEDGE_V2_CORE_FEATURE = "knowledge-v2";
+declare const KNOWLEDGE_STORAGE_CONTRACT_VERSION: 2;
+declare const KNOWLEDGE_STORAGE_SCHEMA_VERSION: 2;
+/** Hard cap on scope nodes returned by one `listScopeNodes` read. */
+declare const MAX_KNOWLEDGE_SCOPE_NODES = 1000;
+interface ListKnowledgeScopeNodesInput {
+  /** Only the scope at this address and the scopes beneath it, following parent edges transitively. */
+  withinAddress?: string;
+  /** Only the scopes at these exact addresses. */
+  addresses?: string[];
+  /** Only the scope nodes with these UUIDs. Combines with the other filters. */
+  ids?: string[];
+  /** `nextCursor` from the previous page of the same query. */
+  cursor?: string;
+  /** Page size, from 1 to `MAX_KNOWLEDGE_SCOPE_NODES` (the default). */
+  limit?: number;
+}
+interface ListKnowledgeScopeNodesOutput {
+  /** Scope nodes ordered by name, then id. */
+  scopes: KnowledgeScopeNodeSummary[];
+  /** Pass back as `cursor` for the next page; `null` when this is the last page. */
+  nextCursor: string | null;
+}
+declare function createKnowledgeScopeNodeCursor(scope: Pick<KnowledgeScopeNodeSummary, 'name' | 'id'>, input: ListKnowledgeScopeNodesInput): string;
+/** Validates the page size and cursor of a `listScopeNodes` query; throws on a cursor from a different query. */
+declare function parseListKnowledgeScopeNodesInput(input?: ListKnowledgeScopeNodesInput): {
+  limit: number;
+  after: {
+    name: string;
+    id: string;
+  } | null;
+};
+/** Builds a page from up to `limit + 1` name/id-ordered scope nodes. */
+declare function pageKnowledgeScopeNodes(rows: KnowledgeScopeNodeSummary[], limit: number, input: ListKnowledgeScopeNodesInput): ListKnowledgeScopeNodesOutput;
+/** A node placed inside a structural scope. Child scopes are members too, with `scope: null`. */
+interface KnowledgeScopeMember {
+  id: string;
+  type: 'node';
+  name: string;
+  kind: string;
+  content?: string;
+  description?: string;
+  scope: string[] | null;
+  version: number;
+  mergedInto?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface ListKnowledgeScopeMembersInput {
+  scopeNodeId: string;
+  /** `nextCursor` from the previous page for the same scope. */
+  cursor?: string;
+  /** Members to return, 1–500 (default 500). */
+  limit?: number;
+}
+interface ListKnowledgeScopeMembersOutput {
+  /** Most recently updated members first (ties by name, then ID), at most `limit`. */
+  members: KnowledgeScopeMember[];
+  /** True when the scope has more members than were returned. */
+  hasMore: boolean;
+  /** Pass as `cursor` to read the next page; `null` on the last page. */
+  nextCursor: string | null;
+}
+declare const MAX_KNOWLEDGE_SCOPE_MEMBERS_LIMIT = 500;
+/** Clamps a requested member limit to 1–{@link MAX_KNOWLEDGE_SCOPE_MEMBERS_LIMIT}. */
+declare function knowledgeScopeMembersLimit(limit: number | undefined): number;
+/** Validates the page size and cursor of a `listScopeMembers` query; throws on a cursor from another scope. */
+declare function parseListKnowledgeScopeMembersInput(input: ListKnowledgeScopeMembersInput): {
+  limit: number;
+  after: {
+    updatedAt: Date;
+    name: string;
+    id: string;
+  } | null;
+};
+/** Builds a page from up to `limit + 1` members in `listScopeMembers` order. */
+declare function pageKnowledgeScopeMembers(rows: KnowledgeScopeMember[], limit: number, input: ListKnowledgeScopeMembersInput): ListKnowledgeScopeMembersOutput;
+/** A reconciled structural scope node with its containing scope nodes. */
+interface KnowledgeScopeNodeSummary {
+  /** UUID of the `isScope` node. */
+  id: string;
+  /** Canonical address the scope node was reconciled from (e.g. `features:memory`). */
+  address: string;
+  name: string;
+  kind?: string;
+  description?: string;
+  /** UUIDs of the scope nodes that contain this scope (membership edges). */
+  parentIds: string[];
+}
+declare const TABLE_KNOWLEDGE_NODE_SCOPES = "mastra_knowledge_node_scopes";
+declare const TABLE_KNOWLEDGE_RECORD_SCOPES = "mastra_knowledge_record_scopes";
+declare const TABLE_KNOWLEDGE_SCOPE_GRANTS = "mastra_knowledge_scope_grants";
+declare const TABLE_KNOWLEDGE_ACCESS_STATE = "mastra_knowledge_access_state";
+declare const TABLE_KNOWLEDGE_SCOPE_ADDRESSES = "mastra_knowledge_scope_addresses";
+declare const TABLE_KNOWLEDGE_NODE_ADDRESSES = "mastra_knowledge_node_addresses";
+declare const TABLE_KNOWLEDGE_IMPORT_STATE = "mastra_knowledge_import_state";
+declare const TABLE_KNOWLEDGE_IMPORT_RUNS = "mastra_knowledge_import_runs";
+declare const TABLE_KNOWLEDGE_PROPOSALS = "mastra_knowledge_proposals";
+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. */
+declare const RETIRED_KNOWLEDGE_TABLE_NAMES: readonly ['mastra_knowledge_cursors'];
+/** Tables and indexes published v1 adapters created for every app, whether or not it used Knowledge. */
+declare const PUBLISHED_KNOWLEDGE_V1_TABLE_NAMES: ReadonlySet<string>;
+declare const PUBLISHED_KNOWLEDGE_V1_INDEX_NAMES: ReadonlySet<string>;
+declare const KNOWLEDGE_V2_NODES_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly name: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly kind: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly isScope: {
+    readonly type: 'boolean';
+    readonly nullable: false;
+  };
+  readonly metadata: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  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;
+  };
+  readonly type: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly canonicalName: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly content: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly description: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly scope: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly scopeKey: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly mergedInto: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_V2_RECORDS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly node: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly text: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly metadata: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly version: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly capturedAt: {
+    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;
+  };
+  readonly scope: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly scopeKey: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly sourceThreadId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly when: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_V2_MENTIONS_SCHEMA: {
+  readonly recordId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_records";
+      readonly column: 'id';
+    };
+  };
+  readonly targetNodeId: {
+    readonly type: 'text';
+    readonly nullable: true;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly sourceType: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly sourceId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_NODE_SCOPES_SCHEMA: {
+  readonly nodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly addedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_RECORD_SCOPES_SCHEMA: {
+  readonly recordId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_records";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly addedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_SCOPE_GRANTS_SCHEMA: {
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeRefId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly role: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly canSuggest: {
+    readonly type: 'boolean';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_ACCESS_STATE_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly epoch: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly schemaVersion: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA: {
+  readonly address: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+};
+declare const KNOWLEDGE_NODE_ADDRESSES_SCHEMA: {
+  readonly source: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly address: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly nodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+};
+declare const KNOWLEDGE_IMPORT_STATE_SCHEMA: {
+  readonly importerId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly binding: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly key: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly value: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_IMPORT_RUNS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly importerId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly binding: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly importKind: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly triggerKind: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly status: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly error: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly transcriptThreadId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly traceId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly queuedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly startedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly completedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_V2_ACTIVITY_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly action: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly targetType: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly targetId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly contextScopeId: {
+    readonly type: 'text';
+    readonly nullable: true;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly importRunId: {
+    readonly type: 'text';
+    readonly nullable: true;
+    readonly references: {
+      readonly table: "mastra_knowledge_import_runs";
+      readonly column: 'id';
+    };
+  };
+  readonly details: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly recordType: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly recordId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly scope: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly scopeKey: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly sourceThreadId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_PROPOSALS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly targetType: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly targetId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly action: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly changes: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly reason: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly proposerContextScopeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly expectedVersion: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly status: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly reviewerContextScopeId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly reviewedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+type KnowledgeSchemaInspection = {
+  status: 'compatible';
+  schemaVersion: typeof KNOWLEDGE_STORAGE_SCHEMA_VERSION;
+} | {
+  status: 'uninitialized';
+  schemaVersion: null;
+} | {
+  status: 'incompatible-reset-required';
+  schemaVersion: number | null;
+  reason: string;
+} | {
+  status: 'unavailable';
+  schemaVersion: null;
+  reason: string;
+};
+interface KnowledgeSchemaSnapshot {
+  available: boolean;
+  tableNames: readonly string[];
+  schemaVersion?: number;
+  reason?: string;
+}
+interface KnowledgeV2Core {
+  assertKnowledgeDescriptionWithinBound(description: string | undefined): void;
+  assertKnowledgeRecordTextWithinBound(text: string): void;
+  assertKnowledgeSchemaCompatible(inspection: KnowledgeSchemaInspection): void;
+  inspectKnowledgeSchema(snapshot: KnowledgeSchemaSnapshot): KnowledgeSchemaInspection;
+}
+declare function assertKnowledgeV2CoreSupport(features: ReadonlySet<string>): void;
+declare function createKnowledgeV2CoreLoader(features: ReadonlySet<string>, loadStorageModule: () => Promise<unknown>): () => Promise<KnowledgeV2Core>;
+//#endregion
+export { KNOWLEDGE_ACCESS_STATE_SCHEMA, KNOWLEDGE_IMPORT_RUNS_SCHEMA, KNOWLEDGE_IMPORT_STATE_SCHEMA, KNOWLEDGE_NODE_ADDRESSES_SCHEMA, KNOWLEDGE_NODE_SCOPES_SCHEMA, KNOWLEDGE_PROPOSALS_SCHEMA, KNOWLEDGE_RECORD_SCOPES_SCHEMA, KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA, KNOWLEDGE_SCOPE_GRANTS_SCHEMA, KNOWLEDGE_STORAGE_CONTRACT_VERSION, KNOWLEDGE_STORAGE_SCHEMA_VERSION, KNOWLEDGE_TABLE_NAMES, KNOWLEDGE_V2_ACTIVITY_SCHEMA, KNOWLEDGE_V2_CORE_FEATURE, KNOWLEDGE_V2_MENTIONS_SCHEMA, KNOWLEDGE_V2_NODES_SCHEMA, KNOWLEDGE_V2_RECORDS_SCHEMA, KnowledgeSchemaInspection, KnowledgeSchemaSnapshot, KnowledgeScopeMember, KnowledgeScopeNodeSummary, ListKnowledgeScopeMembersInput, ListKnowledgeScopeMembersOutput, ListKnowledgeScopeNodesInput, ListKnowledgeScopeNodesOutput, MAX_KNOWLEDGE_SCOPE_MEMBERS_LIMIT, MAX_KNOWLEDGE_SCOPE_NODES, PUBLISHED_KNOWLEDGE_V1_INDEX_NAMES, PUBLISHED_KNOWLEDGE_V1_TABLE_NAMES, RETIRED_KNOWLEDGE_TABLE_NAMES, TABLE_KNOWLEDGE_ACCESS_STATE, TABLE_KNOWLEDGE_IMPORT_RUNS, TABLE_KNOWLEDGE_IMPORT_STATE, TABLE_KNOWLEDGE_NODE_ADDRESSES, TABLE_KNOWLEDGE_NODE_SCOPES, TABLE_KNOWLEDGE_PROPOSALS, TABLE_KNOWLEDGE_RECORD_SCOPES, TABLE_KNOWLEDGE_SCOPE_ADDRESSES, TABLE_KNOWLEDGE_SCOPE_GRANTS, assertKnowledgeV2CoreSupport, createKnowledgeScopeNodeCursor, createKnowledgeV2CoreLoader, knowledgeScopeMembersLimit, pageKnowledgeScopeMembers, pageKnowledgeScopeNodes, parseListKnowledgeScopeMembersInput, parseListKnowledgeScopeNodesInput };
+//# sourceMappingURL=index.d.ts.map

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

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

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.25.2-alpha.1"
+  version: "1.26.0-alpha.2"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.25.2-alpha.1",
+  "version": "1.26.0-alpha.2",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-memory-message-history.md

@@ -10,14 +10,6 @@ You can also retrieve message history to display past conversations in your UI.
 
 > **Note:** Each message belongs to a thread (the conversation) and a resource (the user or entity it's associated with). See [Threads and resources](#threads-and-resources) for more detail.
 
-> **Warning:** When you use memory with a client application, send **only the new message** from the client instead of the full conversation history.
->
-> Sending the full history is redundant because Mastra loads messages from storage. Mastra filters client-echoed history before loading stored messages and uses the stored copy as the base when message IDs match, preserving stored timestamps and provider metadata while retaining new tool results.
->
-> If you assemble the request input yourself and need it processed exactly as sent, set `retainFullInput: true` on `memory.options` for that call, or in the memory constructor options to apply it agent-wide. This disables the filtering described above. History still loads underneath. Every input message that isn't already stored is saved to the thread, including few-shot examples.
->
-> For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/integrations/agentic-ui/ai-sdk-ui).
-
 ## Threads and resources
 
 Mastra organizes conversations using two identifiers:
@@ -126,6 +118,21 @@ You can use this history in two ways:
 
 > **Note:** `lastMessages` counts every stored message, including tool calls, tool results, and [signals](https://mastra.ai/docs/harness/signals) of any kind, so a single turn can add several messages to the count. The window also slides forward on every request: once a thread grows past the limit, the oldest message leaves context on each turn, which changes the start of the prompt and invalidates the provider prompt cache. For long-running conversations, use [Observational Memory](https://mastra.ai/docs/memory/observational-memory), which keeps the prompt prefix stable.
 
+### Sending messages from a client
+
+When you use memory with a client application, send **only the new message** instead of the full conversation history. Mastra loads previous messages from storage.
+
+For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/integrations/agentic-ui/ai-sdk-ui).
+
+<details>
+**Passing a full input history**
+
+Mastra filters client-echoed history before loading stored messages. When message IDs match, it uses the stored copy as the base, preserving stored timestamps and provider metadata while retaining new tool results.
+
+If you assemble the request input yourself and need it processed exactly as sent, set `retainFullInput: true` on `memory.options` for that call, or in the memory constructor options to apply it agent-wide. This disables input filtering, but stored history still loads. Every input message that isn't already stored is saved to the thread, including few-shot examples.
+
+</details>
+
 ### Limit history by tokens
 
 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: