emocentric 0.1.0

package/dist/events/context-event.d.ts

@@ -0,0 +1,49 @@
+import type { Payload } from "./payload.js";
+/** Who caused the event. Usually the human user, but adapters may also
+ * emit events for other entities (another player, a system timer). */
+export interface Actor {
+    /** Stable identifier within the platform (user id, gamertag, handle). */
+    id: string;
+    displayName?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * The normalized envelope every trigger produces. This is the single input
+ * type the rest of the pipeline (interpreter, appraiser, processor, writer)
+ * consumes — platform adapters translate native events into this shape.
+ *
+ * All fields except `raw` are JSON-serializable (when the payload avoids
+ * `bytes` media sources), so events can cross process boundaries.
+ *
+ * @typeParam TRaw - the platform-native event type, kept for adapters and
+ * actions that need platform-specific details (e.g. a reply token).
+ */
+export interface ContextEvent<TRaw = unknown> {
+    /** Unique id for this event (UUID v4 by default). */
+    id: string;
+    /** When the event happened, ISO 8601. */
+    occurredAt: string;
+    /** Which platform produced it: "discord", "imessage", "unity", ... */
+    platform: string;
+    /** Conversation/scene scope within the platform (channel, thread, level). */
+    channelId?: string;
+    actor: Actor;
+    payload: Payload;
+    /** The original platform-native event, untouched. */
+    raw?: TRaw;
+    metadata?: Record<string, unknown>;
+}
+/** Input to {@link createContextEvent}: `id` and `occurredAt` are filled in. */
+export type ContextEventInput<TRaw = unknown> = Omit<ContextEvent<TRaw>, "id" | "occurredAt"> & Partial<Pick<ContextEvent<TRaw>, "id" | "occurredAt">>;
+/**
+ * Build a ContextEvent, generating `id` and `occurredAt` when absent.
+ * Adapters should prefer this over hand-assembling the object so ids and
+ * timestamps stay consistent across platforms.
+ */
+export declare function createContextEvent<TRaw = unknown>(input: ContextEventInput<TRaw>): ContextEvent<TRaw>;
+/**
+ * UUID v4, runtime-portable: Web Crypto where available (Node 19+, browsers,
+ * Deno, Bun), with a Math.random fallback for embedded JS runtimes that lack
+ * `crypto` (some game-engine script hosts).
+ */
+export declare function generateEventId(): string;

package/dist/events/context-event.js

@@ -0,0 +1,43 @@
+/**
+ * Build a ContextEvent, generating `id` and `occurredAt` when absent.
+ * Adapters should prefer this over hand-assembling the object so ids and
+ * timestamps stay consistent across platforms.
+ */
+export function createContextEvent(input) {
+    return {
+        ...input,
+        id: input.id ?? generateEventId(),
+        occurredAt: input.occurredAt ?? new Date().toISOString(),
+    };
+}
+/**
+ * UUID v4, runtime-portable: Web Crypto where available (Node 19+, browsers,
+ * Deno, Bun), with a Math.random fallback for embedded JS runtimes that lack
+ * `crypto` (some game-engine script hosts).
+ */
+export function generateEventId() {
+    const cryptoApi = globalThis.crypto;
+    if (cryptoApi?.randomUUID)
+        return cryptoApi.randomUUID();
+    const bytes = new Uint8Array(16);
+    if (cryptoApi?.getRandomValues) {
+        cryptoApi.getRandomValues(bytes);
+    }
+    else {
+        for (let i = 0; i < 16; i++)
+            bytes[i] = Math.floor(Math.random() * 256);
+    }
+    // RFC 4122 version and variant bits
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+    return (hex.slice(0, 4).join("") +
+        "-" +
+        hex.slice(4, 6).join("") +
+        "-" +
+        hex.slice(6, 8).join("") +
+        "-" +
+        hex.slice(8, 10).join("") +
+        "-" +
+        hex.slice(10, 16).join(""));
+}

package/dist/events/guards.d.ts

@@ -0,0 +1,14 @@
+import type { Payload, SimplePayload } from "./payload.js";
+import type { Actor, ContextEvent } from "./context-event.js";
+/** Runtime check for a non-composite payload. */
+export declare function isSimplePayload(value: unknown): value is SimplePayload;
+/** Runtime check for any payload, rejecting nested composites. */
+export declare function isPayload(value: unknown): value is Payload;
+export declare function isActor(value: unknown): value is Actor;
+/**
+ * Runtime check for a ContextEvent — use at trust boundaries (deserializing
+ * from a queue, accepting events from third-party adapters).
+ */
+export declare function isContextEvent(value: unknown): value is ContextEvent;
+/** Throwing variant of {@link isContextEvent} with a descriptive error. */
+export declare function assertContextEvent(value: unknown): asserts value is ContextEvent;

package/dist/events/guards.js

@@ -0,0 +1,72 @@
+import { isMediaSource } from "./media.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Runtime check for a non-composite payload. */
+export function isSimplePayload(value) {
+    if (!isRecord(value))
+        return false;
+    switch (value.kind) {
+        case "text":
+            return typeof value.text === "string";
+        case "image":
+            return isMediaSource(value.source);
+        case "audio":
+        case "video":
+            return isMediaSource(value.source);
+        case "action":
+            return (typeof value.name === "string" &&
+                (value.data === undefined || isRecord(value.data)));
+        default:
+            return false;
+    }
+}
+/** Runtime check for any payload, rejecting nested composites. */
+export function isPayload(value) {
+    if (isSimplePayload(value))
+        return true;
+    if (!isRecord(value) || value.kind !== "composite")
+        return false;
+    return (Array.isArray(value.parts) &&
+        value.parts.length > 0 &&
+        value.parts.every(isSimplePayload));
+}
+export function isActor(value) {
+    return isRecord(value) && typeof value.id === "string" && value.id.length > 0;
+}
+/**
+ * Runtime check for a ContextEvent — use at trust boundaries (deserializing
+ * from a queue, accepting events from third-party adapters).
+ */
+export function isContextEvent(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === "string" &&
+        value.id.length > 0 &&
+        typeof value.occurredAt === "string" &&
+        !Number.isNaN(Date.parse(value.occurredAt)) &&
+        typeof value.platform === "string" &&
+        value.platform.length > 0 &&
+        (value.channelId === undefined || typeof value.channelId === "string") &&
+        isActor(value.actor) &&
+        isPayload(value.payload));
+}
+/** Throwing variant of {@link isContextEvent} with a descriptive error. */
+export function assertContextEvent(value) {
+    if (!isContextEvent(value)) {
+        throw new TypeError(`Value is not a valid ContextEvent: ${safePreview(value)}`);
+    }
+}
+function safePreview(value) {
+    try {
+        const json = JSON.stringify(value);
+        return json === undefined
+            ? String(value)
+            : json.length > 200
+                ? json.slice(0, 200) + "…"
+                : json;
+    }
+    catch {
+        return Object.prototype.toString.call(value);
+    }
+}

