@halo-sdk/memory 1.0.0

package/README.md

@@ -0,0 +1,26 @@
+# @halo-sdk/memory
+
+Cache-aware long-term memory for Halo AI SDK.
+
+Memory lives in a single cache segment placed before the volatile history tail, so it sits _inside_ the prefix cache and stays byte-stable — and the cache stays warm — until an explicit write. `remember()` is append-only (keeps the existing cached prefix valid); `forget()` / `clear()` rebuild the block as a deliberate, attributable cache miss.
+
+## Usage
+
+```ts
+import { Halo } from "@halo-sdk/core";
+import { MemoryStore } from "@halo-sdk/memory";
+
+const memory = new MemoryStore();
+memory.remember("The user prefers TypeScript.");
+memory.remember("The user is in UTC+8.");
+
+const agent = halo.agent({
+  /* ... */
+});
+agent.setContextSegments([memory.segment]);
+
+// later
+memory.recall(); // ["The user prefers TypeScript.", "The user is in UTC+8."]
+```
+
+Each entry is its own message, so appends extend the block without touching earlier entries — the prefix up to the previous tail stays cached.

package/dist/index.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MemoryStore: () => MemoryStore
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@halo-sdk/core");
+var MemoryStore = class {
+  segment;
+  _format;
+  _role;
+  _entries = [];
+  constructor(opts) {
+    this._format = opts?.format ?? ((e) => `- ${e.text}`);
+    this._role = opts?.role ?? "user";
+    this.segment = new import_core.StableContext({
+      id: opts?.segmentId ?? "memory",
+      kind: "memory",
+      messages: []
+    });
+    if (opts?.entries?.length) {
+      this._entries = [...opts.entries];
+      this._rebuild();
+    }
+  }
+  /** All current entries, in insertion order. */
+  get entries() {
+    return this._entries;
+  }
+  /**
+   * Append a fact. Append-only growth keeps the already-cached prefix valid —
+   * only the new tail of the memory block is uncached on the next turn.
+   */
+  remember(text, opts) {
+    const entry = {
+      id: opts?.id ?? `mem_${this._entries.length + 1}`,
+      text,
+      metadata: opts?.metadata
+    };
+    this._entries.push(entry);
+    this.segment.append([this._toMessage(entry)]);
+    return entry;
+  }
+  /** Remove an entry by id. Rebuilds the block (attributable cache miss). Returns true if removed. */
+  forget(id) {
+    const next = this._entries.filter((e) => e.id !== id);
+    if (next.length === this._entries.length) return false;
+    this._entries = next;
+    this._rebuild();
+    return true;
+  }
+  /** Remove all entries. Rebuilds the (now empty) block. */
+  clear() {
+    this._entries = [];
+    this.segment.setMessages([]);
+  }
+  /** Recall all remembered facts as plain strings. */
+  recall() {
+    return this._entries.map((e) => e.text);
+  }
+  _rebuild() {
+    this.segment.setMessages(this._entries.map((e) => this._toMessage(e)));
+  }
+  _toMessage(entry) {
+    return { role: this._role, content: this._format(entry), discardable: false };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryStore
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { StableContext, type CacheSegment, type ChatMessage } from \"@halo-sdk/core\";\n\n/** A single remembered fact with an id and optional metadata. */\nexport interface MemoryEntry {\n  id: string;\n  text: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface MemoryStoreOptions {\n  /** Segment id (for cache miss attribution). Default \"memory\". */\n  segmentId?: string;\n  /** Initial entries. */\n  entries?: MemoryEntry[];\n  /** Format an entry into a context message line. Default: `- text`. */\n  format?: (entry: MemoryEntry) => string;\n  /** Role used for the synthesized memory message. Default \"user\". */\n  role?: \"system\" | \"user\" | \"assistant\";\n}\n\n/**\n * Cache-aware long-term memory.\n *\n * Memory lives in a single {@link CacheSegment} placed before the volatile\n * history tail, so it sits *inside* the prefix cache. It stays byte-stable —\n * and the cache stays warm — until an explicit write. {@link remember} is\n * append-only (keeps the existing cached prefix valid); {@link forget} /\n * {@link clear} rebuild the block (a deliberate, attributable cache miss).\n *\n * Each entry is its own message so that appends extend the block without\n * touching earlier entries — the prefix up to the previous tail stays cached.\n */\nexport class MemoryStore {\n  readonly segment: StableContext;\n\n  private readonly _format: (entry: MemoryEntry) => string;\n  private readonly _role: \"system\" | \"user\" | \"assistant\";\n  private _entries: MemoryEntry[] = [];\n\n  constructor(opts?: MemoryStoreOptions) {\n    this._format = opts?.format ?? ((e) => `- ${e.text}`);\n    this._role = opts?.role ?? \"user\";\n    this.segment = new StableContext({\n      id: opts?.segmentId ?? \"memory\",\n      kind: \"memory\",\n      messages: [],\n    });\n    if (opts?.entries?.length) {\n      this._entries = [...opts.entries];\n      this._rebuild();\n    }\n  }\n\n  /** All current entries, in insertion order. */\n  get entries(): readonly MemoryEntry[] {\n    return this._entries;\n  }\n\n  /**\n   * Append a fact. Append-only growth keeps the already-cached prefix valid —\n   * only the new tail of the memory block is uncached on the next turn.\n   */\n  remember(text: string, opts?: { id?: string; metadata?: Record<string, unknown> }): MemoryEntry {\n    const entry: MemoryEntry = {\n      id: opts?.id ?? `mem_${this._entries.length + 1}`,\n      text,\n      metadata: opts?.metadata,\n    };\n    this._entries.push(entry);\n    this.segment.append([this._toMessage(entry)]);\n    return entry;\n  }\n\n  /** Remove an entry by id. Rebuilds the block (attributable cache miss). Returns true if removed. */\n  forget(id: string): boolean {\n    const next = this._entries.filter((e) => e.id !== id);\n    if (next.length === this._entries.length) return false;\n    this._entries = next;\n    this._rebuild();\n    return true;\n  }\n\n  /** Remove all entries. Rebuilds the (now empty) block. */\n  clear(): void {\n    this._entries = [];\n    this.segment.setMessages([]);\n  }\n\n  /** Recall all remembered facts as plain strings. */\n  recall(): string[] {\n    return this._entries.map((e) => e.text);\n  }\n\n  private _rebuild(): void {\n    this.segment.setMessages(this._entries.map((e) => this._toMessage(e)));\n  }\n\n  private _toMessage(entry: MemoryEntry): ChatMessage {\n    return { role: this._role, content: this._format(entry), discardable: false };\n  }\n}\n\nexport type { CacheSegment };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAmE;AAgC5D,IAAM,cAAN,MAAkB;AAAA,EACd;AAAA,EAEQ;AAAA,EACA;AAAA,EACT,WAA0B,CAAC;AAAA,EAEnC,YAAY,MAA2B;AACrC,SAAK,UAAU,MAAM,WAAW,CAAC,MAAM,KAAK,EAAE,IAAI;AAClD,SAAK,QAAQ,MAAM,QAAQ;AAC3B,SAAK,UAAU,IAAI,0BAAc;AAAA,MAC/B,IAAI,MAAM,aAAa;AAAA,MACvB,MAAM;AAAA,MACN,UAAU,CAAC;AAAA,IACb,CAAC;AACD,QAAI,MAAM,SAAS,QAAQ;AACzB,WAAK,WAAW,CAAC,GAAG,KAAK,OAAO;AAChC,WAAK,SAAS;AAAA,IAChB;AAAA,EACF;AAAA;AAAA,EAGA,IAAI,UAAkC;AACpC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAS,MAAc,MAAyE;AAC9F,UAAM,QAAqB;AAAA,MACzB,IAAI,MAAM,MAAM,OAAO,KAAK,SAAS,SAAS,CAAC;AAAA,MAC/C;AAAA,MACA,UAAU,MAAM;AAAA,IAClB;AACA,SAAK,SAAS,KAAK,KAAK;AACxB,SAAK,QAAQ,OAAO,CAAC,KAAK,WAAW,KAAK,CAAC,CAAC;AAC5C,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,IAAqB;AAC1B,UAAM,OAAO,KAAK,SAAS,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE;AACpD,QAAI,KAAK,WAAW,KAAK,SAAS,OAAQ,QAAO;AACjD,SAAK,WAAW;AAChB,SAAK,SAAS;AACd,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,WAAW,CAAC;AACjB,SAAK,QAAQ,YAAY,CAAC,CAAC;AAAA,EAC7B;AAAA;AAAA,EAGA,SAAmB;AACjB,WAAO,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,IAAI;AAAA,EACxC;AAAA,EAEQ,WAAiB;AACvB,SAAK,QAAQ,YAAY,KAAK,SAAS,IAAI,CAAC,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC;AAAA,EACvE;AAAA,EAEQ,WAAW,OAAiC;AAClD,WAAO,EAAE,MAAM,KAAK,OAAO,SAAS,KAAK,QAAQ,KAAK,GAAG,aAAa,MAAM;AAAA,EAC9E;AACF;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import { StableContext, type CacheSegment } from "@halo-sdk/core";
+/** A single remembered fact with an id and optional metadata. */
+export interface MemoryEntry {
+    id: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+export interface MemoryStoreOptions {
+    /** Segment id (for cache miss attribution). Default "memory". */
+    segmentId?: string;
+    /** Initial entries. */
+    entries?: MemoryEntry[];
+    /** Format an entry into a context message line. Default: `- text`. */
+    format?: (entry: MemoryEntry) => string;
+    /** Role used for the synthesized memory message. Default "user". */
+    role?: "system" | "user" | "assistant";
+}
+/**
+ * Cache-aware long-term memory.
+ *
+ * Memory lives in a single {@link CacheSegment} placed before the volatile
+ * history tail, so it sits *inside* the prefix cache. It stays byte-stable —
+ * and the cache stays warm — until an explicit write. {@link remember} is
+ * append-only (keeps the existing cached prefix valid); {@link forget} /
+ * {@link clear} rebuild the block (a deliberate, attributable cache miss).
+ *
+ * Each entry is its own message so that appends extend the block without
+ * touching earlier entries — the prefix up to the previous tail stays cached.
+ */
+export declare class MemoryStore {
+    readonly segment: StableContext;
+    private readonly _format;
+    private readonly _role;
+    private _entries;
+    constructor(opts?: MemoryStoreOptions);
+    /** All current entries, in insertion order. */
+    get entries(): readonly MemoryEntry[];
+    /**
+     * Append a fact. Append-only growth keeps the already-cached prefix valid —
+     * only the new tail of the memory block is uncached on the next turn.
+     */
+    remember(text: string, opts?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+    }): MemoryEntry;
+    /** Remove an entry by id. Rebuilds the block (attributable cache miss). Returns true if removed. */
+    forget(id: string): boolean;
+    /** Remove all entries. Rebuilds the (now empty) block. */
+    clear(): void;
+    /** Recall all remembered facts as plain strings. */
+    recall(): string[];
+    private _rebuild;
+    private _toMessage;
+}
+export type { CacheSegment };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,YAAY,EAAoB,MAAM,gBAAgB,CAAC;AAEpF,iEAAiE;AACjE,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,kBAAkB;IACjC,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uBAAuB;IACvB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,sEAAsE;IACtE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC;IACxC,oEAAoE;IACpE,IAAI,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;CACxC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAEhC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;IACxD,OAAO,CAAC,QAAQ,CAAqB;gBAEzB,IAAI,CAAC,EAAE,kBAAkB;IAcrC,+CAA+C;IAC/C,IAAI,OAAO,IAAI,SAAS,WAAW,EAAE,CAEpC;IAED;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,WAAW;IAW/F,oGAAoG;IACpG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAQ3B,0DAA0D;IAC1D,KAAK,IAAI,IAAI;IAKb,oDAAoD;IACpD,MAAM,IAAI,MAAM,EAAE;IAIlB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,UAAU;CAGnB;AAED,YAAY,EAAE,YAAY,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,66 @@
+// src/index.ts
+import { StableContext } from "@halo-sdk/core";
+var MemoryStore = class {
+  segment;
+  _format;
+  _role;
+  _entries = [];
+  constructor(opts) {
+    this._format = opts?.format ?? ((e) => `- ${e.text}`);
+    this._role = opts?.role ?? "user";
+    this.segment = new StableContext({
+      id: opts?.segmentId ?? "memory",
+      kind: "memory",
+      messages: []
+    });
+    if (opts?.entries?.length) {
+      this._entries = [...opts.entries];
+      this._rebuild();
+    }
+  }
+  /** All current entries, in insertion order. */
+  get entries() {
+    return this._entries;
+  }
+  /**
+   * Append a fact. Append-only growth keeps the already-cached prefix valid —
+   * only the new tail of the memory block is uncached on the next turn.
+   */
+  remember(text, opts) {
+    const entry = {
+      id: opts?.id ?? `mem_${this._entries.length + 1}`,
+      text,
+      metadata: opts?.metadata
+    };
+    this._entries.push(entry);
+    this.segment.append([this._toMessage(entry)]);
+    return entry;
+  }
+  /** Remove an entry by id. Rebuilds the block (attributable cache miss). Returns true if removed. */
+  forget(id) {
+    const next = this._entries.filter((e) => e.id !== id);
+    if (next.length === this._entries.length) return false;
+    this._entries = next;
+    this._rebuild();
+    return true;
+  }
+  /** Remove all entries. Rebuilds the (now empty) block. */
+  clear() {
+    this._entries = [];
+    this.segment.setMessages([]);
+  }
+  /** Recall all remembered facts as plain strings. */
+  recall() {
+    return this._entries.map((e) => e.text);
+  }
+  _rebuild() {
+    this.segment.setMessages(this._entries.map((e) => this._toMessage(e)));
+  }
+  _toMessage(entry) {
+    return { role: this._role, content: this._format(entry), discardable: false };
+  }
+};
+export {
+  MemoryStore
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { StableContext, type CacheSegment, type ChatMessage } from \"@halo-sdk/core\";\n\n/** A single remembered fact with an id and optional metadata. */\nexport interface MemoryEntry {\n  id: string;\n  text: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface MemoryStoreOptions {\n  /** Segment id (for cache miss attribution). Default \"memory\". */\n  segmentId?: string;\n  /** Initial entries. */\n  entries?: MemoryEntry[];\n  /** Format an entry into a context message line. Default: `- text`. */\n  format?: (entry: MemoryEntry) => string;\n  /** Role used for the synthesized memory message. Default \"user\". */\n  role?: \"system\" | \"user\" | \"assistant\";\n}\n\n/**\n * Cache-aware long-term memory.\n *\n * Memory lives in a single {@link CacheSegment} placed before the volatile\n * history tail, so it sits *inside* the prefix cache. It stays byte-stable —\n * and the cache stays warm — until an explicit write. {@link remember} is\n * append-only (keeps the existing cached prefix valid); {@link forget} /\n * {@link clear} rebuild the block (a deliberate, attributable cache miss).\n *\n * Each entry is its own message so that appends extend the block without\n * touching earlier entries — the prefix up to the previous tail stays cached.\n */\nexport class MemoryStore {\n  readonly segment: StableContext;\n\n  private readonly _format: (entry: MemoryEntry) => string;\n  private readonly _role: \"system\" | \"user\" | \"assistant\";\n  private _entries: MemoryEntry[] = [];\n\n  constructor(opts?: MemoryStoreOptions) {\n    this._format = opts?.format ?? ((e) => `- ${e.text}`);\n    this._role = opts?.role ?? \"user\";\n    this.segment = new StableContext({\n      id: opts?.segmentId ?? \"memory\",\n      kind: \"memory\",\n      messages: [],\n    });\n    if (opts?.entries?.length) {\n      this._entries = [...opts.entries];\n      this._rebuild();\n    }\n  }\n\n  /** All current entries, in insertion order. */\n  get entries(): readonly MemoryEntry[] {\n    return this._entries;\n  }\n\n  /**\n   * Append a fact. Append-only growth keeps the already-cached prefix valid —\n   * only the new tail of the memory block is uncached on the next turn.\n   */\n  remember(text: string, opts?: { id?: string; metadata?: Record<string, unknown> }): MemoryEntry {\n    const entry: MemoryEntry = {\n      id: opts?.id ?? `mem_${this._entries.length + 1}`,\n      text,\n      metadata: opts?.metadata,\n    };\n    this._entries.push(entry);\n    this.segment.append([this._toMessage(entry)]);\n    return entry;\n  }\n\n  /** Remove an entry by id. Rebuilds the block (attributable cache miss). Returns true if removed. */\n  forget(id: string): boolean {\n    const next = this._entries.filter((e) => e.id !== id);\n    if (next.length === this._entries.length) return false;\n    this._entries = next;\n    this._rebuild();\n    return true;\n  }\n\n  /** Remove all entries. Rebuilds the (now empty) block. */\n  clear(): void {\n    this._entries = [];\n    this.segment.setMessages([]);\n  }\n\n  /** Recall all remembered facts as plain strings. */\n  recall(): string[] {\n    return this._entries.map((e) => e.text);\n  }\n\n  private _rebuild(): void {\n    this.segment.setMessages(this._entries.map((e) => this._toMessage(e)));\n  }\n\n  private _toMessage(entry: MemoryEntry): ChatMessage {\n    return { role: this._role, content: this._format(entry), discardable: false };\n  }\n}\n\nexport type { CacheSegment };\n"],"mappings":";AAAA,SAAS,qBAA0D;AAgC5D,IAAM,cAAN,MAAkB;AAAA,EACd;AAAA,EAEQ;AAAA,EACA;AAAA,EACT,WAA0B,CAAC;AAAA,EAEnC,YAAY,MAA2B;AACrC,SAAK,UAAU,MAAM,WAAW,CAAC,MAAM,KAAK,EAAE,IAAI;AAClD,SAAK,QAAQ,MAAM,QAAQ;AAC3B,SAAK,UAAU,IAAI,cAAc;AAAA,MAC/B,IAAI,MAAM,aAAa;AAAA,MACvB,MAAM;AAAA,MACN,UAAU,CAAC;AAAA,IACb,CAAC;AACD,QAAI,MAAM,SAAS,QAAQ;AACzB,WAAK,WAAW,CAAC,GAAG,KAAK,OAAO;AAChC,WAAK,SAAS;AAAA,IAChB;AAAA,EACF;AAAA;AAAA,EAGA,IAAI,UAAkC;AACpC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAS,MAAc,MAAyE;AAC9F,UAAM,QAAqB;AAAA,MACzB,IAAI,MAAM,MAAM,OAAO,KAAK,SAAS,SAAS,CAAC;AAAA,MAC/C;AAAA,MACA,UAAU,MAAM;AAAA,IAClB;AACA,SAAK,SAAS,KAAK,KAAK;AACxB,SAAK,QAAQ,OAAO,CAAC,KAAK,WAAW,KAAK,CAAC,CAAC;AAC5C,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,IAAqB;AAC1B,UAAM,OAAO,KAAK,SAAS,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE;AACpD,QAAI,KAAK,WAAW,KAAK,SAAS,OAAQ,QAAO;AACjD,SAAK,WAAW;AAChB,SAAK,SAAS;AACd,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,WAAW,CAAC;AACjB,SAAK,QAAQ,YAAY,CAAC,CAAC;AAAA,EAC7B;AAAA;AAAA,EAGA,SAAmB;AACjB,WAAO,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,IAAI;AAAA,EACxC;AAAA,EAEQ,WAAiB;AACvB,SAAK,QAAQ,YAAY,KAAK,SAAS,IAAI,CAAC,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC;AAAA,EACvE;AAAA,EAEQ,WAAW,OAAiC;AAClD,WAAO,EAAE,MAAM,KAAK,OAAO,SAAS,KAAK,QAAQ,KAAK,GAAG,aAAa,MAAM;AAAA,EAC9E;AACF;","names":[]}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@halo-sdk/memory",
+  "version": "1.0.0",
+  "description": "Cache-aware long-term memory for Halo AI SDK — an append-only memory segment that stays inside the prefix cache until an explicit write",
+  "keywords": [
+    "agent",
+    "ai",
+    "llm",
+    "memory",
+    "prefix-cache"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/halo-sdk/halo-ai",
+    "directory": "packages/memory"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.0",
+    "vitest": "^3.0.0",
+    "@halo-sdk/core": "1.1.0"
+  },
+  "peerDependencies": {
+    "@halo-sdk/core": ">=1.1.0"
+  },
+  "scripts": {
+    "build": "tsc --build --emitDeclarationOnly && tsup",
+    "dev": "tsup --watch",
+    "clean": "del-cli dist *.tsbuildinfo",
+    "publint": "publint",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}