purra-mem0 0.5.1 → 1.0.1

package/MEM0-LICENSE

@@ -0,0 +1,201 @@
+                                 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 [2023] [Taranjeet Singh]
+
+   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

@@ -11,11 +11,7 @@ Follow [source installation](../../README.md#source-installation), selecting
 `integrations/mem0/typescript`. Mem0's local store needs the `better-sqlite3`
 native installation scripts.
 
-For managed LLM/Embedding callbacks, install the optional peer in your application:
-
-```sh
-npm install @langchain/core@1.1.47
-```
+Managed callbacks use the native PurrA adapters included in this package; no LangChain installation is required.
 
 Before importing Mem0, set `MEM0_TELEMETRY=false` and an application-owned
 `MEM0_DIR`. Explicitly configure the LLM, embedder, `vectorStore.config.dbPath`,
@@ -137,8 +133,64 @@ pass `policy(candidate, review)` and a stable `policyRevision` to `MemoryWorkflo
 Return an authorized `MemoryResolution` that retains the review key, or `undefined`
 to leave the candidate pending. The policy may be async.
 
+To require authorization before messages can reach Mem0 or its providers, bind a
+host-issued grant to the exact capture intent:
+
+```ts
+import { MemoryWorkflow, memoryCaptureIntent } from "purra-mem0";
+
+const capturePolicyId = "project-memory";
+const capturePolicyRevision = "2026-09-09";
+const authorization = {
+  intentDigest: memoryCaptureIntent(messages, { source, metadata }),
+  policyId: capturePolicyId,
+  policyRevision: capturePolicyRevision,
+  principalId: authenticatedUserId,
+  decisionId: hostDecisionId,
+};
+const workflow = new MemoryWorkflow(memory, { capturePolicyId, capturePolicyRevision });
+await memory.recordCaptureAuthorization(authorization, {
+  key: `capture-authorization:${hostDecisionId}`,
+  expiresAt: captureAuthorizationExpiresAt,
+});
+const result = await workflow.capture(messages, {
+  source, key: operationKey, metadata, authorization,
+});
+```
+
+The host owns authentication, eligibility and audit of the decision. Keep the
+authorization unchanged on retry. Missing or mismatched grants fail before the
+operation journal and Provider calls; changing a bound grant under the same key
+causes an idempotency conflict.
+
+Call `revokeCaptureAuthorization(policyId, decisionId, { key })` to persist a
+revocation. It prevents new extraction, review and activation under the decision
+and hides records produced by it. Expiry only stops new processing. Neither path
+physically deletes Mem0 content or history.
+
 ## Lifecycle
 
 Before shutdown, call `await memory.drain()` and `memory.close()`, then close SDK
 and provider resources. For paging, withdrawal, evidence validation, and uncertain
 writes, see the [memory lifecycle guide](../README.md).
+
+
+## Native managed providers
+
+`createManagedClient` inject native LLM and Embedding adapters into a version-pinned, package-private Mem0 module. Calls retain the existing PurrA budget, cancellation and result validation. Explicit vector dimensions must agree; the managed path rejects LangChain vector stores. It neither patches the installed SDK nor starts a proxy server. See [third-party notices](THIRD_PARTY_NOTICES.md). Raw SDK clients remain host-owned and do not acquire managed accounting automatically.
+
+## Host-controlled selection and relation proposals
+
+`new MemoryContext({ memory, selectIds: hostSelect })` accepts an async
+`hostSelect(request, signal)` returning ordered memory IDs. Supply either
+`selectIds` or the existing `query`, never both. The component rereads authorized
+records, validates evidence, and fits complete records into the context budget.
+The host owns retrieval combination, ordering, callback timeout and model costs.
+
+`proposeMemoryRelations(memory, refs, { relations: allowedNames, extract: hostExtract })`
+is exported from `purra-mem0`. Its async extractor receives `(input, signal)` and
+returns objects with exactly `from`, `to`, `relation`, `fromQuote`, `toQuote` string
+fields. IDs must match supplied `MemoryRef` revisions and quotes must occur in
+those records. Returned immutable proposals do not write links or prove that a
+relation is true. The host reviews proposals and explicitly calls `memory.link`.
+No automatic model invocation, retry or adoption policy is installed.

package/README.zh-CN.md

@@ -10,11 +10,7 @@
 按照[源码安装说明](../../README.zh-CN.md#从源码安装)操作，选择
 `integrations/mem0/typescript`。Mem0 的本地存储需要执行 `better-sqlite3` 的原生安装脚本。
 
-需要受控的 LLM/Embedding 回调时，在应用中安装可选 peer 依赖：
-
-```sh
-npm install @langchain/core@1.1.47
-```
+原生受控模型和向量回调已包含在本包内，无需安装 LangChain。
 
 导入 Mem0 前，设置 `MEM0_TELEMETRY=false`，并将 `MEM0_DIR` 指向应用管理的数据目录。
 显式配置 LLM、embedder、`vectorStore.config.dbPath` 和 `historyDbPath`。
@@ -127,7 +123,51 @@ async function capture(
 `policy(candidate, review)` 和稳定的 `policyRevision`。
 策略返回已授权且保留审查键的 `MemoryResolution`，或返回 `undefined` 保持待处理；策略可以是异步函数。
 
+需要在消息到达 Mem0 或 Provider 前强制授权时，绑定宿主签发的准确捕获意图：
+
+```ts
+import { MemoryWorkflow, memoryCaptureIntent } from "purra-mem0";
+
+const authorization = {
+  intentDigest: memoryCaptureIntent(messages, { source, metadata }),
+  policyId: capturePolicyId,
+  policyRevision: capturePolicyRevision,
+  principalId: authenticatedUserId,
+  decisionId: hostDecisionId,
+};
+const workflow = new MemoryWorkflow(memory, { capturePolicyId, capturePolicyRevision });
+await memory.recordCaptureAuthorization(authorization, {
+  key: `capture-authorization:${hostDecisionId}`,
+  expiresAt: captureAuthorizationExpiresAt,
+});
+const result = await workflow.capture(messages, {
+  source, key: operationKey, metadata, authorization,
+});
+```
+
+宿主负责认证、内容适用性和决定审计。重试必须沿用相同授权；缺失或不匹配的授权会在
+操作日志及 Provider 调用前失败，同一 key 更换已绑定授权会触发幂等冲突。
+调用 `revokeCaptureAuthorization(policyId, decisionId, { key })` 可持久撤销决定，阻止
+新的提取、审查和激活，并隐藏由其产生的记录。到期只阻止新处理；两者均不物理删除
+Mem0 内容或历史。
+
 ## 生命周期
 
 关闭前调用 `await memory.drain()` 和 `memory.close()`，再关闭 SDK 与模型服务资源。
 分页、来源撤回、证据校验和不确定写入的处理见[记忆生命周期指南](../README.zh-CN.md)。
+
+
+## 原生受控适配
+
+`createManagedClient` 把 PurrA 的原生模型和向量适配器注入包内、版本固定的 Mem0 私有模块，沿用现有预算、取消与结果校验。向量维度必须一致，受控路径拒绝 LangChain 向量库。不修改宿主安装的官方 SDK，也不启动代理服务。来源、许可证与修改说明见[第三方声明](THIRD_PARTY_NOTICES.md)。直接传入的原始 SDK 客户端仍由宿主管理，不自动获得受控回调的计费。
+
+## 宿主选择与关系候选
+
+`MemoryContext` 支持异步 `selectIds(request, signal)`，与原有 `query` 二选一。
+宿主返回有序记忆 ID；组件重新读取并验证来源、版本和预算，不接受替换文本。
+
+`purra-mem0` 导出的 `proposeMemoryRelations` 接受记忆引用、宿主关系词表和异步 `extract`。
+抽取回调返回仅含 `from`、`to`、`relation`、`fromQuote`、`toQuote` 字符串的对象数组。
+组件校验原文引用与当前记忆版本，只返回候选，不自动写入关系。
+关系是否成立、是否采纳和显式调用 `memory.link` 均由宿主决定。
+模型调用的授权、超时和费用预算也由宿主负责。

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,9 @@
+# Mem0 attribution and local modifications
+
+This package includes a private module derived from Mem0 (https://github.com/mem0ai/mem0), copyright Mem0 contributors, licensed under Apache-2.0 (MEM0-LICENSE).
+
+Python uses mem0ai 2.0.19 memory/main.py; TypeScript uses mem0ai 3.1.7 dist/oss/index.mjs. PurrA modifies constructor provider injection and, in TypeScript, preserves injected providers across reset. The extension also identifies injected providers and releases SDK-owned local handles on failed initialization; the TypeScript managed factory awaits initialization before returning. These are PurrA-owned private copies, not replacements for or modifications to the installed official mem0ai package. The SDK algorithms remain upstream-owned.
+
+The repository integrations/mem0/sdk/upstream.json records input hashes. Python scripts/sync_sdk.py verifies/regenerates the checked-in private module; TypeScript scripts/build-sdk.mjs generates dist/sdk-memory.js during the package build. No patching or source generation happens when a consumer imports the package.
+
+Generated source is reviewed by verifying the pinned input and the small transformation, then exercising SDK contract and installed-package tests. SDK upgrades require an explicit hash/contract review. Native provider clients are not constructed on the managed path. The private SDK is not part of the public API.

package/dist/context.d.ts

@@ -1,10 +1,12 @@
 import type { ContextBlock, ContextEvidenceReceipt, ContextBudget, ContextBudgetClaim, ContextBundle, ContextProvider, ContextRequest } from "purra";
 import { Mem0Memory } from "./memory.js";
+export type MemorySelectionPolicy = (request: ContextRequest, signal?: AbortSignal) => Promise<readonly string[]>;
 export declare class MemoryContext implements ContextProvider {
     #private;
     constructor(options: {
         memory: Mem0Memory;
-        query: (request: ContextRequest) => string;
+        query?: (request: ContextRequest) => string;
+        selectIds?: MemorySelectionPolicy;
         countTokens?: (content: string) => number;
         name?: string;
         desiredTokens?: number;

package/dist/context.js

@@ -1,8 +1,14 @@
 import { estimateJsonTokens } from "purra";
 import { Mem0Memory, positiveInteger, requiredText } from "./memory.js";
+import { MemoryError } from "./journal.js";
+function validateContextAllowance(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 1_000_000)
+        throw new TypeError("invalid context allowance");
+}
 export class MemoryContext {
     #memory;
     #query;
+    #selectIds;
     #countTokens;
     #name;
     #desiredTokens;
@@ -10,32 +16,44 @@ export class MemoryContext {
     constructor(options) {
         this.#memory = options.memory;
         this.#query = options.query;
+        this.#selectIds = options.selectIds;
         this.#countTokens = options.countTokens ?? estimateJsonTokens;
         this.#name = requiredText(options.name ?? "memory", "context name", 128);
         this.#desiredTokens = positiveInteger(options.desiredTokens ?? 1024, "desiredTokens", 1_000_000);
         this.#limit = positiveInteger(options.limit ?? 8, "limit");
-        if (typeof this.#query !== "function" || typeof this.#countTokens !== "function")
-            throw new TypeError("query and countTokens must be host functions");
+        if ((this.#query === undefined) === (this.#selectIds === undefined))
+            throw new TypeError("Provide exactly one of query or selectIds");
+        if (typeof (this.#selectIds ?? this.#query) !== "function" || typeof this.#countTokens !== "function")
+            throw new TypeError("Selection and countTokens must be host functions");
     }
     describeContextDemands() {
         return [{ name: this.#name, desiredTokens: this.#desiredTokens }];
     }
     async buildContext(request, budget, signal) {
-        const allowance = budget.contextAllocations[this.#name] ?? 0;
-        if (!allowance)
+        const allowance = Object.hasOwn(budget.contextAllocations, this.#name) ? budget.contextAllocations[this.#name] : 0;
+        validateContextAllowance(allowance);
+        if (allowance === 0)
             return { blocks: [] };
         const epoch = this.#memory.epoch;
-        const hits = await this.#memory.retrieve({ query: this.#query(request), limit: this.#limit, scope: {} }, signal);
-        const result = await assembleMemoryContext(this.#memory, hits.map(hit => hit.id), allowance, { name: this.#name, countTokens: this.#countTokens, expectedEpoch: epoch, ...(signal ? { signal } : {}) });
+        if (signal?.aborted)
+            throw new MemoryError("memory_cancelled");
+        const ids = this.#selectIds === undefined
+            ? (await this.#memory.retrieve({ query: this.#query(request), limit: this.#limit, scope: {} }, signal)).map(hit => hit.id)
+            : await this.#selectIds(request, signal);
+        const result = await assembleMemoryContext(this.#memory, ids, allowance, { name: this.#name, countTokens: this.#countTokens, expectedEpoch: epoch, ...(signal ? { signal } : {}) });
         return { blocks: result.block ? [result.block] : [] };
     }
 }
 /** Fresh authorized records; shared by Agent and non-Run consumers. */
 export async function assembleMemoryContext(memory, ids, allowance, options = {}) {
-    if (!Number.isSafeInteger(allowance) || allowance < 0 || allowance > 1_000_000)
-        throw new TypeError("invalid context allowance");
+    validateContextAllowance(allowance);
+    const countTokens = options.countTokens === undefined ? estimateJsonTokens : options.countTokens;
+    if (typeof countTokens !== "function")
+        throw new TypeError("countTokens must be callable");
     const name = requiredText(options.name ?? "memory", "context name", 128);
-    const countTokens = options.countTokens ?? estimateJsonTokens;
+    if (!Array.isArray(ids))
+        throw new TypeError("ids must be an array");
+    ids = Object.freeze([...ids]);
     const epoch = options.expectedEpoch ?? memory.epoch;
     memory.assertEpoch(epoch);
     const hits = await memory.select(ids, options.signal ? { signal: options.signal } : {});

package/dist/direct-providers.d.ts

@@ -0,0 +1,8 @@
+export declare class DirectLlm {
+    generateResponse(messages: unknown, format?: unknown, tools?: unknown, ...extra: unknown[]): Promise<string>;
+    generateChat(): Promise<never>;
+}
+export declare class DirectEmbedder {
+    embed(text: unknown, action?: unknown): Promise<number[]>;
+    embedBatch(texts: unknown, action?: unknown): Promise<number[][]>;
+}

package/dist/direct-providers.js

@@ -0,0 +1,43 @@
+import { currentExecution } from "./providers.js";
+import { MemoryError } from "./journal.js";
+function execution() {
+    const value = currentExecution();
+    if (!value)
+        throw new MemoryError("memory_provider_unbound");
+    value.check();
+    return value;
+}
+function reject(value) {
+    value.stop("memory_provider_contract");
+    throw new MemoryError(value.error);
+}
+export class DirectLlm {
+    async generateResponse(messages, format, tools, ...extra) {
+        const value = execution();
+        if (extra.length || (tools !== undefined && (!Array.isArray(tools) || tools.length))
+            || (format !== undefined && (format === null || typeof format !== "object"
+                || Object.keys(format).length !== 1 || format.type !== "json_object"))
+            || !Array.isArray(messages) || !messages.length)
+            reject(value);
+        const converted = Array.from(messages, (message) => {
+            if (!message || typeof message !== "object" || Object.keys(message).sort().join() !== "content,role")
+                reject(value);
+            const m = message;
+            if (!["system", "user", "assistant"].includes(m.role) || typeof m.content !== "string")
+                reject(value);
+            return { role: m.role, content: m.content };
+        });
+        return value.invoke("llm", converted);
+    }
+    async generateChat() { return reject(execution()); }
+}
+export class DirectEmbedder {
+    async embed(text, action) { return (await this.embedBatch([text], action))[0]; }
+    async embedBatch(texts, action) {
+        const value = execution();
+        if ((action !== undefined && !["add", "search", "update"].includes(action))
+            || !Array.isArray(texts) || Array.from(texts).some(text => typeof text !== "string"))
+            reject(value);
+        return texts.length ? value.invoke("embedding", [...texts]) : [];
+    }
+}

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 /** Optional Node.js integration; not imported by PurrA Core. */
 export { MemoryError } from "./journal.js";
-export { Mem0Memory } from "./memory.js";
-export type { Mem0Client, MemoryScope, MemorySource, MemoryRecord, MemoryMetadata, MemoryFilters, MemoryPage, MemoryOperation, MemoryRef, MemoryLink, MemoryLinkPage, MemoryResolution, MemoryReview, MemoryMatch } from "./memory.js";
-export type { MemoryContextResult } from "./context.js";
+export { Mem0Memory, memoryCaptureIntent } from "./memory.js";
+export type { Mem0Client, MemoryScope, MemorySource, MemoryCaptureAuthorization, MemoryRecord, MemoryMetadata, MemoryFilters, MemoryPage, MemoryOperation, MemoryRef, MemoryLink, MemoryLinkPage, MemoryRelationEvidence, MemoryResolution, MemoryReview, MemoryMatch } from "./memory.js";
+export type { MemoryContextResult, MemorySelectionPolicy } from "./context.js";
 export { MemoryContext, assembleMemoryContext } from "./context.js";
 export { createManagedClient, runModel } from "./providers.js";
 export type { MemoryBudget, MemoryProviders, MemoryUsage, EmbeddingResult, ManagedMem0Config } from "./providers.js";
 export { MemoryWorkflow } from "./workflow.js";
 export type { MemoryWorkflowResult, MemoryDecisionPolicy } from "./workflow.js";
+export { proposeMemoryRelations } from './relations.js';
+export type { MemoryRelationProposal, MemoryRelationExtractionInput, MemoryRelationExtractor } from './relations.js';

package/dist/index.js

@@ -1,6 +1,7 @@
 /** Optional Node.js integration; not imported by PurrA Core. */
 export { MemoryError } from "./journal.js";
-export { Mem0Memory } from "./memory.js";
+export { Mem0Memory, memoryCaptureIntent } from "./memory.js";
 export { MemoryContext, assembleMemoryContext } from "./context.js";
 export { createManagedClient, runModel } from "./providers.js";
 export { MemoryWorkflow } from "./workflow.js";
+export { proposeMemoryRelations } from './relations.js';

package/dist/journal.d.ts

@@ -18,6 +18,8 @@ export interface Metadata {
     purra_reason: string | null;
     purra_created: string;
     purra_updated: string;
+    purra_capture_policy?: string;
+    purra_capture_decision?: string;
 }
 export interface ItemView {
     version: number;
@@ -53,6 +55,17 @@ export interface Plan {
     policy_hash?: string;
     changes?: Partial<ItemView>;
     link?: Omit<MemoryLink, "key" | "valid">;
+    capture_authorization?: {
+        intent_digest: string;
+        policy_id: string;
+        policy_revision: string;
+        principal_id: string;
+        decision_id: string;
+    };
+    valid_from?: string | null;
+    expires?: string | null;
+    policy_id?: string;
+    decision_id?: string;
 }
 export interface OperationRow {
     key: string;
@@ -83,6 +96,10 @@ export declare class Journal {
     revoked(source: string, revision: string): boolean;
     assertSource(meta: Pick<Metadata, "purra_source" | "purra_revision">): void;
     revokeSource(key: string, fingerprint: string, source: string, revision: string | null): void;
+    captureRevoked(policy: string, decision: string): boolean;
+    assertCaptureAuthorization(authorization: NonNullable<Plan["capture_authorization"]>): void;
+    recordCaptureAuthorization(key: string, fingerprint: string, authorization: NonNullable<Plan["capture_authorization"]>, validFrom: string | null, expires: string | null): void;
+    revokeCaptureAuthorization(key: string, fingerprint: string, policy: string, decision: string): void;
     item(id: string): Item | undefined;
     resolve(key: string, fingerprint: string, plan: Plan, epoch: number): void;
     control(key: string, fingerprint: string, plan: Plan, epoch: number, refs: readonly MemoryRef[], changes: readonly Partial<ItemView>[]): void;