package/dist/events/index.d.ts

@@ -0,0 +1,8 @@
+export type { MediaSource } from "./media.js";
+export { isMediaSource } from "./media.js";
+export type { TextPayload, ImagePayload, AudioPayload, VideoPayload, ActionPayload, SimplePayload, CompositePayload, Payload, PayloadKind, } from "./payload.js";
+export { PAYLOAD_KINDS } from "./payload.js";
+export type { Actor, ContextEvent, ContextEventInput, } from "./context-event.js";
+export { createContextEvent, generateEventId } from "./context-event.js";
+export { mergeEvents } from "./merge.js";
+export { isSimplePayload, isPayload, isActor, isContextEvent, assertContextEvent, } from "./guards.js";

package/dist/events/index.js

@@ -0,0 +1,5 @@
+export { isMediaSource } from "./media.js";
+export { PAYLOAD_KINDS } from "./payload.js";
+export { createContextEvent, generateEventId } from "./context-event.js";
+export { mergeEvents } from "./merge.js";
+export { isSimplePayload, isPayload, isActor, isContextEvent, assertContextEvent, } from "./guards.js";

package/dist/events/media.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A reference to a piece of media (image, audio, video).
+ *
+ * Three transports are supported so the SDK works in any JS runtime:
+ * - `url`    — remote media; the consumer fetches it when needed.
+ * - `base64` — inline media, JSON-serializable (safe to put on a queue).
+ * - `bytes`  — inline media as raw bytes, zero-copy within a process.
+ */
+export type MediaSource = {
+    type: "url";
+    url: string;
+    mimeType?: string;
+} | {
+    type: "base64";
+    data: string;
+    mimeType: string;
+} | {
+    type: "bytes";
+    data: Uint8Array;
+    mimeType: string;
+};
+/** Narrow a MediaSource by transport. */
+export declare function isMediaSource(value: unknown): value is MediaSource;

