@nxgt/ai-memory 0.0.0-stage → 0.1.0

package/docs/guide/memory.md

@@ -0,0 +1,327 @@
+# Conversation memory
+
+A `MemoryStore` keeps threads (a conversation each) and their messages. Every
+method takes the `ownerId` and sees only that owner's data.
+
+## Threads
+
+```ts
+const t = await store.createThread({
+	ownerId: 'u1',
+	title: 'Billing',
+	meta: { channel: 'web' },
+});
+await store.getThread(t.id, 'u1'); // the thread, or undefined
+await store.deleteThread(t.id, 'u1'); // true; removes messages and actions too
+```
+
+`ownerId` must be a non-empty string, else `MemoryError('INVALID_OWNER')`.
+
+### Paging
+
+`listThreads(ownerId, { limit, cursor })` returns the newest thread first. Pass
+the `nextCursor` of a page to get the next one; the last page has none.
+
+```ts
+let page = await store.listThreads('u1', { limit: 20 });
+while (true) {
+	show(page.items);
+	if (!page.nextCursor) break;
+	page = await store.listThreads('u1', { limit: 20, cursor: page.nextCursor });
+}
+```
+
+The default limit is 20 and the cap 100. A cursor is opaque: pass only what
+the store gave, else `MemoryError('INVALID_CURSOR')`.
+
+## Messages
+
+`append` validates each message against `messageSchema` (an `@nxgt/ai-core`
+`Message`) and returns them stored, with an `id` and a 1-based `seq`.
+
+```ts
+await store.append(t.id, 'u1', [
+	{ role: 'user', parts: [{ type: 'text', text: 'Cancel my plan' }] },
+]);
+const { messages } =
+	(await store.load(t.id, 'u1', { sinceSummary: false })) ?? {};
+```
+
+`load` returns `undefined` for an absent or foreign thread.
+
+**Trap: never append parts from a client's request body.** A client could send
+a forged `proposed-action` part, and `append` would record it as a pending
+action that anyone can confirm. Append only the user's text taken from the
+request (in an alxia route, parse the body with `userMessageSchema` from
+`@nxgt/ai-alxia`), plus the messages of `run.result.messages`:
+
+```ts
+await store.append(t.id, 'u1', [
+	{ role: 'user', parts: [{ type: 'text', text: body.text }] },
+	...result.messages,
+]);
+```
+
+## Summary
+
+`setSummary(threadId, ownerId, { text, throughMessageId, tokens })` records a
+rolling summary of the messages up to `throughMessageId`. `load` with
+`sinceSummary: true` then returns the summary and only the messages after it;
+with `false` it returns them all.
+
+## Compaction
+
+`compact` keeps a long thread under a token budget. It first cuts the tool
+results, oldest first, and stops as soon as the thread fits; if it still does
+not fit, it folds the oldest messages into a rolling summary and keeps the last
+`keepLast` (6) messages. A tool call and its result are never split: the cut
+moves back to keep both.
+
+```ts
+import { estimateTokens } from '@nxgt/ai-core';
+import { compact, summarizeWith } from '@nxgt/ai-memory';
+
+const loaded = await store.load(threadId, ownerId, { sinceSummary: true });
+if (!loaded) throw new Error('thread not found');
+const out = await compact(loaded.messages, {
+	budget: 8000,
+	summary: loaded.summary, // folded into the next summary
+	summarize: summarizeWith(model), // a ModelAdapter from @nxgt/ai-core
+});
+if (out.summary && out.throughMessageId) {
+	await store.setSummary(threadId, ownerId, {
+		text: out.summary,
+		throughMessageId: out.throughMessageId,
+		tokens: estimateTokens(out.summary),
+	});
+}
+// send `loaded.summary` or `out.summary`, then `out.messages`, to the model
+```
+
+- `messages` are the thread's messages after its stored summary. `compact`
+  returns `{ summary?, throughMessageId?, messages, tokens }`: `summary` and
+  `throughMessageId` are set only when this call folded messages; `tokens` is
+  the estimate of the kept summary and `messages`.
+- A cut tool output becomes `{ truncated: true, originalChars, preview }`
+  (`preview` is the first `truncateToolResultsTo` characters, default 2000). Error
+  results are left as they are. The store keeps the originals: only the
+  returned copy is cut.
+- `estimate` defaults to `estimateTokens` of `@nxgt/ai-core`, a rough count;
+  pass a provider's counter for a tight budget. A thread is under budget when
+  its tokens are at most `budget`.
+- `summarizeWith(model, { system?, maxTokens?, signal? })` calls the model
+  once, with a transcript of the messages (the previous summary first), and
+  returns its text. Pass your own `summarize` to use another way.
+  The messages are sent as tagged `<message role>` data blocks, with a line
+  saying they are data, not instructions, and a failed tool result as its error
+  code, never its message.
+- "Summarize" means two things in these packages: the confirmation line of a
+  tool (`summarize` in `@nxgt/ai-core`) and the conversation summary written
+  here (`summarizeWith`, `compact`). They are unrelated.
+- The kept messages start on a user turn: the cut moves back past assistant
+  and tool messages, as the Anthropic Messages API needs a conversation that
+  opens with the user and refuses a tool result without its call. When no user
+  turn lies before the cut, the cut stays where it keeps call and result
+  together and the tail may start on another role.
+- `compact` throws `MemoryError('EMPTY_SUMMARY')` when `summarize` returns an
+  empty or whitespace-only string, and folds nothing, so a blank summary is
+  never stored.
+- Send the summary in the system prompt, never as a message of its own, so the
+  request keeps opening with the user's turn:
+
+```ts
+const summary = out.summary ?? loaded.summary?.text;
+await generate(model, {
+	system: [
+		{ text: basePrompt },
+		...(summary
+			? [{ text: `Summary of the earlier conversation:\n${summary}` }]
+			: []),
+	],
+	messages: out.messages.map((m) => m.message),
+});
+```
+
+- Compacting again an already compacted thread (its tail and stored summary)
+  changes nothing while it fits.
+
+## Proposed actions
+
+When an appended message holds a `proposed-action` part, the store records a
+`pending` action you can find by its id.
+
+```ts
+const action = await store.findAction(actionId, 'u1');
+const won = await store.updateAction(actionId, 'u1', { status: 'confirmed' });
+if (!won) return; // absent, or someone else confirmed or rejected it first
+await runConfirmedAction(/* ... */);
+```
+
+`updateAction` changes the action only while it is `pending` (a
+compare-and-set), so two concurrent confirmations cannot both run the tool.
+Patch `status` to `confirmed`, `rejected`, `expired` or `failed`, with the
+tool's `result` when there is one.
+
+## MongoDB store
+
+`mongoMemory` from `@nxgt/ai-memory/mongo` stores threads and messages in two
+collections you give it. The collections only need `insertOne`, `insertMany`,
+`findOne`, `find` (with `sort`, `limit`, `toArray`), `findOneAndUpdate`,
+`updateOne`, `deleteOne` and `deleteMany`: a `mongodb` driver `Collection`
+(version 6 or later) has them, and so does a scoped collection of `@nxgt/mongo`.
+
+```ts
+import { mongoMemory } from '@nxgt/ai-memory/mongo';
+
+const store = mongoMemory({
+	threads: db.collection('threads'),
+	messages: db.collection('messages'),
+});
+```
+
+### Indexes
+
+Create them once; the store does not.
+
+```ts
+import { messageIndexes, threadIndexes } from '@nxgt/ai-memory/mongo';
+
+for (const { key, ...options } of threadIndexes) {
+	await db.collection('threads').createIndex(key, options);
+}
+for (const { key, ...options } of messageIndexes) {
+	await db.collection('messages').createIndex(key, options);
+}
+```
+
+The messages' unique index on `ownerId, threadId, seq` is what keeps two
+appends from sharing a position.
+
+### Stored fields
+
+`threadFields` and `messageFields` list the fields of each document, for
+projections, migrations or a schema validator. `_id` is the thread or message
+id (a time-ordered UUID, which is what pages `listThreads` newest first).
+Every message document also carries its `ownerId`, and a message that proposes
+actions carries an `actions` array with their current status.
+
+### Expiry
+
+`expireAfterSeconds` makes the store write an `expiresAt` date, and a thread
+expires as one unit: each write (`append`, `setSummary`) moves the thread and
+all its messages to that long after the write, so a load never starts with a
+tool result whose call is gone. Create `expiresAtIndex` on both collections so MongoDB deletes them.
+
+```ts
+import { expiresAtIndex } from '@nxgt/ai-memory/mongo';
+
+const threads = db.collection('threads');
+const messages = db.collection('messages');
+
+await threads.createIndex(expiresAtIndex.key, { expireAfterSeconds: 0 });
+await messages.createIndex(expiresAtIndex.key, { expireAfterSeconds: 0 });
+const store = mongoMemory({
+	threads,
+	messages,
+	expireAfterSeconds: 30 * 86400,
+});
+```
+
+MongoDB removes expired documents about once a minute, so they can be read for
+a little after their time. A thread that is not written to for that long is
+removed whole.
+
+### Concurrency
+
+`append` reserves its `seq` range with one atomic increment on the thread, so
+concurrent appends never collide. `updateAction` is one `findOneAndUpdate`
+that matches only an action still `pending`; of two concurrent confirmations
+one gets the action and the other `undefined`. A failed insert in `append`
+leaves a gap in `seq`; `load` still orders by it.
+
+#### Deleting
+
+`deleteThread` deletes the messages, then the thread, then the messages again.
+It returns `false` for a foreign or absent owner. A crash after the first sweep
+but before the thread delete leaves an empty thread, which a retry removes. A
+crash after the thread delete can leave messages nobody can reach: a retry
+returns `false`, and the TTL (`expiresAt`) removes them when expiry is on. An
+`append` racing a delete checks the thread after its insert and removes its own
+batch, throwing `THREAD_NOT_FOUND`; for a moment a pending action of that batch
+can still be found by `findAction` or `updateAction`.
+
+## Redis store
+
+`redisMemory` from `@nxgt/ai-memory/redis` stores threads and messages in Redis
+keys. Give it the client of `@nxgt/redis`: the `client` of a `connectRedis`
+connection, or of an instance of `openRedis`. The store calls only
+`client.send(command, args)`, so it opens no connection of its own and closes
+nothing. It needs Redis 6.2 or later, and a single node or a replica set with
+Sentinel: Redis Cluster is not supported, because one script touches several
+keys.
+
+```ts
+import { connectRedis } from '@nxgt/redis';
+import { redisMemory } from '@nxgt/ai-memory/redis';
+
+const redis = await connectRedis(process.env.REDIS_URL ?? 'redis://localhost');
+const store = redisMemory({ client: redis.client });
+```
+
+### Keys
+
+Every key starts with `prefix` (default `ai-memory`); give each application
+that shares a Redis its own.
+
+| key                                  | type       | holds                                                                  |
+| ------------------------------------ | ---------- | ---------------------------------------------------------------------- |
+| `<prefix>:thread:<id>`               | hash       | the thread: `ownerId`, `title`, `meta`, `messageCount`, `summary`, ... |
+| `<prefix>:messages:<id>`             | sorted set | the messages of a thread, scored by `seq`                              |
+| `<prefix>:ids:<id>`                  | hash       | message id to `seq`, to find the summary's last message                |
+| `<prefix>:actions:<id>`              | set        | the keys of the actions the thread proposed                            |
+| `<prefix>:action:<n>:<ownerId>:<id>` | hash       | one proposed action: its `status`, its `body` and its `result`         |
+| `<prefix>:owner:<ownerId>`           | sorted set | the ids of the owner's threads, which pages `listThreads` newest first |
+
+`<n>` is the length of the owner id, so owner ids may hold `:` without their action keys meeting. Thread ids are time-ordered UUIDs. Reads need no index and no setup.
+
+### Expiry
+
+`expireAfterSeconds` sets an expiry on a thread's keys at every write that
+touches the thread (`append`, `setSummary`): the thread, its messages and its
+indexes go together, that long after the last write, and so do its
+proposed actions (`updateAction` slides them too). The whole thread expires
+from its last write, so a thread you keep writing to never expires and an idle one
+disappears whole. The `now` option is the clock the expiry is computed from.
+
+Redis deletes an expired key on access or in the background; a read after
+the time never sees it. The owner index is not given an expiry: `listThreads`
+skips the ids of expired threads and removes them as it goes.
+
+### Concurrency
+
+`append` is one Lua script: it checks the owner, reserves the `seq` range with
+an atomic increment, and writes the messages and the new actions, so
+concurrent appends never share a position and a reader never sees a gap.
+`updateAction` is one script that matches only an action still `pending`; of
+two concurrent confirmations one gets the action and the other `undefined`. An
+action id is recorded once per owner, as in the other stores.
+
+### Deleting
+
+`deleteThread` is one script: it removes the messages, the actions, the thread
+and its entry in the owner index together, and returns `false` for a foreign
+or absent owner. It never leaves unreachable keys; an `append` racing it
+finds the thread gone and throws `THREAD_NOT_FOUND`.
+
+## Write your own store
+
+Implement `MemoryStore` and run the contract suite against it:
+
+```ts
+import { memoryStoreContract } from '@nxgt/ai-memory/testing';
+
+memoryStoreContract(() => myStore());
+```
+
+Your `updateAction` must be atomic in the backing database (a conditional
+update on `status: 'pending'`), not a read then a write.

