@mastra/libsql 0.0.0-knowledge-w2-demo-20261009074925 → 0.0.0-knowledge-studio-20261029065150

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

@@ -0,0 +1,203 @@
+//#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 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 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 RETIRED_KNOWLEDGE_TABLE_NAMES: readonly ['mastra_knowledge_cursors'];
+/**
+ * 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.
+ */
+export declare function replaceableKnowledgeLayoutIndexNames(columnsByTable: ReadonlyMap<string, readonly string[]>, options?: {
+  timestampShadows?: boolean;
+}): ReadonlySet<string> | null;
+/**
+ * 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.
+ */
+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 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>;
+/**
+ * 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.
+ */
+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[];
+/**
+ * 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.
+ */
+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
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,101 @@
+//#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
+ * 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;
+//#endregion
+//# 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: "0.0.0-knowledge-w2-demo-20261009074925"
+  version: "0.0.0-knowledge-studio-20261029065150"
 ---
 
 ## When to use
@@ -25,6 +25,7 @@ Read the individual reference documents for detailed explanations and code examp
 - [Memory](references/docs-memory-overview.md) - Add memory to Mastra agents with message history, semantic recall, working memory, and observational memory across threads and multi-agent delegation.
 - [Semantic recall](references/docs-memory-semantic-recall.md) - Retrieve relevant messages from past Mastra conversations with semantic recall, vector search, embeddings, metadata filters, and configurable storage.
 - [Working memory](references/docs-memory-working-memory.md) - Persist user profiles, preferences, and application data with Mastra working memory using resource- or thread-scoped templates and storage adapters.
+- [Signals](references/docs-signals-overview.md) - Send asynchronous input into a Mastra agent thread while Mastra manages whether the agent is active or idle.
 - [Storage](references/docs-storage.md) - Configure Mastra storage to persist memory, workflow state, observability data, evals, schedules, and long-running agent state across restarts.
 - [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.

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.0-knowledge-w2-demo-20261009074925",
+  "version": "0.0.0-knowledge-studio-20261029065150",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-agents-human-in-the-loop.md

@@ -36,7 +36,7 @@ const deleteTool = createTool({
 const agent = new Agent({
   id: 'my-agent',
   name: 'My Agent',
-  model: 'openai/gpt-5-mini',
+  model: 'openai/gpt-6-luna',
   tools: { deleteTool },
 })
 
@@ -144,7 +144,8 @@ const stream = await agent.stream('Clean up old records', {
       },
     })
 
-    return result.answers.requiresApproval.probability >= 0.7
+    // A refused question has no probability, so it falls back to requiring approval.
+    return (result.answers.requiresApproval.probability ?? 1) >= 0.7
   },
 })
 ```
@@ -178,7 +179,7 @@ const approvedFingerprints = new Set<string>()
 export const approvalBoundAgent = new Agent({
   id: 'approval-bound-agent',
   name: 'Approval Bound Agent',
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   tools: { issueRefundTool, deleteRecordTool },
   hooks: {
     beforeToolCall: ({ toolName, input }) => {
@@ -409,6 +410,19 @@ const handleResume = async () => {
 }
 ```
 
+With `generate()`, the result has `finishReason: 'suspended'`. The tool's data from `suspend()` is in `suspendPayload.suspendPayload`. Call `resumeGenerate()` with the `resumeSchema` data and `runId`:
+
+```typescript
+const output = await agent.generate("What's the weather in London?")
+
+if (output.finishReason === 'suspended') {
+  console.log(output.suspendPayload.suspendPayload) // { reason: 'Approval required.' }
+
+  const resumed = await agent.resumeGenerate({ approved: true }, { runId: output.runId! })
+  console.log(resumed.text)
+}
+```
+
 When a suspended or approval-gated tool call resumes, the stream emits a `tool-call-resumed` chunk with the same `toolCallId` before the call's `tool-result`. Its `payload.kind` is `'suspension'` or `'approval'`, and the payload repeats the original `args`, `suspendPayload`, and `resumeSchema`. The chunk is only emitted when a real suspension or approval request is cleared.
 
 With `@mastra/ai-sdk`, it arrives as a `data-tool-call-suspended` part (or `data-tool-call-approval` part for approvals) with `resumed: true`, which replaces the original part and keeps its payload. Use this signal to mark a question as answered. Don't infer it from the shape of the tool output: when the suspension came from a sub-agent, the output of the delegation call is the sub-agent's result, not your answer.