package/dist/events/media.js

@@ -0,0 +1,16 @@
+/** Narrow a MediaSource by transport. */
+export function isMediaSource(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    switch (v.type) {
+        case "url":
+            return typeof v.url === "string";
+        case "base64":
+            return typeof v.data === "string" && typeof v.mimeType === "string";
+        case "bytes":
+            return v.data instanceof Uint8Array && typeof v.mimeType === "string";
+        default:
+            return false;
+    }
+}

package/dist/events/merge.d.ts

@@ -0,0 +1,24 @@
+import { type ContextEvent } from "./context-event.js";
+/**
+ * Fuse several events from one actor into a single event the pipeline can
+ * process once. This is the mechanical half of event coalescing: when a
+ * user fires off a burst ("yes!" then "actually—" then a photo), running
+ * three separate appraisals would be wrong and wasteful; merging lets the
+ * agent perceive and respond to the whole burst as one moment.
+ *
+ * - **payloads** flatten and concatenate into one {@link CompositePayload}
+ *   (each event's parts in order, oldest first), so the interpreter reads
+ *   them as a sequence; nested composites are flattened, never re-nested.
+ * - **occurredAt** is the latest event's time (decay and ordering stay
+ *   correct).
+ * - **actor / platform / channelId / raw** come from the latest event — the
+ *   freshest reply handle and display name.
+ * - **metadata.mergedFrom** keeps every original event (flattened — merging
+ *   an already-merged event expands its originals rather than nesting), so a
+ *   reply can still address each source message.
+ *
+ * One event in → that event back, untouched (nothing to merge). Zero events
+ * is a programming error. All events must share an `actor.id`; mixing actors
+ * would fuse different people's moments into one and is rejected.
+ */
+export declare function mergeEvents(events: ContextEvent[]): ContextEvent;

package/dist/events/merge.js

@@ -0,0 +1,61 @@
+import { generateEventId, } from "./context-event.js";
+/**
+ * Fuse several events from one actor into a single event the pipeline can
+ * process once. This is the mechanical half of event coalescing: when a
+ * user fires off a burst ("yes!" then "actually—" then a photo), running
+ * three separate appraisals would be wrong and wasteful; merging lets the
+ * agent perceive and respond to the whole burst as one moment.
+ *
+ * - **payloads** flatten and concatenate into one {@link CompositePayload}
+ *   (each event's parts in order, oldest first), so the interpreter reads
+ *   them as a sequence; nested composites are flattened, never re-nested.
+ * - **occurredAt** is the latest event's time (decay and ordering stay
+ *   correct).
+ * - **actor / platform / channelId / raw** come from the latest event — the
+ *   freshest reply handle and display name.
+ * - **metadata.mergedFrom** keeps every original event (flattened — merging
+ *   an already-merged event expands its originals rather than nesting), so a
+ *   reply can still address each source message.
+ *
+ * One event in → that event back, untouched (nothing to merge). Zero events
+ * is a programming error. All events must share an `actor.id`; mixing actors
+ * would fuse different people's moments into one and is rejected.
+ */
+export function mergeEvents(events) {
+    if (events.length === 0) {
+        throw new Error("mergeEvents requires at least one event.");
+    }
+    if (events.length === 1)
+        return events[0];
+    const actorId = events[0].actor.id;
+    if (!events.every((e) => e.actor.id === actorId)) {
+        throw new Error("mergeEvents refuses to merge events from different actors.");
+    }
+    // Oldest first; Array.sort is stable, so equal timestamps keep input order.
+    const ordered = [...events].sort((a, b) => Date.parse(a.occurredAt) - Date.parse(b.occurredAt));
+    const latest = ordered[ordered.length - 1];
+    const parts = ordered.flatMap((e) => flattenPayload(e.payload));
+    const mergedFrom = ordered.flatMap(originalsOf);
+    return {
+        id: generateEventId(),
+        occurredAt: latest.occurredAt,
+        platform: latest.platform,
+        actor: latest.actor,
+        ...(latest.channelId !== undefined && { channelId: latest.channelId }),
+        payload: { kind: "composite", parts },
+        ...(latest.raw !== undefined && { raw: latest.raw }),
+        metadata: { ...(latest.metadata ?? {}), mergedFrom },
+    };
+}
+/** A composite's parts, or the single payload wrapped — never nested. */
+function flattenPayload(payload) {
+    return payload.kind === "composite" ? payload.parts : [payload];
+}
+/** The true source events behind one event: its own `mergedFrom` if it was
+ * already a merge, else itself. Keeps `mergedFrom` a flat list of originals. */
+function originalsOf(event) {
+    const prior = event.metadata?.["mergedFrom"];
+    if (Array.isArray(prior) && prior.length > 0)
+        return prior;
+    return [event];
+}

