@theokit/sdk-memory 0.1.0

package/dist/internal/active-memory-cache.d.ts

@@ -0,0 +1,49 @@
+import type { ActiveMemoryResult } from "./active-memory-types.js";
+/**
+ * TTL-bounded cache for `runActiveMemory` results. Keyed by
+ * `sha256(userText + queryMode)` so two identical sends within `cacheTtlMs`
+ * (default 15s, matching OpenClaw's `DEFAULT_CACHE_TTL_MS`) share a single
+ * search.
+ *
+ * Bounded size; oldest entries evicted first when capacity is exceeded.
+ *
+ * Iter 51 (Stage 3 source-move #8): hybrid copy from sdk-core's
+ * `internal/memory/active-memory-cache.ts`. sdk-core retains its copy
+ * for v1.x active-memory back-compat; sdk-memory ships the canonical
+ * copy that the future `active-memory.ts` move will target as a
+ * sibling. Depends only on `node:crypto` + `./active-memory-types.js`
+ * (moved iter 48), so no further dependency chain is required.
+ *
+ * @internal
+ */
+export interface ActiveMemoryCacheOptions {
+    ttlMs?: number;
+    capacity?: number;
+    now?: () => number;
+}
+export declare class ActiveMemoryCache {
+    private readonly opts;
+    private readonly map;
+    constructor(opts?: ActiveMemoryCacheOptions);
+    get(userText: string, queryMode: string, tenantCtx?: TenantContext): ActiveMemoryResult | undefined;
+    set(userText: string, queryMode: string, result: ActiveMemoryResult, tenantCtx?: TenantContext): void;
+    size(): number;
+    private now;
+}
+/**
+ * T4.9 — Tenant isolation context for cache key derivation.
+ * Pre-T4.9 the key was `sha256(queryMode + userText)` — two users
+ * sharing a process with the same query got each other's results.
+ * CRITICAL cross-tenant data leak (DR4 finding #9).
+ *
+ * Synced from sdk-core's `internal/memory/active-memory-cache.ts`
+ * per ADR 0002 Stage 4 routing byte-equivalence invariant (iter 112).
+ *
+ * @internal
+ */
+export interface TenantContext {
+    namespace?: string;
+    userId?: string;
+    scope?: string;
+}
+//# sourceMappingURL=active-memory-cache.d.ts.map

package/dist/internal/active-memory-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-memory-cache.d.ts","sourceRoot":"","sources":["../../src/internal/active-memory-cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,wBAAwB;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAUD,qBAAa,iBAAiB;IAGhB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAiC;gBAExB,IAAI,GAAE,wBAA6B;IAEhE,GAAG,CACD,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,aAAa,GACxB,kBAAkB,GAAG,SAAS;IAcjC,GAAG,CACD,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,kBAAkB,EAC1B,SAAS,CAAC,EAAE,aAAa,GACxB,IAAI;IAYP,IAAI,IAAI,MAAM;IAId,OAAO,CAAC,GAAG;CAGZ;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/internal/active-memory-types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Type-leaf — shared types between `active-memory.ts` and
+ * `active-memory-cache.ts`. Extracted to break LOW type-only cycle #10
+ * (audit `architecture-output/final_report.md`) per plan
+ * arch-review-fixes-2026-06-06 § Phase 4 / T4.1 (D438).
+ *
+ * Internal — `active-memory.ts` re-exports these for in-tree consumers
+ * that historically imported from there.
+ *
+ * **Iter 48 → iter 50 evolution:** the original `MemorySearchHit`
+ * import from `./index-manager-contract.js` was temporarily inlined
+ * as a duplicate interface because rollup-plugin-dts treeshook it out
+ * of sdk-memory's dist (no reachable consumer yet). Iter 50 moved
+ * `memory-index.ts` into sdk-memory and the barrel now publicly
+ * re-exports `MemorySearchHit` — creating the reachable consumer —
+ * so this file restores the canonical import and the inline mirror
+ * is gone. Single source of truth is back.
+ *
+ * @internal
+ */
+import type { MemorySearchHit } from "./index-manager-contract.js";
+export type ActiveMemoryQueryMode = "message" | "recent" | "full";
+export type ActiveMemoryStatus = "ok" | "timeout" | "skipped" | "no-recall" | "error";
+export interface ActiveMemoryResult {
+    summary: string | undefined;
+    durationMs: number;
+    status: ActiveMemoryStatus;
+    hits: ReadonlyArray<MemorySearchHit>;
+}
+//# sourceMappingURL=active-memory-types.d.ts.map