@@ -425,7 +439,7 @@ const agent = new Agent({
   id: 'my-agent',
   name: 'My Agent',
   instructions: 'You are a helpful assistant',
-  model: 'openai/gpt-5-mini',
+  model: 'openai/gpt-6-luna',
   tools: { weatherTool },
   memory: new Memory(),
   defaultOptions: {
@@ -603,7 +617,7 @@ const dataAgent = new Agent({
   id: 'data-agent',
   name: 'Data Agent',
   description: 'Handles database queries and user data retrieval',
-  model: 'openai/gpt-5-mini',
+  model: 'openai/gpt-6-luna',
   tools: { findUserTool },
 })
 
@@ -612,7 +626,7 @@ const supervisorAgent = new Agent({
   name: 'Supervisor Agent',
   instructions: `You coordinate data retrieval tasks.
     Delegate to data-agent for user lookups.`,
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   agents: { dataAgent },
   memory: new Memory(),
 })

package/dist/docs/references/docs-agents-networks.md

@@ -31,7 +31,7 @@ export const routingAgent = new Agent({
   name: 'Routing Agent',
   instructions: `
     You are a network of writers and researchers. The user will ask you to research a topic. Always respond with a complete report—no bullet points. Write in full paragraphs, like a blog post. Do not answer with incomplete or uncertain information.`,
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   agents: {
     researchAgent,
     writingAgent,

package/dist/docs/references/docs-deployment-workers.md

@@ -146,7 +146,7 @@ Workers are internal infrastructure. They're not exposed to end users and don't
 In a split deployment:
 
 - **The API server is the only public-facing process**: It serves all client HTTP requests. These requests include REST endpoints and agent interactions, plus workflow triggers and custom routes.
-- **Workers connect outbound only**: They pull events from the distributed PubSub backend and read/write to the shared storage database. They don't accept inbound traffic from clients.
+- **Workers don't serve client traffic**: They pull events from the distributed PubSub backend and read/write to the shared storage database. Each worker process also listens on `PORT` (default `4111`) for internal health checks. `/health` reports readiness and `/config` returns the worker configuration to authorized callers. Keep this port on the private network.
 - **The orchestration worker calls the API internally**: It sends step execution requests to the API over the container network using `MASTRA_STEP_EXECUTION_URL`. This is internal service-to-service communication, not a public endpoint.
 
 All three worker types (orchestration, scheduler, background task) sit behind the API on a private network. They share access to the PubSub backend and storage database but never receive traffic directly from clients. HTTP routes for worker-related features run on the API server rather than the worker process. One example is creating a token for a voice integration.

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

@@ -28,13 +28,15 @@ Retrieves message history and persists new messages.
 
 ```typescript
 memory: new Memory({
-  lastMessages: 10,
+  options: {
+    lastMessages: 10,
+  },
 })
 ```
 
 **Mastra internally:**
 
-1. Creates a `MessageHistory` processor with `limit: 10`
+1. Creates a `MessageHistory` processor with `lastMessages: 10`
 2. Adds it to the agent's input processors (runs before the LLM)
 3. Adds it to the agent's output processors (runs after the LLM)
 
@@ -55,13 +57,15 @@ const agent = new Agent({
   id: 'test-agent',
   name: 'Test Agent',
   instructions: 'You are a helpful assistant',
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   memory: new Memory({
     storage: new LibSQLStore({
       id: 'memory-store',
       url: 'file:memory.db',
     }),
-    lastMessages: 10, // MessageHistory processor automatically added
+    options: {
+      lastMessages: 10, // MessageHistory processor automatically added
+    },
   }),
 })
 ```
@@ -85,7 +89,7 @@ memory: new Memory({
 1. Creates a `SemanticRecall` processor
 2. Adds it to the agent's input processors (runs before the LLM)
 3. Adds it to the agent's output processors (runs after the LLM)
-4. Requires both a vector store and embedder to be configured
+4. Requires a vector store, plus an embedder unless the vector store generates embeddings itself
 
 **What it does:**
 
@@ -105,7 +109,7 @@ import { openai } from '@ai-sdk/openai'
 const agent = new Agent({
   name: 'semantic-agent',
   instructions: 'You are a helpful assistant with semantic memory',
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   memory: new Memory({
     storage: new LibSQLStore({
       id: 'memory-store',
@@ -155,7 +159,7 @@ import { openai } from '@ai-sdk/openai'
 const agent = new Agent({
   name: 'working-memory-agent',
   instructions: 'You are an assistant with working memory',
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   memory: new Memory({
     storage: new LibSQLStore({
       id: 'memory-store',
@@ -187,10 +191,12 @@ const customMessageHistory = new MessageHistory({
 const agent = new Agent({
   name: 'custom-memory-agent',
   instructions: 'You are a helpful assistant',
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   memory: new Memory({
     storage: new LibSQLStore({ id: 'memory-store', url: 'file:memory.db' }),
-    lastMessages: 10, // This would normally add MessageHistory(10)
+    options: {
+      lastMessages: 10, // This would normally add MessageHistory(10)
+    },
   }),
   inputProcessors: [
     customMessageHistory, // Your custom one is used instead
@@ -258,8 +264,8 @@ const agent = new Agent({
   id: 'safe-agent',
   name: 'safe-agent',
   instructions: 'You are a helpful assistant',
-  model: 'openai/gpt-5.6-sol',
-  memory: new Memory({ lastMessages: 10 }),
+  model: 'openai/gpt-6.1-sol',
+  memory: new Memory({ options: { lastMessages: 10 } }),
   // Your guardrail runs BEFORE memory saves
   outputProcessors: [contentBlocker],
 })
@@ -298,8 +304,8 @@ const agent = new Agent({
   id: 'validated-agent',
   name: 'validated-agent',
   instructions: 'You are a helpful assistant',
-  model: 'openai/gpt-5.6-sol',
-  memory: new Memory({ lastMessages: 10 }),
+  model: 'openai/gpt-6.1-sol',
+  memory: new Memory({ options: { lastMessages: 10 } }),
   // Your guardrail runs AFTER memory loads history
   inputProcessors: [inputValidator],
 })
@@ -375,8 +381,8 @@ export const supportAgent = new Agent({
   id: 'support-agent',
   name: 'Support agent',
   instructions: 'Answer customer support questions.',
-  model: 'openai/gpt-5.6-sol',
-  memory: new Memory({ lastMessages: 10 }),
+  model: 'openai/gpt-6.1-sol',
+  memory: new Memory({ options: { lastMessages: 10 } }),
   inputProcessors: [new AttachmentUploader()],
 })
 ```

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:
@@ -124,7 +116,22 @@ You can use this history in two ways:
 - **Automatic inclusion**: Mastra automatically includes recent messages in the context window. The default of 10 messages keeps agents grounded in the conversation. Adjust it with `lastMessages` when needed.
 - [**Manual querying**](#querying): For more control, query threads and messages directly with `recall()`. Use the results to choose which memories enter the context window or to render conversation history in your UI.
 
-> **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.
+> **Note:** `lastMessages` counts every stored message, including tool calls, tool results, and [signals](https://mastra.ai/docs/signals/sending-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
 
@@ -161,7 +168,7 @@ export const supportAgent = new Agent({
   id: 'support-agent',
   name: 'Support agent',
   instructions: 'Answer customer support questions.',
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   memory: new Memory({
     options: {
       generateTitle: true,
@@ -184,7 +191,7 @@ export const supportAgent = new Agent({
   id: 'support-agent',
   name: 'Support agent',
   instructions: 'Answer customer support questions.',
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   memory: new Memory({
     options: {
       generateTitle: {
@@ -219,11 +226,11 @@ export const supportAgent = new Agent({
   id: 'support-agent',
   name: 'Support agent',
   instructions: 'Answer customer support questions.',
-  model: 'openai/gpt-5.6-sol',
+  model: 'openai/gpt-6.1-sol',
   memory: new Memory({
     options: {
       generateTitle: {
-        model: 'openai/gpt-5-mini',
+        model: 'openai/gpt-6-luna',
         instructions: 'Generate a one-word title.',
       },
     },

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

@@ -69,7 +69,7 @@ const memory = new Memory({
 export const collabAgent = new Agent({
   id: 'collab',
   name: 'CollabAgent',
-  model: 'openai/gpt-5-mini',
+  model: 'openai/gpt-6-luna',
   memory,
   instructions: `
 You are a collaborative document assistant. Multiple users talk to you in the SAME thread.
@@ -158,7 +158,7 @@ const memory = new Memory({
 })
 ```
 
-OM requires a storage adapter that supports it: `@mastra/libsql`, `@mastra/pg`, `@mastra/mongodb`, or `@mastra/oracledb`.
+OM requires a storage adapter that supports it: `@mastra/libsql`, `@mastra/pg`, `@mastra/mongodb`, `@mastra/mysql`, `@mastra/convex`, or `@mastra/oracledb`.
 
 > **Note:** If you switch the Observer to a less capable model and see facts attributed to a generic `User` instead of individual participants, use [`observation.instruction`](https://mastra.ai/reference/memory/observational-memory) to explain how to interpret the `<turn>` tag.