package/docs/roadmap.md

@@ -0,0 +1,31 @@
+# Roadmap
+
+A direction, not a commitment. See the [repository roadmap](https://github.com/softistx/nxgt-ai/blob/develop/docs/roadmap.md) for the whole SDK.
+
+## Now
+
+- **The memory port and the in-process store** — you get:
+  - `MemoryStore`, scoped by owner on every call: threads, messages, a rolling summary and proposed actions.
+  - `inProcessMemory()`, an in-process store.
+  - `memoryStoreContract` in `@nxgt/ai-memory/testing`, to test your own stores.
+- **Compaction** — you get:
+  - `compact`, which trims old tool results first, then keeps a rolling summary without splitting a tool call from its result.
+  - `summarizeWith(model)`, a summarizer over any model adapter.
+- **MongoDB store** — `@nxgt/ai-memory/mongo`: `mongoMemory` over two collections, with optional expiry; it passes the same contract.
+- **Redis store** — `@nxgt/ai-memory/redis`: `redisMemory` over the `@nxgt/redis` client, with optional expiry; it passes the same contract.
+
+## Next
+
+Nothing yet.
+
+## Later
+
+Nothing yet.
+
+## Not planned
+
+- **Searching across threads** — retrieval is out of scope for the SDK.
+
+## Shipped
+
+Nothing yet. Releases are listed in `CHANGELOG.md`.

package/docs/troubleshooting.md

@@ -0,0 +1,171 @@
+# Troubleshooting
+
+- [`MemoryError` THREAD_NOT_FOUND](#memoryerror-thread_not_found)
+- [`MemoryError` MESSAGE_NOT_FOUND](#memoryerror-message_not_found)
+- [`MemoryError` INVALID_CURSOR](#memoryerror-invalid_cursor)
+- [`MemoryError` INVALID_OWNER](#memoryerror-invalid_owner)
+- [`updateAction` returns undefined](#updateaction-returns-undefined)
+- [`compact` returns more tokens than `budget`](#compact-returns-more-tokens-than-budget)
+- [The summary forgets what the previous one said](#the-summary-forgets-what-the-previous-one-said)
+- [The model sees `{ truncated: true, preview }` as a tool result](#the-model-sees--truncated-true-preview--as-a-tool-result)
+- [`MemoryError` EMPTY_SUMMARY](#memoryerror-empty_summary)
+- [Mongo store: `E11000 duplicate key` on `ownerId_1_threadId_1_seq_1`](#mongo-store-e11000-duplicate-key-on-ownerid_1_threadid_1_seq_1)
+- [Mongo store: expired threads and messages are still read](#mongo-store-expired-threads-and-messages-are-still-read)
+- [Mongo store: `findOneAndUpdate` returns a result object, not a document](#mongo-store-findoneandupdate-returns-a-result-object-not-a-document)
+- [Mongo store: a failed `append` leaves a gap in `seq`](#mongo-store-a-failed-append-leaves-a-gap-in-seq)
+- [Redis store: `ERR syntax error` when listing threads](#redis-store-err-syntax-error-when-listing-threads)
+- [Redis store: `CROSSSLOT Keys in request don't hash to the same slot`](#redis-store-crossslot-keys-in-request-dont-hash-to-the-same-slot)
+- [Redis store: `WRONGTYPE Operation against a key holding the wrong kind of value`](#redis-store-wrongtype-operation-against-a-key-holding-the-wrong-kind-of-value)
+- [Redis store: `ERR_REDIS_CONNECTION_CLOSED`](#redis-store-err_redis_connection_closed)
+- [Redis store: a thread is gone before its time](#redis-store-a-thread-is-gone-before-its-time)
+
+## `MemoryError` THREAD_NOT_FOUND
+
+**When:** `append` or `setSummary` throws `Thread "…" was not found.`
+**Why:** the thread does not exist, was deleted, or belongs to another owner; the store does not tell these apart. A Mongo `append` racing a `deleteThread` also throws it and removes its own batch; this is expected, so do not retry.
+**Fix:** check the `ownerId` is the one that created the thread.
+
+```ts
+const thread = await store.getThread(id, ownerId);
+if (!thread) return notFound();
+```
+
+## `MemoryError` MESSAGE_NOT_FOUND
+
+**When:** `setSummary` throws `Message "…" is not in thread "…".`
+**Why:** `throughMessageId` is not the `id` of a message of that thread.
+**Fix:** use an `id` returned by `append` or `load`, not a `seq`.
+
+## `MemoryError` INVALID_CURSOR
+
+**When:** `listThreads` throws `"…" is not a cursor this store gave.`
+**Why:** the cursor was edited, or came from another store.
+**Fix:** pass back the `nextCursor` of the previous page unchanged.
+
+## `MemoryError` INVALID_OWNER
+
+**When:** any call throws `ownerId must be a non-empty string.`
+**Why:** the owner id is empty or missing, which would put every caller in one scope.
+**Fix:** resolve the signed-in user before calling the store.
+
+## `updateAction` returns undefined
+
+**When:** you confirm an action and get `undefined`.
+**Why:** the action is absent, belongs to another owner, or is no longer `pending` because a concurrent call or an earlier one already settled it.
+**Fix:** treat it as "not yours to run": do not execute the tool. Call `findAction` to see the status.
+
+## `compact` returns more tokens than `budget`
+
+It happens when the last `keepLast` messages (default 6), or a tool call and the
+result kept with it, are alone over the budget. `compact` never drops them. Lower
+`keepLast`, lower `truncateToolResultsTo`, or raise `budget`.
+
+```ts
+await compact(messages, {
+	budget,
+	keepLast: 2,
+	truncateToolResultsTo: 500,
+	summarize,
+});
+```
+
+## The summary forgets what the previous one said
+
+`compact` only knows the earlier summary when you give it. Pass the thread's
+stored one as `summary`.
+
+```ts
+const loaded = await store.load(id, ownerId, { sinceSummary: true });
+await compact(loaded.messages, { budget, summary: loaded.summary, summarize });
+```
+
+## The model sees `{ truncated: true, preview }` as a tool result
+
+That is a tool output cut by `compact` because it was longer than
+`truncateToolResultsTo` characters. The stored message is unchanged. Raise
+`truncateToolResultsTo`, or have the tool return less.
+
+## `MemoryError` EMPTY_SUMMARY
+
+`summarize` returned an empty or whitespace-only string, so `compact` folded
+nothing rather than let a blank summary replace the messages. Check the model's
+reply (a refusal or a `maxTokens` too low gives no text) and retry.
+
+```ts
+try {
+	await compact(messages, { budget, summarize });
+} catch (e) {
+	if (e instanceof MemoryError && e.code === 'EMPTY_SUMMARY') retryLater();
+	else throw e;
+}
+```
+
+## Mongo store: `E11000 duplicate key` on `ownerId_1_threadId_1_seq_1`
+
+**When:** `append` on the Mongo store fails with a duplicate key error.
+**Why:** two documents got the same `seq` in a thread: the messages were written by something other than the store, or `messageCount` of the thread was changed by hand.
+**Fix:** let only the store write these collections. Set the thread's `messageCount` to the highest `seq` of its messages again.
+
+```ts
+const last = await messages
+	.find({ threadId })
+	.sort({ seq: -1 })
+	.limit(1)
+	.toArray();
+await threads.updateOne(
+	{ _id: threadId },
+	{ $set: { messageCount: last[0]?.seq ?? 0 } },
+);
+```
+
+## Mongo store: expired threads and messages are still read
+
+**When:** a thread past its `expireAfterSeconds` still loads.
+**Why:** MongoDB's TTL monitor runs about once a minute, and it only runs for a collection that has `expiresAtIndex`.
+**Fix:** create `expiresAtIndex` on both collections (see the guide), and do not rely on the exact second of expiry.
+
+## Mongo store: `findOneAndUpdate` returns a result object, not a document
+
+**When:** `append` stores `NaN` as a `seq`, or `updateAction` returns `undefined` for a pending action that exists.
+**Why:** the collection resolves `findOneAndUpdate` to `{ value }`, as `mongodb` 5 and earlier do; the store needs the document itself.
+**Fix:** use `mongodb` 6 or later, or wrap the collection so `findOneAndUpdate` resolves to the document.
+
+## Mongo store: a failed `append` leaves a gap in `seq`
+
+**When:** an `append` threw while inserting, and the next messages start at a higher `seq` than the last stored one.
+**Why:** the store reserves the `seq` range on the thread before inserting, so a failed insert keeps `messageCount` advanced.
+**Fix:** none needed. A retry of the `append` works, but the gap stays. It is harmless: `load` orders by `seq`.
+
+## Redis store: `ERR syntax error` when listing threads
+
+**When:** `listThreads` fails with `ERR syntax error`.
+**Why:** it pages with `ZRANGE ... BYLEX REV`, which Redis 6.2 added; an older server does not know the form.
+**Fix:** use Redis 6.2 or later.
+
+## Redis store: `CROSSSLOT Keys in request don't hash to the same slot`
+
+**When:** `append`, `setSummary` or `deleteThread` fails on a Redis Cluster.
+**Why:** each script touches the keys of a thread, which a cluster spreads over several slots, and builds the action keys inside the script instead of declaring them in `KEYS`. Redis Cluster is not supported. The store supports a single node, or one primary with replicas behind Sentinel.
+**Fix:** point the client at a non-cluster Redis.
+
+## Redis store: `WRONGTYPE Operation against a key holding the wrong kind of value`
+
+**When:** any call fails with `WRONGTYPE`.
+**Why:** another application, or a cache, writes keys that start with the same `prefix`.
+**Fix:** give the store a prefix of its own, and clear the keys that collide.
+
+```ts
+const store = redisMemory({ client, prefix: 'support-chat' });
+```
+
+## Redis store: `ERR_REDIS_CONNECTION_CLOSED`
+
+**When:** a call rejects with `ERR_REDIS_CONNECTION_CLOSED`.
+**Why:** the client was closed, by `connection.close()` or `closeRedis()` of `@nxgt/redis`, while the store still used it. The store never opens or closes a connection.
+**Fix:** close the connection after the last call, at shutdown, and build the store from a connection that is still open.
+
+## Redis store: a thread is gone before its time
+
+**When:** `getThread` returns `undefined` or `append` throws `THREAD_NOT_FOUND` for a thread you created.
+**Why:** `expireAfterSeconds` counts from the thread's last write, and the clock the expiry uses is `now`: a `now` that returns a time in the past, or a short TTL, expires the thread at once.
+**Fix:** leave `now` out (it is `Date.now`) or give it epoch milliseconds, and set `expireAfterSeconds` longer than the idle time you accept.

package/package.json

@@ -1,6 +1,86 @@
 {
-  "name": "@nxgt/ai-memory",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@nxgt/ai-memory",
+	"version": "0.1.0",
+	"description": "Conversation memory for @nxgt/ai-core agents: an owner-scoped store port, an in-process store and a contract suite for your own stores",
+	"license": "MIT",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist",
+		"docs",
+		"README.md",
+		"package.json",
+		"LICENSE"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./mongo": {
+			"types": "./dist/mongo.d.ts",
+			"import": "./dist/mongo.js",
+			"default": "./dist/mongo.js"
+		},
+		"./redis": {
+			"types": "./dist/redis.d.ts",
+			"import": "./dist/redis.js",
+			"default": "./dist/redis.js"
+		},
+		"./testing": {
+			"types": "./dist/testing.d.ts",
+			"import": "./dist/testing.js",
+			"default": "./dist/testing.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"keywords": [
+		"ai",
+		"agent",
+		"llm",
+		"memory",
+		"conversation",
+		"bun",
+		"typescript"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/softistx/nxgt-ai.git",
+		"directory": "packages/ai-memory"
+	},
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org",
+		"access": "public"
+	},
+	"scripts": {
+		"build": "bun run ../../build.ts",
+		"test": "bun run build:redis && bun test --timeout 30000 src",
+		"typecheck": "tsc --noEmit",
+		"build:redis": "bun run test/redis.ts"
+	},
+	"nxgt": {
+		"entrypoints": [
+			"src/index.ts",
+			"src/mongo.ts",
+			"src/redis.ts",
+			"src/testing.ts"
+		]
+	},
+	"devDependencies": {
+		"@nxgt/ai-core": "^0.2.0",
+		"@nxgt/ai-testing": "^0.1.1",
+		"@nxgt/redis": "0.11.0",
+		"@types/bun": "^1.4.4",
+		"mongodb": "7.6.0",
+		"mongodb-memory-server-core": "11.2.0",
+		"redis-memory-server": "0.17.1",
+		"zod": "4.6.5"
+	},
+	"peerDependencies": {
+		"@nxgt/ai-core": "^0.2.0",
+		"typescript": "^6.0.3 || ^7.0.0",
+		"zod": ">=4.6.5 <5"
+	}
+}