package/dist/events/payload.d.ts

@@ -0,0 +1,54 @@
+import type { MediaSource } from "./media.js";
+/** Plain text — a chat message, a tweet, a caption. */
+export interface TextPayload {
+    kind: "text";
+    text: string;
+}
+/** A single image, optionally with platform-provided caption/alt text. */
+export interface ImagePayload {
+    kind: "image";
+    source: MediaSource;
+    caption?: string;
+}
+/** Audio, optionally with a platform-provided transcript. */
+export interface AudioPayload {
+    kind: "audio";
+    source: MediaSource;
+    durationMs?: number;
+    transcript?: string;
+}
+/** Video, optionally with a platform-provided transcript. */
+export interface VideoPayload {
+    kind: "video";
+    source: MediaSource;
+    durationMs?: number;
+    transcript?: string;
+}
+/**
+ * A structured, non-media action performed by the user — a game move,
+ * a button press, a reaction emoji, an in-app purchase.
+ *
+ * `name` identifies the action type ("player_attacked", "gift_sent");
+ * `description` is an optional human-readable summary the interpreter can
+ * use directly; `data` carries the structured details.
+ */
+export interface ActionPayload {
+    kind: "action";
+    name: string;
+    description?: string;
+    data?: Record<string, unknown>;
+}
+/** Every payload except composite. Composite parts must be one of these. */
+export type SimplePayload = TextPayload | ImagePayload | AudioPayload | VideoPayload | ActionPayload;
+/**
+ * A multi-part payload — e.g. a message containing text plus two images.
+ * Parts are ordered as the user presented them. Nesting composites is
+ * intentionally not representable: one event = one flat list of parts.
+ */
+export interface CompositePayload {
+    kind: "composite";
+    parts: SimplePayload[];
+}
+export type Payload = SimplePayload | CompositePayload;
+export type PayloadKind = Payload["kind"];
+export declare const PAYLOAD_KINDS: readonly PayloadKind[];

package/dist/events/payload.js

@@ -0,0 +1,8 @@
+export const PAYLOAD_KINDS = [
+    "text",
+    "image",
+    "audio",
+    "video",
+    "action",
+    "composite",
+];

package/dist/gateway/client.d.ts

@@ -0,0 +1,28 @@
+import type { LLMClient, LLMRequest, LLMResponse } from "../llm/types.js";
+export interface GatewayLLMClientOptions {
+    /** Base URL of the platform's LLM gateway, e.g.
+     * "https://emocentric-gateway.up.railway.app". */
+    url: string;
+    /** The developer's platform token — an opaque badge, not an OpenRouter
+     * key. The gateway holds the real key and never sends it back. */
+    token: string;
+    /** Model id requested from the gateway (subject to its allowlist). */
+    model: string;
+    /** Abort requests after this many ms. Default 120_000. */
+    timeoutMs?: number;
+}
+/**
+ * LLMClient that completes through the platform's gateway instead of a
+ * provider directly. The developer authenticates with a platform token; the
+ * gateway attaches the platform's provider key server-side, so reasoning
+ * stages run on the platform's budget without the key ever reaching the
+ * developer's machine.
+ */
+export declare class GatewayLLMClient implements LLMClient {
+    private readonly url;
+    private readonly token;
+    private readonly model;
+    private readonly timeoutMs;
+    constructor(options: GatewayLLMClientOptions);
+    complete(request: LLMRequest): Promise<LLMResponse>;
+}

