@memoweft/adapter-ai-sdk 0.1.0

package/README.md

@@ -0,0 +1,84 @@
+# @memoweft/adapter-ai-sdk
+
+> 中文版 · [README.zh-CN.md](./README.zh-CN.md)
+
+**Vercel AI SDK adapter for [MemoWeft](https://github.com/memoweft/memoweft).** Give your AI SDK app long-term memory: **read** = recall relevant memory and inject it into the prompt; **write** = persist the user's own words after each turn.
+
+This is an **external integration package**. It wraps MemoWeft's public Core facade (`createMemoWeftCore`) — it does not touch Core internals. `ai` is a peer dependency (bring your own).
+
+## Install
+
+```bash
+npm i ai memoweft @memoweft/adapter-ai-sdk
+```
+
+`ai` `^7` and `memoweft` `^0.5.0` are peer dependencies. You also need an `ai` provider (e.g. `@ai-sdk/openai`) for a real model.
+
+## Two paths: read and write
+
+### Read — recall via middleware
+
+`createMemoWeftMiddleware(core)` returns a Vercel AI SDK `LanguageModelMiddleware`. In `transformParams` it takes the **last user message text**, calls `core.recall({ query })`, and injects the recalled cognitions into that user message before the model sees it.
+
+```ts
+import { wrapLanguageModel, generateText } from 'ai';
+import { createMemoWeftCore } from 'memoweft';
+import { createMemoWeftMiddleware } from '@memoweft/adapter-ai-sdk';
+
+const core = createMemoWeftCore({ dbPath: './memory.db' });
+
+const model = wrapLanguageModel({
+  model: baseModel, // your @ai-sdk/* model
+  middleware: createMemoWeftMiddleware(core),
+});
+
+const { text } = await generateText({ model, prompt: 'Explain recursion.' });
+```
+
+The injected block uses MemoWeft's own neutral wording (ported verbatim from Core's `knowledgeBlock`). Low-confidence items are explicitly marked *"only guesses — do not treat as established facts."* The adapter **adds no persona / character prompt** of its own — tone and role stay the host's job.
+
+If recall returns nothing, the query has no user text, or recall throws, the params pass through unchanged (recall failure never blocks the reply).
+
+Options: `{ subjectId?, lang?: 'en' | 'zh', onRecall? }`.
+
+### Write — persist the user's turn on finish
+
+`createPersistOnEnd(core, { userMessage, originId })` returns a callback for `generateText`/`streamText`'s **`onEnd`** (the SDK's `onFinish` is a deprecated alias for `onEnd`). After the turn ends it calls `core.ingestUserMessage` to store **the user's own words** as one `spoken` evidence.
+
+```ts
+import { createPersistOnEnd } from '@memoweft/adapter-ai-sdk';
+
+const userMessage = 'I strongly prefer short, direct answers.';
+await generateText({
+  model,
+  prompt: userMessage,
+  onEnd: createPersistOnEnd(core, { userMessage, originId: 'turn-1' }),
+});
+```
+
+**Why you pass `userMessage` explicitly:** the SDK's `onEnd` event carries only *result-side* fields (text, steps, usage, response…). It does not carry the original user input, and the request body sent to the provider has already been rewritten by the read middleware (recalled memory injected). So the only clean source of the user's real words is the value you already hold when you call `generateText`. The `onEnd` event object is **not used** — it is just the trigger.
+
+- **User words only, never the assistant reply** (Core discipline: the assistant reply is not recorded as evidence).
+- Give a stable `originId` (your turn/message id) for **idempotency** — the same turn stores at most one evidence even if `onEnd` fires more than once.
+- No cloud-authorization bits are passed: `ingestUserMessage` stores `spoken` evidence, which does not involve the observed cloud-consent flags.
+- Empty/whitespace-only input is skipped. Ingest errors go to `onError` (or are swallowed) — persisting memory never crashes your turn.
+
+There is also a plain `persistUserTurn(core, { userMessage, originId? })` if you want to call it outside an `onEnd` hook.
+
+## Full example
+
+See [`examples/basic.ts`](./examples/basic.ts) — a two-turn chat where turn 1's words are stored and recalled into turn 2's prompt.
+
+## Relationship to the MemoWeft Host
+
+The Host (`apps/memoweft-host`) is MemoWeft's *reference application* — chat UI, multi-session, backups. This adapter is the *opposite direction*: it lets **your** app (built on the Vercel AI SDK) reuse MemoWeft as a memory backend, without the Host. Both talk to the same public Core facade; they don't depend on each other. Pick the Host if you want a ready UI; pick this adapter if you already have an AI SDK app and just want the memory layer.
+
+## What it does not do
+
+- No persona / character prompt (Core is headless — tone/role is the host's job).
+- Does not store the assistant reply, only the user's words.
+- Does not widen `observed` cloud sharing, and does not pass authorization bits on the write path.
+
+## License
+
+MIT

package/README.zh-CN.md

@@ -0,0 +1,84 @@
+# @memoweft/adapter-ai-sdk
+
+> English · [README.md](./README.md)
+
+**[MemoWeft](https://github.com/memoweft/memoweft) 的 Vercel AI SDK 适配器。** 给你的 AI SDK 应用接上长期记忆：**读** = 召回相关记忆、注入进 prompt；**写** = 每轮对话结束后，沉淀【用户原话】。
+
+这是个**外部集成包**，只消费 MemoWeft 的公开 Core 门面（`createMemoWeftCore`），不碰 Core 内部。`ai` 是 peer 依赖（你自备）。
+
+## 安装
+
+```bash
+npm i ai memoweft @memoweft/adapter-ai-sdk
+```
+
+`ai`（`^7`）和 `memoweft`（`^0.5.0`）是 peer 依赖；跑真模型还需一个 `ai` provider（如 `@ai-sdk/openai`）。
+
+## 两条路：读和写
+
+### 读 —— 用 middleware 召回
+
+`createMemoWeftMiddleware(core)` 返回一个 Vercel AI SDK 的 `LanguageModelMiddleware`。它在 `transformParams` 里取**最后一条 user 消息的文本**，调 `core.recall({ query })`，把召回到的认知注入回那条 user 消息，再交给模型。
+
+```ts
+import { wrapLanguageModel, generateText } from 'ai';
+import { createMemoWeftCore } from 'memoweft';
+import { createMemoWeftMiddleware } from '@memoweft/adapter-ai-sdk';
+
+const core = createMemoWeftCore({ dbPath: './memory.db' });
+
+const model = wrapLanguageModel({
+  model: baseModel, // 你的 @ai-sdk/* 模型
+  middleware: createMemoWeftMiddleware(core),
+});
+
+const { text } = await generateText({ model, prompt: '讲讲递归。' });
+```
+
+注入的这段说明**照搬 MemoWeft Core 现成的中性措辞**（逐字对齐 Core 的 `knowledgeBlock`）：低置信条目明确标"只是假设，别当定论"。适配器**不自造任何人格/人设 prompt**——语气和角色仍归宿主。
+
+召回为空、没有 user 文本、或召回抛错时，params 原样透传（召回失败绝不挡回话）。
+
+选项：`{ subjectId?, lang?: 'en' | 'zh', onRecall? }`。
+
+### 写 —— 对话结束沉淀用户原话
+
+`createPersistOnEnd(core, { userMessage, originId })` 返回一个塞给 `generateText`/`streamText` 的 **`onEnd`** 回调（SDK 的 `onFinish` 是 `onEnd` 的 @deprecated 别名）。这一轮结束后，它调 `core.ingestUserMessage`，把【用户原话】存成一条 `spoken` 证据。
+
+```ts
+import { createPersistOnEnd } from '@memoweft/adapter-ai-sdk';
+
+const userMessage = '我很偏好简短、直接的回答。';
+await generateText({
+  model,
+  prompt: userMessage,
+  onEnd: createPersistOnEnd(core, { userMessage, originId: 'turn-1' }),
+});
+```
+
+**为什么要你显式传 `userMessage`：** SDK 的 `onEnd` 事件只带【结果侧】字段（text、steps、usage、response…），**不带**原始用户输入；而发给 provider 的请求体已经被读 middleware 改过（注入了召回记忆）。所以"用户真正说的那句原话"唯一干净的来源，就是你调 `generateText` 时本来就持有的那份。`onEnd` 事件对象**不被使用**——它只当触发时机。
+
+- **只存用户原话、绝不存助手回话**（Core 纪律：助手回话不落证据）。
+- 给稳定的 `originId`（你的 turnId/messageId）保证**幂等**——同一轮即便 `onEnd` 触发多次也只落一条。
+- **不传任何上云授权位**：`ingestUserMessage` 存 `spoken` 证据，本就不涉 observed 的上云授权位。
+- 空串/纯空白跳过不落库；落库出错走 `onError`（或静默吞）——存记忆失败绝不崩你这轮对话。
+
+也有一个直白的 `persistUserTurn(core, { userMessage, originId? })`，想在 `onEnd` 之外自己调时用。
+
+## 完整示例
+
+见 [`examples/basic.ts`](./examples/basic.ts)——两轮对话：第 1 轮的话被存进去、召回进第 2 轮的 prompt。
+
+## 与 MemoWeft Host 的关系
+
+Host（`apps/memoweft-host`）是 MemoWeft 的*参考应用*——聊天界面、多会话、备份。本适配器是*反方向*：让**你自己**的应用（基于 Vercel AI SDK 搭的）把 MemoWeft 当记忆后端复用，不需要 Host。两者都对着同一个公开 Core 门面，彼此不依赖。想要现成 UI 就用 Host；已经有 AI SDK 应用、只想要记忆层，就用本适配器。
+
+## 不做什么
+
+- 不做人格/人设 prompt（Core 无头——语气/角色归宿主）。
+- 不存助手回话，只存用户原话。
+- 不放宽 `observed` 上云，写路径不传授权位。
+
+## 许可
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @memoweft/adapter-ai-sdk · 公开面。
+ *
+ * 把 MemoWeft 的长期记忆接进 Vercel AI SDK（`ai`）：
+ *   - 读：createMemoWeftMiddleware(core) → 塞进 wrapLanguageModel，召回记忆注入进 prompt。
+ *   - 写：createPersistOnEnd(core, { userMessage, originId }) → 塞进 generateText 的 onEnd，
+ *         对话结束后把【用户原话】沉淀成 spoken 证据（不存助手回话）。
+ */
+export { createMemoWeftMiddleware, buildKnowledgeBlock, getLastUserMessageText, addToLastUserMessage, type MemoWeftMiddlewareOptions, } from './recallMiddleware.ts';
+export { createPersistOnEnd, persistUserTurn, type PersistOnEndOptions, type PersistUserTurnInput, } from './persistOnEnd.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * @memoweft/adapter-ai-sdk · 公开面。
+ *
+ * 把 MemoWeft 的长期记忆接进 Vercel AI SDK（`ai`）：
+ *   - 读：createMemoWeftMiddleware(core) → 塞进 wrapLanguageModel，召回记忆注入进 prompt。
+ *   - 写：createPersistOnEnd(core, { userMessage, originId }) → 塞进 generateText 的 onEnd，
+ *         对话结束后把【用户原话】沉淀成 spoken 证据（不存助手回话）。
+ */
+export { createMemoWeftMiddleware, buildKnowledgeBlock, getLastUserMessageText, addToLastUserMessage, } from "./recallMiddleware.js";
+export { createPersistOnEnd, persistUserTurn, } from "./persistOnEnd.js";
+//# sourceMappingURL=index.js.map

package/dist/persistOnEnd.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 写适配器：一轮对话结束后，把【用户这轮说的原话】沉淀成 MemoWeft 的 spoken 证据。
+ *
+ * 为什么由调用方显式传用户原话，而不是从 onEnd 事件里解析：
+ *   Vercel AI SDK 的 onEnd（generateText/streamText）事件字段全是【结果侧】
+ *   （text/content/steps/usage/responseMessages/response…），SDK 不保证有原始用户输入。
+ *   而发给 provider 的 request.body 已经被读适配器 middleware 注入过召回文本——
+ *   若从那里反解析用户话，会把注入的记忆一起当成"用户原话"存回去（脏数据）。
+ *   所以用户原话必须由调用方在发起 generateText 时就知道、显式交给本 helper（闭包捕获）。
+ *   onEnd 只用来当"这一轮成功结束了、可以落库"的触发时机。
+ *
+ * Core 纪律（本适配器严格照做）：
+ *   - 只存【用户原话】，不存助手回话（conversation.ts 纪律：助手回话不落证据）。
+ *   - 走 core.ingestUserMessage（只落一条 spoken 证据、不改画像）。
+ *   - 稳定 originId 保证幂等（同一轮即便 onEnd 被触发多次 / 重放，也只落一条）。
+ */
+import type { MemoWeftCore } from 'memoweft';
+/** 只依赖 ingestUserMessage 一个方法——测试可传最小 stub。 */
+type IngestOnly = Pick<MemoWeftCore, 'ingestUserMessage'>;
+export interface PersistUserTurnInput {
+    /** 用户这轮说的原话（由调用方在发起 generateText 时就持有的那份，别从模型响应里回捞）。 */
+    userMessage: string;
+    /**
+     * 稳定幂等键：同一轮对话给同一个 originId，重复触发 onEnd 也只落一条。
+     * 建议宿主用自己的 turnId / messageId；不传则不去重（每次都落，见 Core originId 语义）。
+     */
+    originId?: string | null;
+    subjectId?: string;
+    hostId?: string;
+    /** ISO 时间戳；缺省交给 Core（perceive 里取"现在"）。 */
+    occurredAt?: string;
+}
+/**
+ * 直接落一轮用户原话（薄封装 core.ingestUserMessage，字段名对齐 Core `UserMessageInput`）。
+ * 不做任何"从响应里提取"的事——传进来什么原话就存什么。
+ */
+export declare function persistUserTurn(core: IngestOnly, input: PersistUserTurnInput): Promise<void>;
+/** 造 onEnd 回调时的选项（用户原话由 factory 参数闭包捕获）。 */
+export interface PersistOnEndOptions {
+    /** 用户这轮说的原话（发起 generateText 时就持有的那份）。 */
+    userMessage: string;
+    /** 稳定幂等键（强烈建议给：同一轮的 turnId/messageId）。 */
+    originId?: string | null;
+    subjectId?: string;
+    hostId?: string;
+    occurredAt?: string;
+    /** 落库出错时的回调（可选；不给则静默吞——落记忆失败不该崩主流程）。 */
+    onError?: (err: unknown) => void;
+}
+/**
+ * 造一个可直接塞进 `generateText({ onEnd })` / `streamText({ onEnd })` 的回调。
+ *
+ * onEnd（`onFinish` 是它的 @deprecated 别名）事件对象【不被本回调使用】——
+ *   用户原话来自闭包捕获的 opts.userMessage，事件仅作触发时机。
+ * 回调返回 Promise：generateText 会 await onEnd（Callback 类型允许返回 PromiseLike），
+ *   所以落库完成后才 resolve；出错走 onError、不向外抛（不崩宿主主流程）。
+ *
+ * 用法：
+ *   const userMessage = '……用户这轮的话……';
+ *   await generateText({
+ *     model: wrapLanguageModel({ model, middleware: createMemoWeftMiddleware(core) }),
+ *     prompt: userMessage,
+ *     onEnd: createPersistOnEnd(core, { userMessage, originId: turnId }),
+ *   });
+ */
+export declare function createPersistOnEnd(core: IngestOnly, opts: PersistOnEndOptions): (event?: unknown) => Promise<void>;
+export {};
+//# sourceMappingURL=persistOnEnd.d.ts.map

package/dist/persistOnEnd.js

@@ -0,0 +1,56 @@
+/**
+ * 直接落一轮用户原话（薄封装 core.ingestUserMessage，字段名对齐 Core `UserMessageInput`）。
+ * 不做任何"从响应里提取"的事——传进来什么原话就存什么。
+ */
+export async function persistUserTurn(core, input) {
+    const text = input.userMessage;
+    // 空串 / 全空白不落库（没有"用户原话"可存）。
+    if (typeof text !== 'string' || text.trim() === '')
+        return;
+    await core.ingestUserMessage({
+        content: text,
+        originId: input.originId ?? null,
+        subjectId: input.subjectId,
+        hostId: input.hostId,
+        occurredAt: input.occurredAt,
+        // sourceKind 不传：Core 缺省 'spoken'（用户亲口）。
+        // 注意：不传任何授权位——ingestUserMessage 存 spoken，本就不涉上云授权位（红线）。
+    });
+}
+/**
+ * 造一个可直接塞进 `generateText({ onEnd })` / `streamText({ onEnd })` 的回调。
+ *
+ * onEnd（`onFinish` 是它的 @deprecated 别名）事件对象【不被本回调使用】——
+ *   用户原话来自闭包捕获的 opts.userMessage，事件仅作触发时机。
+ * 回调返回 Promise：generateText 会 await onEnd（Callback 类型允许返回 PromiseLike），
+ *   所以落库完成后才 resolve；出错走 onError、不向外抛（不崩宿主主流程）。
+ *
+ * 用法：
+ *   const userMessage = '……用户这轮的话……';
+ *   await generateText({
+ *     model: wrapLanguageModel({ model, middleware: createMemoWeftMiddleware(core) }),
+ *     prompt: userMessage,
+ *     onEnd: createPersistOnEnd(core, { userMessage, originId: turnId }),
+ *   });
+ */
+export function createPersistOnEnd(core, opts) {
+    // 形参 event 被【故意忽略】——用户原话来自闭包 opts.userMessage，事件仅作触发时机。
+    //   声明它只为契合 SDK Callback = (event) => PromiseLike<void>，能直接塞进 onEnd。
+    return async (_event) => {
+        try {
+            await persistUserTurn(core, {
+                userMessage: opts.userMessage,
+                originId: opts.originId,
+                subjectId: opts.subjectId,
+                hostId: opts.hostId,
+                occurredAt: opts.occurredAt,
+            });
+        }
+        catch (err) {
+            if (opts.onError)
+                opts.onError(err);
+            // 无 onError 时静默吞：落记忆失败不该让宿主这轮对话失败。
+        }
+    };
+}
+//# sourceMappingURL=persistOnEnd.js.map

package/dist/recallMiddleware.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 读适配器（RAG-as-middleware）：把 MemoWeft 的长期记忆召回，注入进发给模型的 prompt。
+ *
+ * 范式：`wrapLanguageModel({ model, middleware: createMemoWeftMiddleware(core) })`。
+ * 在 `transformParams` 里取本轮最后一条 user 文本 → `await core.recall({ query })` →
+ * 按 Core 现成的 knowledgeBlock 中性口径拼成一段说明 → 注入回最后一条 user 消息。
+ *
+ * 边界（照 MemoWeft「Core 无头」纪律）：注入文案只搬 Core `action.ts` 的中性措辞，
+ *   低置信条目明确标 "only guesses—do not treat as established facts"。适配器里不自造人格/人设 prompt。
+ *
+ * 类型：用 `ai` re-export 的宽松 `LanguageModelMiddleware`（specificationVersion 可选，抗大版本漂移），
+ *   不直绑 `@ai-sdk/provider` 的强版类型。
+ */
+import type { LanguageModelMiddleware } from 'ai';
+import type { MemoWeftCore } from 'memoweft';
+/** 最小召回项形状（只用注入需要的三个字段）。故意不引 Core 的完整类型，保持松耦合。 */
+interface RecalledLike {
+    content: string;
+    confidence: number;
+    credStatus: string;
+}
+/** 只依赖 recall 一个方法——测试可传最小 stub。 */
+type RecallOnly = Pick<MemoWeftCore, 'recall'>;
+export interface MemoWeftMiddlewareOptions {
+    /** 召回归属的 subject；缺省交给 Core（config.identity.subjectId）。 */
+    subjectId?: string;
+    /**
+     * 注入块的语言（措辞照 Core action.ts 的 knowledgeBlock 双语口径）。缺省 'en'。
+     * 只影响适配器拼的这段说明文字，不改 Core 行为。
+     */
+    lang?: 'en' | 'zh';
+    /** 召回为空时的回调（可选，便于宿主观测/日志）。 */
+    onRecall?: (items: RecalledLike[]) => void;
+}
+/**
+ * 拼注入块：照搬 Core `src/pipeline/action.ts` 的 knowledgeBlock 中性措辞（逐字对齐，别自造人设）。
+ * 空召回返回空串（调用方据此决定不注入）。
+ */
+export declare function buildKnowledgeBlock(relevant: RecalledLike[], lang?: 'en' | 'zh'): string;
+/** 从 SDK prompt 数组里取最后一条 user 消息里的纯文本（多个 text part 用换行拼）。找不到返回 null。 */
+export declare function getLastUserMessageText(prompt: unknown): string | null;
+/**
+ * 把一段说明追加进最后一条 user 消息（作为额外的 text part 塞在原文本之前——
+ *   让"你已了解的情况"排在用户这轮问题之前，符合 knowledgeBlock 进 system 的语序意图）。
+ * 返回一个【新的】prompt 数组（不原地改，避免污染调用方持有的对象）。找不到 user 消息则原样返回。
+ */
+export declare function addToLastUserMessage(prompt: unknown, block: string): unknown;
+/**
+ * 造一个 MemoWeft 读适配器 middleware。
+ * @param core 只需持有 `recall` 方法的 Core（或任意实现了 recall 的对象）。
+ * @param opts subjectId / lang / onRecall。
+ */
+export declare function createMemoWeftMiddleware(core: RecallOnly, opts?: MemoWeftMiddlewareOptions): LanguageModelMiddleware;
+export {};
+//# sourceMappingURL=recallMiddleware.d.ts.map

package/dist/recallMiddleware.js

@@ -0,0 +1,94 @@
+/**
+ * 拼注入块：照搬 Core `src/pipeline/action.ts` 的 knowledgeBlock 中性措辞（逐字对齐，别自造人设）。
+ * 空召回返回空串（调用方据此决定不注入）。
+ */
+export function buildKnowledgeBlock(relevant, lang = 'en') {
+    if (relevant.length === 0)
+        return '';
+    const lines = relevant
+        .map((c) => lang === 'zh'
+        ? `- ${c.content}（把握度 ${c.confidence}/1000，${c.credStatus}）`
+        : `- ${c.content} (confidence ${c.confidence}/1000, ${c.credStatus})`)
+        .join('\n');
+    const head = lang === 'zh'
+        ? '\n\n你已了解关于这个用户的一些情况（带把握度；低置信的只是假设，别当定论、别生硬复述）：\n'
+        : '\n\nHere is some of what you already understand about this user (with confidence; low-confidence items are only guesses—do not treat them as established facts, and do not recite them stiffly):\n';
+    return head + lines;
+}
+// ── last-user-message helper（非 SDK 自带，按 params.prompt 真实结构自研）──
+//
+// `ai` 的 LanguageModelV4Prompt = Array<LanguageModelV4Message>；
+//   user 消息 = { role:'user', content: Array<TextPart|FilePart> }，TextPart = { type:'text', text:string }。
+// 这里只碰 text part、不动 file/image part（多模态原样保留）。
+/** 从 SDK prompt 数组里取最后一条 user 消息里的纯文本（多个 text part 用换行拼）。找不到返回 null。 */
+export function getLastUserMessageText(prompt) {
+    if (!Array.isArray(prompt))
+        return null;
+    for (let i = prompt.length - 1; i >= 0; i--) {
+        const msg = prompt[i];
+        if (!msg || msg.role !== 'user')
+            continue;
+        if (!Array.isArray(msg.content))
+            return null;
+        const texts = msg.content
+            .filter((p) => {
+            const part = p;
+            return part?.type === 'text' && typeof part.text === 'string';
+        })
+            .map((p) => p.text);
+        return texts.length > 0 ? texts.join('\n') : null;
+    }
+    return null;
+}
+/**
+ * 把一段说明追加进最后一条 user 消息（作为额外的 text part 塞在原文本之前——
+ *   让"你已了解的情况"排在用户这轮问题之前，符合 knowledgeBlock 进 system 的语序意图）。
+ * 返回一个【新的】prompt 数组（不原地改，避免污染调用方持有的对象）。找不到 user 消息则原样返回。
+ */
+export function addToLastUserMessage(prompt, block) {
+    if (!Array.isArray(prompt) || block === '')
+        return prompt;
+    const next = prompt.slice();
+    for (let i = next.length - 1; i >= 0; i--) {
+        const msg = next[i];
+        if (!msg || msg.role !== 'user' || !Array.isArray(msg.content))
+            continue;
+        const injected = { type: 'text', text: block.replace(/^\n+/, '') + '\n\n' };
+        next[i] = { ...msg, content: [injected, ...msg.content] };
+        return next;
+    }
+    return prompt;
+}
+/**
+ * 造一个 MemoWeft 读适配器 middleware。
+ * @param core 只需持有 `recall` 方法的 Core（或任意实现了 recall 的对象）。
+ * @param opts subjectId / lang / onRecall。
+ */
+export function createMemoWeftMiddleware(core, opts = {}) {
+    const { subjectId, lang = 'en', onRecall } = opts;
+    return {
+        async transformParams({ params }) {
+            const query = getLastUserMessageText(params.prompt);
+            // 没有可召回的 query（无 user 文本 / 纯多模态）→ 原样透传，不注入。
+            if (!query)
+                return params;
+            let recalled;
+            try {
+                recalled = await core.recall(subjectId ? { query, subjectId } : { query });
+            }
+            catch {
+                // 召回失败不挡回话（呼应 Core "召回失败不阻塞对话"纪律）：静默降级为不注入。
+                return params;
+            }
+            onRecall?.(recalled);
+            const block = buildKnowledgeBlock(recalled, lang);
+            if (block === '')
+                return params;
+            // addToLastUserMessage 收/返宽松 unknown（对外也当独立工具用）；这里回填 params 时
+            //   收窄回 params.prompt 的真实类型——注入只改了 text part、结构与原 prompt 一致，cast 安全。
+            const prompt = addToLastUserMessage(params.prompt, block);
+            return { ...params, prompt };
+        },
+    };
+}
+//# sourceMappingURL=recallMiddleware.js.map

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@memoweft/adapter-ai-sdk",
+  "version": "0.1.0",
+  "description": "Vercel AI SDK adapter for MemoWeft — inject long-term memory via middleware (recall) and persist the user's turn on finish (write).",
+  "keywords": ["vercel-ai-sdk", "ai-sdk", "memoweft", "memory", "llm", "middleware"],
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
+  },
+  "files": ["dist/**/*.js", "dist/**/*.d.ts", "README.md", "README.zh-CN.md"],
+  "engines": { "node": ">=22" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/memoweft/memoweft.git",
+    "directory": "packages/adapter-ai-sdk"
+  },
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "node --test \"tests/**/*.test.ts\"",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "peerDependencies": {
+    "ai": "^7",
+    "memoweft": "^0.5.0"
+  },
+  "devDependencies": {
+    "ai": "^7.0.15",
+    "memoweft": "*"
+  }
+}