@dbx-tools/appkit-memory 0.0.0-stage → 0.9.131

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,79 @@
-# Temporary Holding Version
+# `@dbx-tools/appkit-memory`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Add durable, actor-scoped memory tools to an AppKit application. The plugin
+checks Databricks Agent Memory first and starts its Graphiti sidecar only when
+the current actor cannot access the configured managed-memory store.
+
+## Register the plugin
+
+```ts
+import { createApp, server } from "@databricks/appkit";
+import { memory } from "@dbx-tools/appkit-memory";
+
+await createApp({
+  plugins: [
+    server(),
+    memory({
+      databricks: { memoryStore: "support-memory" },
+      graphiti: { modelClass: "chat-fast" },
+    }),
+  ],
+});
+```
+
+`memory()` publishes two tools:
+
+- `remember` saves content at a stable absolute path.
+- `recall_memory` searches durable memory for the current actor.
+
+A 403 or 404 from the Databricks store selects Graphiti. Other Databricks
+errors propagate so a transient outage does not split one actor's memory
+between backends.
+
+`databricks` defaults to `"auto"`. Set it to `true` to require managed-memory
+access for every caller or `false` to disable the managed backend. The object
+form accepts `memoryStore` and `mode: "auto" | "required"`.
+
+## Use with Mastra
+
+Request the toolkit from an agent:
+
+```ts
+import { agents, mastra } from "@dbx-tools/appkit-mastra";
+
+const support = agents.createAgent({
+  instructions: "Help the user.",
+  async tools(plugins) {
+    return (await plugins.memory?.toolkit()) ?? {};
+  },
+});
+
+await createApp({
+  plugins: [server(), mastra({ agents: { support } }), memory()],
+});
+```
+
+Mastra continues to store threads and messages in its configured
+`PostgresStore` and semantic recall in `PgVector`. `saveTurns` defaults to
+`"auto"`, which attaches the memory plugin's output processor when both Mastra
+and Graphiti are registered. Set it to `true` to require attachment at startup
+or `false` to disable it. Completed turns are mirrored to Graphiti only when
+Databricks managed memory is unavailable. Managed-memory session extraction is
+not used.
+
+## Graphiti runtime
+
+The Graphiti fallback is imported and started on the first operation that needs
+it. Concurrent first operations share one startup. Configure `PYTHON` to use an
+installed runtime or let the package provision the matching Python package
+through `uv`.
+
+Standalone Graphiti callers and the dbx CLI use the public subpath:
+
+```ts
+import { runtime as graphiti } from "@dbx-tools/appkit-memory/graphiti";
+
+await graphiti.runGraphiti({ profile: "MY-PROFILE" });
+```
+
+# replace this

package/index.ts

@@ -0,0 +1,17 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-memory";
+export const PACKAGE_VERSION = "0.9.131";
+export * as config from "./src/config.ts";
+export * as databricksClient from "./src/databricks/client.ts";
+export * as graphitiOptions from "./src/graphiti/options.ts";
+export * as graphitiRuntime from "./src/graphiti/runtime.ts";
+export * as plugin from "./src/plugin.ts";
+export { DatabricksMemoryOptionsSchema, MemoryPluginOptionsSchema, MEMORY_CONFIG_SCHEMA } from "./src/config.ts";
+export type { DatabricksMemoryOptions, MemoryPluginOptions, MemoryPluginConfig, ResolvedDatabricksMemoryOptions, ResolvedMemoryPluginConfig } from "./src/config.ts";
+export { ManagedMemoryEntrySchema, ManagedAgentMemoryClient } from "./src/databricks/client.ts";
+export type { ManagedMemoryEntry, ManagedMemorySearchResult } from "./src/databricks/client.ts";
+export type { GraphitiHealthCheckContext, GraphitiHealthCheck, GraphitiChildProcess, GraphitiRuntimeOptions, GraphitiPythonCommand } from "./src/graphiti/runtime.ts";
+export { MemoryPlugin, memory } from "./src/plugin.ts";

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+export declare const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-memory";
+export declare const PACKAGE_VERSION = "0.9.131";
+export * as config from "./src/config.ts";
+export * as databricksClient from "./src/databricks/client.ts";
+export * as graphitiOptions from "./src/graphiti/options.ts";
+export * as graphitiRuntime from "./src/graphiti/runtime.ts";
+export * as plugin from "./src/plugin.ts";
+export { DatabricksMemoryOptionsSchema, MemoryPluginOptionsSchema, MEMORY_CONFIG_SCHEMA } from "./src/config.ts";
+export type { DatabricksMemoryOptions, MemoryPluginOptions, MemoryPluginConfig, ResolvedDatabricksMemoryOptions, ResolvedMemoryPluginConfig } from "./src/config.ts";
+export { ManagedMemoryEntrySchema, ManagedAgentMemoryClient } from "./src/databricks/client.ts";
+export type { ManagedMemoryEntry, ManagedMemorySearchResult } from "./src/databricks/client.ts";
+export type { GraphitiHealthCheckContext, GraphitiHealthCheck, GraphitiChildProcess, GraphitiRuntimeOptions, GraphitiPythonCommand } from "./src/graphiti/runtime.ts";
+export { MemoryPlugin, memory } from "./src/plugin.ts";