package/dist/gateway/client.js

@@ -0,0 +1,79 @@
+/**
+ * LLMClient that completes through the platform's gateway instead of a
+ * provider directly. The developer authenticates with a platform token; the
+ * gateway attaches the platform's provider key server-side, so reasoning
+ * stages run on the platform's budget without the key ever reaching the
+ * developer's machine.
+ */
+export class GatewayLLMClient {
+    url;
+    token;
+    model;
+    timeoutMs;
+    constructor(options) {
+        if (!options.url)
+            throw new Error("GatewayLLMClient needs a gateway url.");
+        if (!options.token)
+            throw new Error("GatewayLLMClient needs a platform token.");
+        this.url = options.url.replace(/\/+$/, "");
+        this.token = options.token;
+        this.model = options.model;
+        this.timeoutMs = options.timeoutMs ?? 120_000;
+    }
+    async complete(request) {
+        const body = {
+            model: this.model,
+            messages: request.messages.map(toWireMessage),
+        };
+        if (request.system !== undefined)
+            body.system = request.system;
+        if (request.maxTokens !== undefined)
+            body.maxTokens = request.maxTokens;
+        if (request.jsonSchema !== undefined)
+            body.jsonSchema = request.jsonSchema;
+        const response = await fetch(`${this.url}/v1/complete`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        const payload = (await response.json().catch(() => ({})));
+        if (!response.ok) {
+            throw new Error(`Gateway request failed (${response.status} ${response.statusText}): ` +
+                (payload.error ?? "no error detail"));
+        }
+        if (typeof payload.text !== "string" || payload.text === "") {
+            throw new Error("Gateway returned no completion text.");
+        }
+        return { text: payload.text };
+    }
+}
+/** Bytes sources don't survive JSON (Uint8Array serializes as an object),
+ * so they're converted to base64 before crossing the wire. */
+function toWireMessage(message) {
+    return { ...message, content: message.content.map(toWireContent) };
+}
+function toWireContent(content) {
+    if (content.type !== "image" || content.source.type !== "bytes") {
+        return content;
+    }
+    const source = {
+        type: "base64",
+        data: bytesToBase64(content.source.data),
+        mimeType: content.source.mimeType,
+    };
+    return { type: "image", source };
+}
+function bytesToBase64(bytes) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("base64");
+    }
+    let binary = "";
+    for (let i = 0; i < bytes.length; i += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    }
+    return btoa(binary);
+}

package/dist/gateway/index.d.ts

@@ -0,0 +1 @@
+export { GatewayLLMClient, type GatewayLLMClientOptions } from "./client.js";

package/dist/gateway/index.js

@@ -0,0 +1 @@
+export { GatewayLLMClient } from "./client.js";

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Agent, AgentError, type AgentOptions, type AgentResult, type AgentStage, type HandleEventOptions, } from "./agent.js";
+export * from "./blueprint/index.js";
+export * from "./events/index.js";
+export * from "./memory/index.js";
+export * from "./short-term/index.js";
+export * from "./emotion/index.js";
+export * from "./actions/index.js";
+export * from "./llm/index.js";
+export * from "./pipeline/index.js";

package/dist/index.js

@@ -0,0 +1,13 @@
+export { Agent, AgentError, } from "./agent.js";
+export * from "./blueprint/index.js";
+export * from "./events/index.js";
+export * from "./memory/index.js";
+export * from "./short-term/index.js";
+export * from "./emotion/index.js";
+export * from "./actions/index.js";
+export * from "./llm/index.js";
+export * from "./pipeline/index.js";
+// Node-only / provider-specific implementations live behind their own entry
+// points so core imports stay runtime-portable:
+//   emocentric/postgres   — PostgresMemoryStore
+//   emocentric/openrouter — OpenRouterClient

package/dist/llm/index.d.ts

@@ -0,0 +1 @@
+export type { LLMClient, LLMContent, LLMMessage, LLMRequest, LLMResponse, } from "./types.js";

package/dist/llm/index.js

@@ -0,0 +1 @@
+export {};

package/dist/llm/types.d.ts