package/dist/internal/active-memory-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-memory-types.d.ts","sourceRoot":"","sources":["../../src/internal/active-memory-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;AAElE,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;AAEtF,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,IAAI,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;CACtC"}

package/dist/internal/active-memory.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Active Memory blocking recall (ADR D6 of memory-system-openclaw-parity).
+ *
+ * Runs BEFORE `agent.send()` assembles the system prompt. Issues a direct
+ * call to `IndexManager.search` with the user message (and optional recent
+ * turns per `queryMode`).
+ *
+ * Returns a `summary` string capped at `maxSummaryChars` (default 220 to
+ * match OpenClaw's `DEFAULT_MAX_SUMMARY_CHARS`) which the system-prompt
+ * pipeline prepends as a `<active-memory>` block (priority 5).
+ *
+ * Iter 75 (Stage 3 source-move #38, FINAL move): hybrid copy from
+ * sdk-core's `internal/memory/active-memory.ts`. sdk-core retains its
+ * copy as the v1.x runtime that `Memory` class delegates to;
+ * sdk-memory ships the canonical copy that future Stage 4 port-based
+ * composition will consume.
+ *
+ * **CLOSES the Stage 3 source-move stage in sdk-memory.** Every
+ * memory-related concept under sdk-core's internal/memory/ is now
+ * canonical in @theokit/sdk-memory (38 source files moved across
+ * iter 44-75; 2 inlined adapters added: adapter-http-error iter 73
+ * + adapter-catalog renamed iter 74).
+ *
+ * **Cross-package telemetry contract:** sdk-core's `internal/telemetry/`
+ * is not part of the public surface. sdk-memory inlines minimal
+ * structural mirrors of `OTelSpan` + `TelemetryHandle` here AND the
+ * 2 constant strings the file uses (`memory.recall` span name +
+ * `theokit_memory_recall_duration_ms` histogram name). The runtime
+ * still receives + emits the canonical types via consumer call sites
+ * — the structural mirrors only satisfy this file's local type
+ * checking. When sdk-core exposes telemetry types publicly, these
+ * mirrors MUST be replaced with the canonical imports.
+ *
+ * @internal
+ */
+import type { ActiveMemoryCache } from "./active-memory-cache.js";
+import type { ActiveMemoryQueryMode, ActiveMemoryResult, ActiveMemoryStatus } from "./active-memory-types.js";
+import type { CircuitBreaker } from "./circuit-breaker.js";
+import type { MemoryIndex } from "./memory-index.js";
+export type { ActiveMemoryQueryMode, ActiveMemoryResult, ActiveMemoryStatus };
+interface OTelSpan {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setAttributes(attrs: Record<string, string | number | boolean>): void;
+    addEvent(name: string, attrs?: Record<string, string | number | boolean>): void;
+    setStatus(status: {
+        code: number;
+        message?: string;
+    }): void;
+    recordException(exception: unknown): void;
+    end(): void;
+    spanContext(): {
+        traceId: string;
+        spanId: string;
+    };
+    isRecording(): boolean;
+}
+interface TelemetryHandle {
+    startSpan(name: string, attrs?: Record<string, string | number | boolean>): OTelSpan;
+    recordHistogram(name: string, value: number, attrs?: Record<string, string | number | boolean>): void;
+}
+export interface ActiveMemoryOptions {
+    /** Whether active recall is enabled. Default `false`. */
+    enabled?: boolean;
+    /** Query construction strategy. Default `"recent"`. */
+    queryMode?: ActiveMemoryQueryMode;
+    /** Hard timeout in ms. Default `15000`. */
+    timeoutMs?: number;
+    /** Max chars in the summary. Default `220`. */
+    maxSummaryChars?: number;
+    /** Number of recent user turns to include in `queryMode === "recent"`. Default `2`. */
+    recentUserTurns?: number;
+}
+export interface RunActiveMemoryArgs {
+    userText: string;
+    priorMessages: ReadonlyArray<{
+        role: "user" | "assistant";
+        text: string;
+    }>;
+    index: MemoryIndex | undefined;
+    options: ActiveMemoryOptions;
+    /** Per-agent circuit breaker (Phase 8). */
+    breaker?: CircuitBreaker;
+    /** Per-agent result cache (Phase 8). */
+    cache?: ActiveMemoryCache;
+    /** Workspace root for transcript persistence. */
+    cwd?: string;
+    /** When true, write transcript JSON under .theokit/memory/transcripts/active-memory/. */
+    persistTranscripts?: boolean;
+    /** Stable key the breaker + cache key by (default `default`). */
+    agentKey?: string;
+    /** Run id for transcript file naming. */
+    runId?: string;
+    /**
+     * T0.1 — optional telemetry handle. When provided AND telemetry is enabled,
+     * `memory.recall` span is emitted with `{ userId, namespace, scope, queryMode,
+     * hits, status }` attrs and `theokit_memory_recall_duration_ms` histogram is
+     * recorded with the same dimension keys.
+     */
+    telemetry?: TelemetryHandle;
+    /** User id surfaced as a memory.recall span attr for cross-tenant tracing. */
+    userId?: string;
+    /** Memory namespace (e.g. `default`, `<orgId>`) for span/histogram dimensions. */
+    namespace?: string;
+    /** Memory scope (`session` / `user` / `global`) for span/histogram dimensions. */
+    scope?: string;
+}
+export declare function runActiveMemory(args: RunActiveMemoryArgs): Promise<ActiveMemoryResult>;
+//# sourceMappingURL=active-memory.d.ts.map

package/dist/internal/active-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-memory.d.ts","sourceRoot":"","sources":["../../src/internal/active-memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,OAAO,KAAK,EACV,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,YAAY,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAC;AAU9E,UAAU,QAAQ;IAChB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAClE,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC;IAChF,SAAS,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC5D,eAAe,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1C,GAAG,IAAI,IAAI,CAAC;IACZ,WAAW,IAAI;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,WAAW,IAAI,OAAO,CAAC;CACxB;AAED,UAAU,eAAe;IACvB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,QAAQ,CAAC;IACrF,eAAe,CACb,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAChD,IAAI,CAAC;CACT;AAED,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uDAAuD;IACvD,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAClC,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uFAAuF;IACvF,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3E,KAAK,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,mBAAmB,CAAC;IAC7B,2CAA2C;IAC3C,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,wCAAwC;IACxC,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,iDAAiD;IACjD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yFAAyF;IACzF,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,8EAA8E;IAC9E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kFAAkF;IAClF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AASD,wBAAsB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA+C5F"}

package/dist/internal/adapter-catalog.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Memory embedding adapter catalog, indexed by provider id.
+ *
+ * Only adapters with full, tested implementations are exposed. The
+ * `openrouter` provider proxies through OpenRouter to whichever embedding
+ * model the caller selects via `model` (e.g.
+ * `"openai/text-embedding-3-small"`, `"mistralai/mistral-embed"`).
+ *
+ * Locked by ADR D11: `openai`, `mistral`, `openrouter`, `voyage`, `deepinfra`
+ * ship in v1.0. ADR D183: `ollama` added — first `transport: "local"`
+ * adapter, enables 100%-local RAG (no remote API key needed).
+ * `lmstudio`, `google`, `bedrock` are deferred to v1.1.
+ *
+ * Iter 74 (Stage 3 source-move #37): hybrid copy from sdk-core's
+ * `internal/memory/adapters/catalog.ts`. Filename renamed to
+ * `adapter-catalog.ts` in sdk-memory to disambiguate from the broader
+ * "catalog" notion at the package barrel level.
+ *
+ * **CLOSES the embedding-adapter cluster in sdk-memory.** All 7
+ * provider adapters + the shared OpenAI-compatible runtime + the
+ * inlined HTTP error mapper are now canonical:
+ * - iter 45: embedding-adapter (types)
+ * - iter 46: embedding-cache (LRU)
+ * - iter 73: openai-compatible (shared factory) + adapter-http-error
+ *   (inlined mapper)
+ * - iter 74: openai-embedding + mistral-embedding + deepinfra-embedding
+ *   + voyage-embedding + openrouter-embedding + ollama-embedding +
+ *   adapter-catalog (THIS)
+ *
+ * @internal
+ */
+export declare const MEMORY_EMBEDDING_ADAPTERS: {
+    openai: {
+        id: string;
+        defaultModel: string;
+        transport: "remote";
+        authProviderId: string;
+        autoSelectPriority: number;
+        create: (options: Parameters<typeof import("./openai-compatible.js").createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+    };
+    mistral: {
+        id: string;
+        defaultModel: string;
+        transport: "remote";
+        authProviderId: string;
+        autoSelectPriority: number;
+        create: (options: Parameters<typeof import("./openai-compatible.js").createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+    };
+    openrouter: {
+        id: string;
+        defaultModel: string;
+        transport: "remote";
+        authProviderId: string;
+        autoSelectPriority: number;
+        create: (options: Parameters<typeof import("./openai-compatible.js").createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+    };
+    voyage: {
+        id: string;
+        defaultModel: string;
+        transport: "remote";
+        authProviderId: string;
+        autoSelectPriority: number;
+        create: (options: Parameters<typeof import("./openai-compatible.js").createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+    };
+    deepinfra: {
+        id: string;
+        defaultModel: string;
+        transport: "remote";
+        authProviderId: string;
+        autoSelectPriority: number;
+        create: (options: Parameters<typeof import("./openai-compatible.js").createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+    };
+    ollama: {
+        id: string;
+        defaultModel: string;
+        transport: "local";
+        authProviderId: string;
+        autoSelectPriority: number;
+        create: (options: Parameters<typeof import("./openai-compatible.js").createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+    };
+};
+//# sourceMappingURL=adapter-catalog.d.ts.map

package/dist/internal/adapter-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-catalog.d.ts","sourceRoot":"","sources":["../../src/internal/adapter-catalog.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOrC,CAAC"}

package/dist/internal/adapter-http-error.d.ts

@@ -0,0 +1,63 @@
+/**
+ * OpenAI-compatible HTTP error mapper (ADR D67) — sdk-memory inlined copy.
+ *
+ * Translates OpenAI-shaped API error responses (covers OpenAI, OpenRouter,
+ * DeepSeek, Together, Mistral, Voyage, DeepInfra, etc.) into typed
+ * `TheokitAgentError` subclasses with full `ErrorMetadata`.
+ *
+ * Body inspection: looks at `body.error.code` / `body.error.type` to detect
+ * `context_too_long`, `content_filtered`, `model_unavailable` semantics.
+ * Falls back to status-based mapping when body doesn't expose `.error`
+ * (e.g., HTML server error page, DeepInfra's `{message: "..."}` shape).
+ *
+ * Never throws — caller is already in an error path.
+ *
+ * Iter 73 (Stage 3 source-move #30): inlined adaptation of sdk-core's
+ * `internal/errors/mappers/openai-compatible.ts` + `shared.ts`. sdk-core's
+ * mapper is internal — not part of the public errors surface — so sdk-memory
+ * carries its own minimal copy here. Behavior MUST stay byte-equivalent
+ * with sdk-core's so consumers consuming hits via either package surface
+ * see identical error shape.
+ *
+ * The 4 helpers (`parseRetryAfter`, `truncateRaw`, `buildErrorMetadata`,
+ * `mapOpenAICompatibleError`) are intentionally co-located in this single
+ * file so all 8 embedding adapter moves (catalog + 7 providers) share one
+ * import target.
+ *
+ * @internal
+ */
+import { type ErrorCode, type ErrorMetadata, type TheokitAgentError } from "@theokit/sdk/errors";
+/**
+ * Parse `retry-after` header in numeric-seconds form. HTTP-date form
+ * (RFC 7231) returns `undefined` to avoid NaN propagation downstream.
+ */
+export declare function parseRetryAfter(headers: Headers | undefined): number | undefined;
+/**
+ * Truncate raw response body to ~2KB and redact known credential
+ * patterns so it can ride inside `ErrorMetadata.raw` without
+ * ballooning logs OR leaking tokens. Returns `undefined` for
+ * null/undefined input.
+ */
+export declare function truncateRaw(body: unknown): unknown;
+/**
+ * Build an `ErrorMetadata` object with all optional fields included
+ * conditionally (no `undefined` keys in the output).
+ */
+export declare function buildErrorMetadata(args: {
+    provider: string;
+    endpoint: string;
+    code: ErrorCode;
+    status: number;
+    headers: Headers | undefined;
+    body: unknown;
+}): ErrorMetadata;
+interface MapOpenAiErrorArgs {
+    providerId: string;
+    status: number;
+    body: unknown;
+    headers: Headers | undefined;
+    endpoint: string;
+}
+export declare function mapOpenAICompatibleError(args: MapOpenAiErrorArgs): TheokitAgentError;
+export {};
+//# sourceMappingURL=adapter-http-error.d.ts.map

package/dist/internal/adapter-http-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-http-error.d.ts","sourceRoot":"","sources":["../../src/internal/adapter-http-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,aAAa,EAGlB,KAAK,iBAAiB,EAEvB,MAAM,qBAAqB,CAAC;AAM7B;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAOhF;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAKlD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,aAAa,CAWhB;AAED,UAAU,kBAAkB;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,kBAAkB,GAAG,iBAAiB,CA6BpF"}

package/dist/internal/batch-encoder.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Batch encoding pipeline — embeds N texts in 1 API call with intra-batch dedup.
+ *
+ * Inspired by CrewAI's `encoding_flow.py` Stage 1-2: batch embed + cosine dedup.
+ * Per ADR D1: new module alongside sync(), not a replacement.
+ *
+ * @internal
+ */
+import type { EmbeddingRuntime } from "./embedding-adapter.js";
+interface RememberManyOptions {
+    scope?: string;
+    importance?: number;
+    dedupThreshold?: number;
+}
+interface RememberManyResult {
+    total: number;
+    deduped: number;
+    inserted: number;
+}
+interface KeptItem {
+    text: string;
+    vector: number[];
+}
+declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare function rememberMany(texts: string[], embedding: EmbeddingRuntime, opts?: RememberManyOptions): Promise<{
+    result: RememberManyResult;
+    items: KeptItem[];
+}>;
+export { cosineSimilarity };
+//# sourceMappingURL=batch-encoder.d.ts.map

package/dist/internal/batch-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-encoder.d.ts","sourceRoot":"","sources":["../../src/internal/batch-encoder.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,UAAU,mBAAmB;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,kBAAkB;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,QAAQ;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,iBAAS,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAY1D;AAmBD,wBAAsB,YAAY,CAChC,KAAK,EAAE,MAAM,EAAE,EACf,SAAS,EAAE,gBAAgB,EAC3B,IAAI,GAAE,mBAAwB,GAC7B,OAAO,CAAC;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,KAAK,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAC,CAiB5D;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/internal/chunk-markdown.d.ts

@@ -0,0 +1,66 @@
+/**
+ * **Iter 53 rollup-plugin-dts workaround** (mirrors iter 48
+ * MemorySearchHit pattern). The canonical sdk-core copy imports
+ * `MemoryChunk` from `../types.js`. In sdk-memory the same type lives
+ * in sibling `./memory-types.js` (moved iter 52) but rollup-dts
+ * treeshakes it out of the dist .d.ts because no PUBLIC type
+ * references it transitively yet — the public `chunkMarkdown(text):
+ * MemoryChunk[]` signature would be the first transitive reachable
+ * consumer, BUT rollup-dts processes files in an order that asks for
+ * the import resolution BEFORE chunk-markdown.ts itself becomes the
+ * reachable consumer. Result: "MemoryChunk is not exported by
+ * src/internal/memory-types.ts" build error.
+ *
+ * Fix: declare a byte-identical mirror of MemoryChunk inline. When a
+ * future move turns MemoryChunk into a publicly-reachable type
+ * through a different path (e.g. `index-db.ts` or `IndexManager`
+ * methods that return arrays of it), this mirror MUST be deleted +
+ * the canonical import restored to maintain single source of truth.
+ *
+ * @internal
+ */
+interface MemoryChunk {
+    /** 1-indexed starting line in the source file. */
+    startLine: number;
+    /** 1-indexed ending line (inclusive). */
+    endLine: number;
+    /** Slice of markdown source text. */
+    text: string;
+    /** sha256 of `text`; stable across runs for identical inputs. */
+    hash: string;
+    /** Optional nearest heading text (without the `#` markers). */
+    heading?: string;
+}
+/**
+ * Split a markdown document into semantically meaningful chunks (ADR D1 of
+ * memory-system-openclaw-parity).
+ *
+ * Algorithm:
+ *   1. Walk lines tracking the current heading (latest `^#+ ` line).
+ *   2. Split chunks at the next heading boundary AND on blank-line paragraph
+ *      boundaries.
+ *   3. If a single paragraph exceeds `maxChars`, split it at the nearest
+ *      whitespace ≤ maxChars (word-aligned per edge-case review EC-6) —
+ *      never mid-word.
+ *
+ * Mirrors OpenClaw's `chunkMarkdown` from
+ * `packages/memory-host-sdk/src/host/chunk-markdown.ts`.
+ *
+ * Iter 53 (Stage 3 source-move #10): hybrid copy from sdk-core's
+ * `internal/memory/storage/chunk-markdown.ts`. sdk-core retains its
+ * copy for v1.x back-compat; sdk-memory ships the canonical copy that
+ * future `storage/markdown-store`, `migration`, `index-db`, and
+ * `index-manager` moves will target as siblings. The `MemoryChunk`
+ * type comes from sibling `./memory-types.js` (moved iter 52).
+ *
+ * @internal
+ */
+export interface ChunkMarkdownOptions {
+    /** Maximum chars per chunk. Default 800. */
+    maxChars?: number;
+    /** Minimum chars per chunk (avoids splintering tiny lines). Default 80. */
+    minChars?: number;
+}
+export declare function chunkMarkdown(text: string, options?: ChunkMarkdownOptions): MemoryChunk[];
+export {};
+//# sourceMappingURL=chunk-markdown.d.ts.map

package/dist/internal/chunk-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-markdown.d.ts","sourceRoot":"","sources":["../../src/internal/chunk-markdown.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,UAAU,WAAW;IACnB,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,WAAW,oBAAoB;IACnC,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAWD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,WAAW,EAAE,CAY7F"}

package/dist/internal/circuit-breaker.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Consecutive-timeout circuit breaker for Active Memory recall.
+ *
+ * Mirrors OpenClaw's `circuitBreakerMaxTimeouts` + `circuitBreakerCooldownMs`
+ * config: after N consecutive timeouts the breaker trips and `shouldSkip`
+ * returns `true` until `cooldownMs` has elapsed. A successful recall resets
+ * the counter immediately.
+ *
+ * Per-key isolation so two agents in the same process don't share a counter.
+ *
+ * @internal
+ */
+export interface CircuitBreakerOptions {
+    maxTimeouts?: number;
+    cooldownMs?: number;
+    /** Injectable clock for tests. */
+    now?: () => number;
+}
+interface KeyState {
+    consecutiveTimeouts: number;
+    cooldownUntilMs: number;
+}
+export declare class CircuitBreaker {
+    private readonly opts;
+    private readonly states;
+    constructor(opts?: CircuitBreakerOptions);
+    /** @returns true when the breaker is open and the call should be skipped. */
+    shouldSkip(key: string): boolean;
+    recordSuccess(key: string): void;
+    recordTimeout(key: string): void;
+    /** @internal — tests inspect counter state. */
+    inspect(key: string): Readonly<KeyState>;
+    private now;
+}
+export {};
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/internal/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../src/internal/circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kCAAkC;IAClC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,UAAU,QAAQ;IAChB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;CACzB;AAKD,qBAAa,cAAc;IAGb,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;gBAEzB,IAAI,GAAE,qBAA0B;IAE7D,6EAA6E;IAC7E,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAWhC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAOhC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAShC,+CAA+C;IAC/C,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAIxC,OAAO,CAAC,GAAG;CAGZ"}

package/dist/internal/composite-scorer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Composite scoring — blends semantic, text, recency, and importance signals.
+ *
+ * Inspired by CrewAI's `unified_memory.py` composite scoring (lines 345-381).
+ * Default weights: semantic 0.5, text 0.2, recency 0.2, importance 0.1.
+ * Backward-compatible: old behavior reproduced with {recencyWeight:0, importanceWeight:0}.
+ *
+ * @internal
+ */
+export interface CompositeScoreConfig {
+    semanticWeight: number;
+    textWeight: number;
+    recencyWeight: number;
+    importanceWeight: number;
+    recencyHalfLifeMs: number;
+}
+export declare const DEFAULT_COMPOSITE_CONFIG: CompositeScoreConfig;
+export declare function compositeScore(vectorScore: number, textScore: number, createdAt: number | null, importance: number, config?: CompositeScoreConfig): number;
+//# sourceMappingURL=composite-scorer.d.ts.map

package/dist/internal/composite-scorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-scorer.d.ts","sourceRoot":"","sources":["../../src/internal/composite-scorer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,MAAM,WAAW,oBAAoB;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,eAAO,MAAM,wBAAwB,EAAE,oBAMtC,CAAC;AAEF,wBAAgB,cAAc,CAC5B,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,oBAA+C,GACtD,MAAM,CAUR"}

package/dist/internal/deepinfra-embedding.d.ts

@@ -0,0 +1,25 @@
+import { createOpenAiCompatibleRuntime } from "./openai-compatible.js";
+/**
+ * DeepInfra embedding adapter — hosts open-source embedding models
+ * (BGE, E5, Jina, etc.) at pay-per-token. OpenAI-compatible REST at
+ * `POST /v1/openai/embeddings` (note the `/openai` segment; not the
+ * canonical `/v1/embeddings`). The `embeddingsPath` override on
+ * `OpenAiCompatibleConfig` REPLACES the default suffix (EC-2).
+ *
+ * Honors `DEEPINFRA_API_KEY` and `DEEPINFRA_API_BASE_URL`.
+ *
+ * Iter 74 (Stage 3 source-move #33): hybrid copy from sdk-core's
+ * `internal/memory/adapters/deepinfra-embedding.ts`.
+ *
+ * @internal
+ */
+export declare const DEFAULT_DEEPINFRA_EMBEDDING_MODEL = "BAAI/bge-large-en-v1.5";
+export declare const deepinfraMemoryEmbeddingProviderAdapter: {
+    id: string;
+    defaultModel: string;
+    transport: "remote";
+    authProviderId: string;
+    autoSelectPriority: number;
+    create: (options: Parameters<typeof createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+};
+//# sourceMappingURL=deepinfra-embedding.d.ts.map

package/dist/internal/deepinfra-embedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepinfra-embedding.d.ts","sourceRoot":"","sources":["../../src/internal/deepinfra-embedding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAIvE;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,iCAAiC,2BAA2B,CAAC;AAe1E,eAAO,MAAM,uCAAuC;;;;;;sBAMhC,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC,CAAC,CAAC;CAatE,CAAC"}

package/dist/internal/dreaming-diary.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Dream-diary append (ADR D7).
+ *
+ * Diary lives at `.theokit/memory/dream-diary.md` and grows with one entry
+ * per sweep. Each entry is content-hashed so the same input produces the
+ * same entry — idempotency contract.
+ *
+ * Writes go through `replaceFileAtomic` (EC-3 of edge-case review) so a
+ * crash mid-write can never leave a half-written diary.
+ *
+ * Iter 59 (Stage 3 source-move #16): hybrid copy from sdk-core's
+ * `internal/memory/dreaming/diary.ts`. sdk-core retains its copy for
+ * v1.x dream-diary back-compat; sdk-memory ships the canonical copy
+ * that the future `dreaming-run.ts` move will compose with as a
+ * sibling (run.ts imports `appendDiaryEntry` after each dreaming
+ * sweep). Dependency chain (both resolved):
+ * - `@theokit/sdk/internal/persistence` for `replaceFileAtomic`
+ * - sibling `./markdown-store.js` for `memoryDir` (moved iter 56)
+ *
+ * Flat-naming convention (not `dreaming/diary.ts`): sdk-memory's
+ * `internal/` directory stays flat. The `dreaming-` prefix preserves
+ * the topical grouping (companion to iter 54's `dreaming-phases`).
+ *
+ * @internal
+ */
+export interface DiaryEntry {
+    timestampMs: number;
+    factsBefore: number;
+    factsAfter: number;
+    duplicatesRemoved: number;
+    clustersCreated: number;
+    notesWritten: number;
+}
+export declare function diaryPath(cwd: string): string;
+export declare function renderDiaryEntry(entry: DiaryEntry): string;
+export declare function appendDiaryEntry(cwd: string, entry: DiaryEntry): Promise<void>;
+export declare function entryHash(entry: DiaryEntry): string;
+//# sourceMappingURL=dreaming-diary.d.ts.map

package/dist/internal/dreaming-diary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dreaming-diary.d.ts","sourceRoot":"","sources":["../../src/internal/dreaming-diary.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAc1D;AAED,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAUpF;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAYnD"}

package/dist/internal/dreaming-phases.d.ts

@@ -0,0 +1,43 @@
+import type { EmbeddingRuntime } from "./embedding-adapter.js";
+import type { MemoryFact } from "./memory-types.js";
+/**
+ * Dreaming/REM phase logic.
+ *
+ * Three phases:
+ *   - **light** — drop near-duplicate facts (cosine similarity > 0.95).
+ *   - **REM**  — cluster thematically related facts (cosine ≥ 0.75).
+ *   - **deep** — pick a representative bullet per cluster (longest text
+ *                wins) and emit consolidated markdown notes.
+ *
+ * Iter 54 (Stage 3 source-move #11): hybrid copy from sdk-core's
+ * `internal/memory/dreaming/phases.ts`. sdk-core retains its copy
+ * for v1.x dreaming back-compat; sdk-memory ships the canonical copy
+ * that future `dreaming/run.ts` move will compose with as a sibling.
+ * Dependencies (both moved): `EmbeddingRuntime` (iter 45) +
+ * `MemoryFact` (iter 52).
+ *
+ * Flat-naming convention (not `dreaming/phases.ts`): sdk-memory's
+ * `internal/` directory stays flat to keep relative-import paths
+ * uniform across iter 44-53. The `dreaming-` prefix preserves the
+ * topical grouping without a sub-directory.
+ *
+ * @internal
+ */
+export interface DedupResult {
+    kept: MemoryFact[];
+    duplicatesRemoved: number;
+}
+export interface Cluster {
+    representativeText: string;
+    members: ReadonlyArray<MemoryFact>;
+}
+export interface ClusterResult {
+    clusters: Cluster[];
+}
+/** Light phase — drop facts whose embedding is too similar to one already kept. */
+export declare function lightPhase(facts: ReadonlyArray<MemoryFact>, embedding: EmbeddingRuntime, threshold?: number): Promise<DedupResult>;
+/** REM phase — single-link agglomerative clustering by cosine similarity. */
+export declare function remPhase(facts: ReadonlyArray<MemoryFact>, embedding: EmbeddingRuntime, threshold?: number, maxFactsPerSweep?: number): Promise<ClusterResult>;
+/** Deep phase — render consolidated markdown for the dreamed note. */
+export declare function deepPhase(clusters: ReadonlyArray<Cluster>, timestampMs: number): string;
+//# sourceMappingURL=dreaming-phases.d.ts.map

package/dist/internal/dreaming-phases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dreaming-phases.d.ts","sourceRoot":"","sources":["../../src/internal/dreaming-phases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,OAAO;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAKD,mFAAmF;AACnF,wBAAsB,UAAU,CAC9B,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,EAChC,SAAS,EAAE,gBAAgB,EAC3B,SAAS,GAAE,MAAgC,GAC1C,OAAO,CAAC,WAAW,CAAC,CActB;AAQD,6EAA6E;AAC7E,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,EAChC,SAAS,EAAE,gBAAgB,EAC3B,SAAS,GAAE,MAAkC,EAC7C,gBAAgB,GAAE,MAAoC,GACrD,OAAO,CAAC,aAAa,CAAC,CASxB;AAoCD,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAavF"}