package/lib/index.js

@@ -0,0 +1,14 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-memory";
+export const PACKAGE_VERSION = "0.9.131";
+export * as config from "./src/config.js";
+export * as databricksClient from "./src/databricks/client.js";
+export * as graphitiOptions from "./src/graphiti/options.js";
+export * as graphitiRuntime from "./src/graphiti/runtime.js";
+export * as plugin from "./src/plugin.js";
+export { DatabricksMemoryOptionsSchema, MemoryPluginOptionsSchema, MEMORY_CONFIG_SCHEMA } from "./src/config.js";
+export { ManagedMemoryEntrySchema, ManagedAgentMemoryClient } from "./src/databricks/client.js";
+export { MemoryPlugin, memory } from "./src/plugin.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/smoke/mastra-tool.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/smoke/mastra-tool.js

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { MemoryPlugin } from "../src/plugin.js";
+const { values } = parseArgs({
+    options: {
+        profile: { type: "string" },
+    },
+});
+const profile = values.profile?.trim();
+if (!profile)
+    throw new Error("Usage: bun mastra-tool.ts --profile <databricks-profile>");
+const graphitiHome = join(tmpdir(), `dbx-tools-memory-graphiti-${crypto.randomUUID()}`);
+const resourceId = `smoke-${crypto.randomUUID()}`;
+async function start() {
+    const plugin = new MemoryPlugin({
+        databricks: false,
+        graphiti: { profile, graphitiHome },
+    });
+    await plugin.setup();
+    return plugin;
+}
+let plugin;
+try {
+    plugin = await start();
+    assert.deepEqual(plugin.getAgentTools().map(({ name }) => name), ["remember", "recall_memory"]);
+    const saved = await plugin.executeAgentTool("remember", {
+        path: "/facts/employment.md",
+        content: "Reggie Pierce works for Databricks.",
+        description: "Employment fact",
+    }, undefined, { resourceId });
+    assert.equal(saved.backend, "graphiti");
+    const firstSearch = await plugin.executeAgentTool("recall_memory", { query: "Where does Reggie Pierce work?", limit: 10 }, undefined, { resourceId });
+    assert.ok(firstSearch.memories?.length);
+    await plugin.shutdown();
+    plugin = await start();
+    const restartedSearch = await plugin.executeAgentTool("recall_memory", { query: "Reggie Pierce employment", limit: 10 }, undefined, { resourceId });
+    assert.ok(restartedSearch.memories?.length);
+}
+finally {
+    await plugin?.shutdown();
+    await rm(graphitiHome, { recursive: true, force: true });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_contracts.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Backend-neutral memory tool and turn contracts.
+ *
+ * @module
+ */
+import { z } from "zod";
+export declare const RememberMemoryInputSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RememberMemoryInput = z.infer<typeof RememberMemoryInputSchema>;
+export declare const RecallMemoryInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodCoercedNumber<number>>;
+}, z.core.$strict>;
+export type RecallMemoryInput = z.input<typeof RecallMemoryInputSchema>;
+export declare const MemoryBackendSchema: z.ZodEnum<{
+    databricks: "databricks";
+    graphiti: "graphiti";
+}>;
+export type MemoryBackend = z.infer<typeof MemoryBackendSchema>;
+export declare const MemoryRecordSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    score: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type MemoryRecord = z.infer<typeof MemoryRecordSchema>;
+export declare const RememberMemoryResultSchema: z.ZodObject<{
+    backend: z.ZodEnum<{
+        databricks: "databricks";
+        graphiti: "graphiti";
+    }>;
+    memory: z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        score: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RememberMemoryResult = z.infer<typeof RememberMemoryResultSchema>;
+export declare const RecallMemoryResultSchema: z.ZodObject<{
+    backend: z.ZodEnum<{
+        databricks: "databricks";
+        graphiti: "graphiti";
+    }>;
+    memories: z.ZodArray<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        score: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RecallMemoryResult = z.infer<typeof RecallMemoryResultSchema>;
+/** Completed Mastra turn offered to the optional external saver. */
+export interface MemoryTurn {
+    readonly agentId: string;
+    readonly actorId: string;
+    readonly threadId: string;
+    readonly user: string;
+    readonly assistant: string;
+}
+/** Lazy Graphiti backend used only after managed memory is unavailable. */
+export interface GraphitiMemoryBackend {
+    readonly running: boolean;
+    remember(actorId: string, input: RememberMemoryInput, signal?: AbortSignal): Promise<RememberMemoryResult>;
+    recall(actorId: string, input: z.output<typeof RecallMemoryInputSchema>, signal?: AbortSignal): Promise<RecallMemoryResult>;
+    saveTurn(turn: MemoryTurn, signal?: AbortSignal): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/lib/src/_contracts.js

@@ -0,0 +1,63 @@
+/**
+ * Backend-neutral memory tool and turn contracts.
+ *
+ * @module
+ */
+import { z } from "zod";
+export const RememberMemoryInputSchema = z
+    .object({
+    path: z
+        .string()
+        .trim()
+        .startsWith("/")
+        .describe("Stable absolute memory path, such as /preferences/response.md."),
+    content: z.string().trim().min(1).describe("Durable memory content."),
+    description: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Short retrieval-oriented description."),
+})
+    .strict()
+    .describe("Durable memory to save for the current actor.");
+export const RecallMemoryInputSchema = z
+    .object({
+    query: z.string().trim().min(1).describe("Question or phrase used to retrieve memory."),
+    limit: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(10)
+        .describe("Maximum number of matching memories to return."),
+})
+    .strict()
+    .describe("Actor-scoped memory search.");
+export const MemoryBackendSchema = z
+    .enum(["databricks", "graphiti"])
+    .describe("Memory backend that completed the operation.");
+export const MemoryRecordSchema = z
+    .object({
+    path: z.string().optional().describe("Stable memory path when the backend supports paths."),
+    content: z.string().describe("Retrieved or saved memory content."),
+    description: z.string().optional().describe("Retrieval-oriented memory description."),
+    score: z.number().optional().describe("Backend relevance score when available."),
+})
+    .strict()
+    .describe("Backend-neutral durable memory record.");
+export const RememberMemoryResultSchema = z
+    .object({
+    backend: MemoryBackendSchema,
+    memory: MemoryRecordSchema,
+})
+    .strict()
+    .describe("Result of saving one durable memory.");
+export const RecallMemoryResultSchema = z
+    .object({
+    backend: MemoryBackendSchema,
+    memories: z.array(MemoryRecordSchema).describe("Matching actor-scoped memories."),
+})
+    .strict()
+    .describe("Result of one durable memory search.");
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_mastra.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Optional Mastra output-processor attachment.
+ *
+ * Loaded only when the memory plugin finds a registered Mastra sibling.
+ *
+ * @module
+ */
+import { pluginRegistry } from "@dbx-tools/appkit";
+import type { MemoryTurn } from "./_contracts.ts";
+/** Attach a memory-owned turn saver through Mastra's generic processor extension. */
+export declare function attachMastraTurnSaver(context: pluginRegistry.PluginContextLike, saveTurn: (turn: MemoryTurn, signal?: AbortSignal) => Promise<void>): Promise<boolean>;

package/lib/src/_mastra.js

@@ -0,0 +1,66 @@
+/**
+ * Optional Mastra output-processor attachment.
+ *
+ * Loaded only when the memory plugin finds a registered Mastra sibling.
+ *
+ * @module
+ */
+import { pluginRegistry } from "@dbx-tools/appkit";
+import { errorUtils, log, object } from "@dbx-tools/shared-core";
+const logger = log.logger("memory/mastra");
+/** Attach a memory-owned turn saver through Mastra's generic processor extension. */
+export async function attachMastraTurnSaver(context, saveTurn) {
+    const mastraModule = await import("@dbx-tools/appkit-mastra");
+    const plugin = pluginRegistry.instance(context, mastraModule.mastra);
+    if (!plugin)
+        return false;
+    plugin.exports().registerOutputProcessor((agentId) => ({
+        id: `appkit_memory_${agentId}`,
+        name: "AppKit memory turn saver",
+        description: "Saves completed turns to the configured fallback memory backend.",
+        processOutputResult: async ({ messageList, requestContext, abortSignal }) => {
+            const scope = mastraModule.memory.requestMemoryScope(requestContext);
+            if (!scope)
+                return messageList;
+            const actorId = typeof scope.resource === "string" ? scope.resource : undefined;
+            const threadId = typeof scope.thread === "string" ? scope.thread : undefined;
+            if (!actorId || !threadId)
+                return messageList;
+            const user = latestText(messageList.get.input.db(), "user");
+            const assistant = latestText(messageList.get.response.db(), "assistant");
+            if (!user || !assistant)
+                return messageList;
+            try {
+                await saveTurn({
+                    agentId,
+                    actorId,
+                    threadId,
+                    user,
+                    assistant,
+                }, abortSignal);
+            }
+            catch (error) {
+                logger.warn("turn save failed", { error: errorUtils.toError(error), agentId });
+            }
+            return messageList;
+        },
+    }));
+    return true;
+}
+function latestText(messages, role) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role !== role)
+            continue;
+        const text = message.content.parts
+            .flatMap((part) => object.isRecord(part) && part.type === "text" && typeof part.text === "string"
+            ? [part.text]
+            : [])
+            .join("\n")
+            .trim();
+        if (text)
+            return text;
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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