@@ -0,0 +1,40 @@
+import type { MediaSource } from "../events/media.js";
+/** One piece of a message: text or an image. (Audio/video reach the LLM as
+ * text — transcripts/captions — because chat models don't ingest them raw.) */
+export type LLMContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    source: MediaSource;
+};
+export interface LLMMessage {
+    role: "user" | "assistant";
+    content: LLMContent[];
+}
+export interface LLMRequest {
+    /** System prompt — who the model is for this call. */
+    system?: string;
+    messages: LLMMessage[];
+    maxTokens?: number;
+    /** When set, the client asks the provider for JSON conforming to this
+     * schema (providers without schema support get prompt-level enforcement
+     * instead, so callers must still parse defensively). */
+    jsonSchema?: {
+        name: string;
+        schema: Record<string, unknown>;
+    };
+}
+export interface LLMResponse {
+    text: string;
+}
+/**
+ * The LLM boundary of the SDK — every model-touching component (interpreter,
+ * appraiser, processor, writer) calls this one method and nothing else.
+ * The SDK ships an OpenRouter implementation (`emocentric/openrouter`) so
+ * developers pick any model by name; bringing a different provider means
+ * implementing `complete` and passing your client in.
+ */
+export interface LLMClient {
+    complete(request: LLMRequest): Promise<LLMResponse>;
+}

package/dist/llm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/memory/fact.d.ts

@@ -0,0 +1,54 @@
+/**
+ * What a fact is about. The four built-in kinds come from the agent design:
+ * - `persona` — who the agent is (traits, voice, backstory)
+ * - `self`    — things the agent learned about itself ("I'm bad at chess")
+ * - `user`    — things about a user ("Alice has a golden retriever")
+ * - `event`   — specific things that happened ("On 2026-06-01 Alice showed
+ *               me a photo of her new apartment")
+ *
+ * The `(string & {})` arm keeps the union open so developers can add their
+ * own kinds ("world", "relationship", ...) without losing autocomplete on
+ * the built-ins.
+ */
+export type FactKind = "persona" | "self" | "user" | "event" | (string & {});
+/** One remembered thing, stored as natural-language text. */
+export interface Fact {
+    id: string;
+    kind: FactKind;
+    /** The fact itself, written as a standalone sentence. The recaller
+     * searches this text and the interpreter quotes it verbatim, so it must
+     * make sense without surrounding context. */
+    content: string;
+    /** Who the fact is about, when it's about someone — usually an Actor id. */
+    subjectId?: string;
+    /** 0..1, how much this fact matters. Feeds into retrieval ranking. */
+    importance: number;
+    /** ISO 8601. */
+    createdAt: string;
+    /** ISO 8601, set by the store when the fact is returned from a fetch. */
+    lastAccessedAt?: string;
+    /** Id of the fact that replaced this one. Superseded facts are kept for
+     * history but excluded from retrieval by default. */
+    supersededBy?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Input to MemoryStore.add — id/createdAt are generated when absent. */
+export interface FactInput {
+    kind: FactKind;
+    content: string;
+    subjectId?: string;
+    /** Defaults to 0.5. */
+    importance?: number;
+    metadata?: Record<string, unknown>;
+    id?: string;
+    createdAt?: string;
+}
+/** Partial update for MemoryStore.update. */
+export interface FactPatch {
+    kind?: FactKind;
+    content?: string;
+    subjectId?: string;
+    importance?: number;
+    supersededBy?: string;
+    metadata?: Record<string, unknown>;
+}

package/dist/memory/fact.js

@@ -0,0 +1 @@
+export {};

package/dist/memory/index.d.ts

@@ -0,0 +1,4 @@
+export type { Fact, FactInput, FactKind, FactPatch } from "./fact.js";
+export type { Embedder, MemoryQuery, MemoryStore, ScoredFact, } from "./store.js";
+export { DEFAULT_SCORING_WEIGHTS, type ScoringWeights, blendScore, clamp01, recencyScore, } from "./scoring.js";
+export { OpenAIEmbedder, type OpenAIEmbedderOptions } from "./openai-embedder.js";

package/dist/memory/index.js

@@ -0,0 +1,2 @@
+export { DEFAULT_SCORING_WEIGHTS, blendScore, clamp01, recencyScore, } from "./scoring.js";
+export { OpenAIEmbedder } from "./openai-embedder.js";