@retinue/agentkit 0.1.0

package/dist/adapters/memory/message-store.d.ts

@@ -0,0 +1,17 @@
+/**
+ * In-memory message + agent stores — used by the embedded `createAgent` facade and for tests.
+ * Tenant-partitioned. `append` is on the port as of #157 — it used to be a "test-only affordance", which meant
+ * every host had to reach past the port to record what a user said. AgentStore serves manifests by version.
+ */
+import type { AgentManifest } from "../../agents/index.js";
+import type { AgentStore, MessageStore } from "../../persistence/index.js";
+export declare const createMemoryMessageStore: () => MessageStore;
+/** A manifest and the tenant that owns it. Manifests carry no `tenantId`, so ownership is explicit here. */
+export type AgentStoreEntry = {
+    readonly tenantId: string;
+    readonly manifest: AgentManifest;
+};
+export declare const createMemoryAgentStore: (entries?: readonly AgentStoreEntry[]) => AgentStore & {
+    put(tenantId: string, manifest: AgentManifest): void;
+};
+//# sourceMappingURL=message-store.d.ts.map

package/dist/adapters/memory/message-store.js

@@ -0,0 +1,70 @@
+/**
+ * In-memory message + agent stores — used by the embedded `createAgent` facade and for tests.
+ * Tenant-partitioned. `append` is on the port as of #157 — it used to be a "test-only affordance", which meant
+ * every host had to reach past the port to record what a user said. AgentStore serves manifests by version.
+ */
+export const createMemoryMessageStore = () => {
+    const byTenant = new Map();
+    const list = (t) => {
+        let m = byTenant.get(t);
+        if (!m)
+            byTenant.set(t, (m = []));
+        return m;
+    };
+    return {
+        async append({ tenantId, message }) {
+            // Idempotent on the id, matching the Postgres adapter's `ON CONFLICT DO NOTHING`. The reference adapter
+            // silently diverging on a retry is exactly the class of difference the conformance suite exists to catch.
+            const messages = list(tenantId);
+            if (messages.some((m) => m.id === message.id))
+                return;
+            messages.push(message);
+        },
+        async findById({ tenantId, id }) {
+            return list(tenantId).find((m) => m.id === id) ?? null;
+        },
+        async listByConversation({ tenantId, conversationId, limit, cursor, newestFirst }) {
+            /**
+             * Ordered by `(createdAt, id)`, like the SQL adapter — not by insertion order.
+             *
+             * It used to page the array as stored, which agreed with the SQL adapter only because every seed happened
+             * to insert in timestamp order. A host that appended an older message — a backfill, a replayed event —
+             * would have got a different order from each adapter, and the conformance suite could not see it because
+             * its own fixtures were ordered too.
+             */
+            const all = list(tenantId)
+                .filter((m) => m.conversationId === conversationId)
+                .sort((a, b) => a.createdAt === b.createdAt ? a.id.localeCompare(b.id) : a.createdAt.localeCompare(b.createdAt));
+            // #167: the same page read from the other end.
+            const ordered = newestFirst === true ? [...all].reverse() : all;
+            const start = cursor ? ordered.findIndex((m) => m.id === cursor) + 1 : 0;
+            const items = ordered.slice(start, start + limit);
+            const nextCursor = start + limit < ordered.length ? items[items.length - 1]?.id : undefined;
+            const page = nextCursor === undefined ? { items } : { items, nextCursor };
+            return page;
+        },
+    };
+};
+export const createMemoryAgentStore = (entries = []) => {
+    // tenantId → (id@version → manifest). Partitioning by tenant makes cross-tenant reads
+    // structurally impossible, matching every sibling store in this package. Keying only by
+    // `id@version` let one tenant resolve another's manifest — the leak the #91 harness surfaced.
+    const byTenant = new Map();
+    const tenant = (t) => {
+        let m = byTenant.get(t);
+        if (!m)
+            byTenant.set(t, (m = new Map()));
+        return m;
+    };
+    const key = (id, v) => `${id}@${v}`;
+    const put = (tenantId, manifest) => void tenant(tenantId).set(key(manifest.id, manifest.version), manifest);
+    for (const entry of entries)
+        put(entry.tenantId, entry.manifest);
+    return {
+        put,
+        async findByVersion({ tenantId, agentId, version }) {
+            return byTenant.get(tenantId)?.get(key(agentId, version)) ?? null;
+        },
+    };
+};
+//# sourceMappingURL=message-store.js.map

package/dist/adapters/memory/principal-memory.d.ts

@@ -0,0 +1,7 @@
+/**
+ * In-memory principal memory store — `docs/15`. Partitioned by (tenant, principal) so a query can
+ * never reach another principal's or tenant's memory. Versioned; hard-delete cannot resurface.
+ */
+import type { PrincipalMemoryStore } from "../../principal-memory/index.js";
+export declare const createMemoryPrincipalMemoryStore: (clock?: () => string) => PrincipalMemoryStore;
+//# sourceMappingURL=principal-memory.d.ts.map

package/dist/adapters/memory/principal-memory.js

@@ -0,0 +1,83 @@
+/**
+ * In-memory principal memory store — `docs/15`. Partitioned by (tenant, principal) so a query can
+ * never reach another principal's or tenant's memory. Versioned; hard-delete cannot resurface.
+ */
+import { AgentPlatformError } from "../../core/errors.js";
+const conflict = (m) => new AgentPlatformError({ code: "conflict", message: m, retryable: false });
+const notFound = (id) => new AgentPlatformError({ code: "not_found", message: `Memory ${id} not found`, retryable: false });
+export const createMemoryPrincipalMemoryStore = (clock = () => new Date().toISOString()) => {
+    const byKey = new Map();
+    let counter = 0;
+    const key = (t, p) => `${t} ${p}`;
+    const bucket = (t, p) => {
+        const k = key(t, p);
+        let m = byKey.get(k);
+        if (!m)
+            byKey.set(k, (m = new Map()));
+        return m;
+    };
+    const active = (e) => e.disabledAt === undefined;
+    return {
+        async put({ tenantId, principalId, id, text, tags, salience }) {
+            const rows = bucket(tenantId, principalId);
+            const entryId = id ?? `mem-${(counter += 1)}`;
+            const now = clock();
+            const existing = rows.get(entryId);
+            const entry = {
+                id: entryId,
+                tenantId,
+                principalId,
+                text,
+                tags: tags ?? [],
+                salience: salience ?? 1,
+                version: existing ? existing.version + 1 : 1,
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+            };
+            rows.set(entryId, entry);
+            return entry;
+        },
+        async get({ tenantId, principalId, id }) {
+            return bucket(tenantId, principalId).get(id) ?? null;
+        },
+        async list({ tenantId, principalId, limit, cursor }) {
+            const all = [...bucket(tenantId, principalId).values()].sort((a, b) => a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : a.id < b.id ? -1 : 1);
+            const start = cursor ? all.findIndex((e) => e.id === cursor) + 1 : 0;
+            const items = all.slice(start, start + limit);
+            const nextCursor = start + limit < all.length ? items[items.length - 1]?.id : undefined;
+            const page = nextCursor === undefined ? { items } : { items, nextCursor };
+            return page;
+        },
+        async update({ tenantId, principalId, id, expectedVersion, patch }) {
+            const rows = bucket(tenantId, principalId);
+            const row = rows.get(id);
+            if (!row)
+                throw notFound(id);
+            if (row.version !== expectedVersion)
+                throw conflict(`Memory ${id} version ${expectedVersion} is stale (current ${row.version})`);
+            const next = {
+                ...row,
+                ...(patch.text === undefined ? {} : { text: patch.text }),
+                ...(patch.tags === undefined ? {} : { tags: patch.tags }),
+                ...(patch.salience === undefined ? {} : { salience: patch.salience }),
+                ...(patch.disabled === undefined ? {} : patch.disabled ? { disabledAt: clock() } : { disabledAt: undefined }),
+                version: row.version + 1,
+                updatedAt: clock(),
+            };
+            rows.set(id, next);
+            return next;
+        },
+        async delete({ tenantId, principalId, id }) {
+            bucket(tenantId, principalId).delete(id); // hard delete — cannot resurface
+        },
+        async retrieve({ tenantId, principalId, query, limit }) {
+            const q = query?.trim().toLowerCase();
+            return [...bucket(tenantId, principalId).values()]
+                .filter(active)
+                .filter((e) => !q || e.text.toLowerCase().includes(q) || e.tags.some((t) => t.toLowerCase().includes(q)))
+                .sort((a, b) => b.salience - a.salience)
+                .slice(0, limit);
+        },
+    };
+};
+//# sourceMappingURL=principal-memory.js.map

package/dist/adapters/memory/runtime.d.ts

@@ -0,0 +1,29 @@
+/**
+ * In-memory runtime adapters — `docs/04-durable-runtime-and-hitl.md`.
+ *
+ * Reference `RunStore`, `CheckpointStore`, `JobDispatcher` and `DistributedLockStore` for tests and
+ * dev. The `RunStore` models real lease semantics (atomic claim, expiry, guarded transitions) so the
+ * durable-worker guarantees can be proven without Redis/Postgres. Verified by `runStoreConformance`.
+ */
+import type { RunId, TenantId } from "../../core/ids.js";
+import type { RunEventLog } from "../../core/events.js";
+import type { CheckpointStore, RunStore } from "../../persistence/index.js";
+import { type DistributedLockStore, type JobDispatcher } from "../../runtime/index.js";
+export declare const createMemoryRunStore: () => RunStore;
+export declare const createMemoryCheckpointStore: () => CheckpointStore;
+/** Append-only in-memory `RunEventLog` — the durable catch-up half of reconnect, for tests/dev. */
+export declare const createMemoryRunEventLog: () => RunEventLog;
+/**
+ * Synchronous in-memory job dispatcher. Enqueue records the job; `drain` runs each pending job
+ * through the provided processor. Mirrors Twenty's `SyncDriver` — inline execution for tests.
+ */
+export declare const createMemoryJobDispatcher: (process: (job: {
+    tenantId: TenantId;
+    runId: RunId;
+}) => Promise<unknown>) => JobDispatcher & {
+    pending: () => number;
+    drain: () => Promise<void>;
+};
+/** In-memory lock with TTL expiry. `now` is injectable for deterministic tests. */
+export declare const createMemoryLockStore: (now?: () => number) => DistributedLockStore;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/adapters/memory/sessions.d.ts

@@ -0,0 +1,29 @@
+/**
+ * In-memory session/thread adapters — `docs/13-sessions-and-threads.md`.
+ *
+ * Reference `SessionStateStore`, `ConversationRunCoordinator`, `ConversationBindingStore` and a
+ * rollback-capable `UnitOfWork` for tests and dev. They model the real semantics the runtime relies
+ * on: optimistic concurrency + size bounds on session state, single-flight + FIFO run ordering per
+ * conversation, deterministic agent binding, and all-or-nothing turn commit.
+ */
+import type { ConversationBindingStore, ConversationRunCoordinator, SessionStateStore, UnitOfWork } from "../../persistence/index.js";
+export declare const createMemorySessionStateStore: (options?: {
+    maxBytes?: number;
+    clock?: () => string;
+}) => SessionStateStore;
+export declare const createMemoryConversationBindingStore: () => ConversationBindingStore;
+export declare const createMemoryConversationRunCoordinator: () => ConversationRunCoordinator;
+/** Rollback hook a transactional body registers compensating actions on. */
+export interface RollbackContext {
+    onRollback(compensate: () => void | Promise<void>): void;
+}
+/**
+ * Memory `UnitOfWork` with explicit compensation: the body registers rollbacks; if it throws, they
+ * run in reverse. Real Postgres uses an actual transaction — this gives the reference adapter the
+ * same all-or-nothing guarantee (session-state write and run finalization commit together or not
+ * at all). Use `runTx` to receive the rollback context; `run` satisfies the bare port.
+ */
+export declare const createMemoryUnitOfWork: () => UnitOfWork & {
+    runTx<T>(fn: (tx: RollbackContext) => Promise<T>): Promise<T>;
+};
+//# sourceMappingURL=sessions.d.ts.map

package/dist/adapters/memory/skills.d.ts

@@ -0,0 +1,10 @@
+/**
+ * In-memory skill store — `docs/03` → Skills. Holds tenant-authored skill versions for the resolver.
+ * Tenant-partitioned; validated on the way in against SKILL_LIMITS via `validateSkillInput`.
+ */
+import type { SkillStore } from "../../persistence/index.js";
+import type { SkillVersion } from "../../skills/index.js";
+export declare const createMemorySkillStore: (seed?: readonly SkillVersion[]) => SkillStore & {
+    add(tenantId: string, skill: SkillVersion): void;
+};
+//# sourceMappingURL=skills.d.ts.map

package/dist/adapters/memory/skills.js

@@ -0,0 +1,41 @@
+/**
+ * In-memory skill store — `docs/03` → Skills. Holds tenant-authored skill versions for the resolver.
+ * Tenant-partitioned; validated on the way in against SKILL_LIMITS via `validateSkillInput`.
+ */
+import { validateSkillInput } from "../../skills/resolver.js";
+export const createMemorySkillStore = (seed = []) => {
+    // tenantId -> `${name}@${version}` -> SkillVersion
+    const byTenant = new Map();
+    const tenant = (t) => {
+        let m = byTenant.get(t);
+        if (!m)
+            byTenant.set(t, (m = new Map()));
+        return m;
+    };
+    const add = (tenantId, skill) => {
+        validateSkillInput(skill);
+        tenant(tenantId).set(`${skill.name}@${skill.version}`, skill);
+    };
+    for (const s of seed)
+        if (s.tenantId)
+            add(s.tenantId, s);
+    return {
+        add,
+        async listCatalog({ tenantId }) {
+            // Latest version per name, active only.
+            const latest = new Map();
+            for (const s of tenant(tenantId).values()) {
+                if (s.status !== "active")
+                    continue;
+                const prev = latest.get(s.name);
+                if (!prev || s.version > prev.version)
+                    latest.set(s.name, s);
+            }
+            return [...latest.values()].map((s) => ({ id: s.id, name: s.name, description: s.description, source: s.source, version: s.version }));
+        },
+        async findVersion({ tenantId, name, version }) {
+            return tenant(tenantId).get(`${name}@${version}`) ?? null;
+        },
+    };
+};
+//# sourceMappingURL=skills.js.map

package/dist/adapters/memory/thread-summary.d.ts

@@ -0,0 +1,7 @@
+/**
+ * In-memory thread summary store — `docs/13` → Long-thread compaction. Versioned, append-only
+ * compacted history; `latest` returns the newest summary. Tenant/conversation-partitioned.
+ */
+import type { ThreadSummaryStore } from "../../persistence/index.js";
+export declare const createMemoryThreadSummaryStore: (clock?: () => string) => ThreadSummaryStore;
+//# sourceMappingURL=thread-summary.d.ts.map

package/dist/adapters/memory/thread-summary.js

@@ -0,0 +1,29 @@
+/**
+ * In-memory thread summary store — `docs/13` → Long-thread compaction. Versioned, append-only
+ * compacted history; `latest` returns the newest summary. Tenant/conversation-partitioned.
+ */
+export const createMemoryThreadSummaryStore = (clock = () => new Date().toISOString()) => {
+    const byKey = new Map();
+    const key = (tenantId, conversationId) => `${tenantId} ${conversationId}`;
+    return {
+        async latest({ tenantId, conversationId }) {
+            const list = byKey.get(key(tenantId, conversationId));
+            return list && list.length > 0 ? list[list.length - 1] : null;
+        },
+        async append({ tenantId, conversationId, summary, coversUpToMessageId }) {
+            const k = key(tenantId, conversationId);
+            const list = byKey.get(k) ?? [];
+            const next = {
+                conversationId,
+                version: list.length + 1,
+                summary,
+                coversUpToMessageId,
+                createdAt: clock(),
+            };
+            list.push(next);
+            byKey.set(k, list);
+            return next;
+        },
+    };
+};
+//# sourceMappingURL=thread-summary.js.map

package/dist/adapters/memory/usage-limits.d.ts

@@ -0,0 +1,13 @@
+/**
+ * In-memory `UsageLimitStore` — the reference implementation (#175).
+ *
+ * Mirrors the SQL adapter's resolution rule exactly, including the part that is easy to get subtly different:
+ * **most specific wins**, and a tenant default is the fallback rather than something to merge with. A store that
+ * merged the two — taking the principal's cost limit and the tenant's token limit — would be a third behaviour
+ * neither adapter documents, and the conformance suite exists to stop precisely that.
+ */
+import type { UsageLimitStore } from "../../persistence/index.js";
+export declare const createMemoryUsageLimitStore: (config?: {
+    readonly clock?: () => string;
+}) => UsageLimitStore;
+//# sourceMappingURL=usage-limits.d.ts.map

package/dist/adapters/memory/usage-limits.js

@@ -0,0 +1,72 @@
+/**
+ * In-memory `UsageLimitStore` — the reference implementation (#175).
+ *
+ * Mirrors the SQL adapter's resolution rule exactly, including the part that is easy to get subtly different:
+ * **most specific wins**, and a tenant default is the fallback rather than something to merge with. A store that
+ * merged the two — taking the principal's cost limit and the tenant's token limit — would be a third behaviour
+ * neither adapter documents, and the conformance suite exists to stop precisely that.
+ */
+import { windowKey } from "../../persistence/index.js";
+/**
+ * Keyed by grain, with the tenant default under an empty principal segment — same shape as the SQL indexes.
+ *
+ * The window half goes through `windowKey`, the same function the SQL adapter stores, so the two adapters cannot
+ * key a rolling window differently. Spelling it `${minutes}` here and `rolling:${minutes}` there would leave both
+ * stores self-consistent and mutually unreadable, which conformance would not catch.
+ */
+const keyOf = (principalId, modelId, window) => 
+// Three segments with an explicit empty for "absent", matching the SQL index's `COALESCE(col, '')`. Neither id
+// can legitimately be empty, so the marker cannot collide with a real value.
+`${principalId ?? ""} ${modelId ?? ""} ${windowKey(window)}`;
+export const createMemoryUsageLimitStore = (config = {}) => {
+    const clock = config.clock ?? (() => new Date().toISOString());
+    const byTenant = new Map();
+    const tenant = (t) => {
+        let m = byTenant.get(t);
+        if (!m)
+            byTenant.set(t, (m = new Map()));
+        return m;
+    };
+    return {
+        async put({ tenantId, limit }) {
+            const stored = { ...limit, tenantId: tenantId, updatedAt: clock() };
+            tenant(tenantId).set(keyOf(limit.principalId, limit.modelId, limit.window), stored);
+            return stored;
+        },
+        async resolve({ tenantId, principalId, modelId, window }) {
+            const rows = tenant(tenantId);
+            // The principal's own row, else the tenant default, else unbounded. A fallback, never a merge: a partial
+            // override that inherited the rest would be a third set of limits nobody configured.
+            return (rows.get(keyOf(principalId, modelId, window)) ?? rows.get(keyOf(undefined, modelId, window)) ?? null);
+        },
+        async applicable({ tenantId, principalId, modelId }) {
+            // Override within a scope, coexist across scopes — #182. One row per `(window, model)`, the principal's
+            // beating the tenant's for that same scope only.
+            const bestByScope = new Map();
+            for (const record of tenant(tenantId).values()) {
+                // A row for somebody else never applies; a model-scoped row applies only to that model, and not at all
+                // when the caller has no model to check.
+                if (record.principalId !== undefined && record.principalId !== principalId)
+                    continue;
+                if (record.modelId !== undefined && record.modelId !== modelId)
+                    continue;
+                const scope = `${record.modelId ?? ""} ${windowKey(record.window)}`;
+                const held = bestByScope.get(scope);
+                // A principal's row wins the scope. Where both are the tenant's or both the principal's there is only
+                // one row, since that is exactly what the key is.
+                if (held === undefined || (held.principalId === undefined && record.principalId !== undefined))
+                    bestByScope.set(scope, record);
+            }
+            return [...bestByScope.values()];
+        },
+        async list({ tenantId }) {
+            return [...tenant(tenantId).values()].sort((a, b) => (a.principalId ?? "").localeCompare(b.principalId ?? "") ||
+                (a.modelId ?? "").localeCompare(b.modelId ?? "") ||
+                windowKey(a.window).localeCompare(windowKey(b.window)));
+        },
+        async remove({ tenantId, principalId, modelId, window }) {
+            tenant(tenantId).delete(keyOf(principalId, modelId, window));
+        },
+    };
+};
+//# sourceMappingURL=usage-limits.js.map

package/dist/adapters/memory/usage.d.ts

@@ -0,0 +1,16 @@
+import type { UsageRollupStore, UsageStore } from "../../persistence/index.js";
+/**
+ * The ledger and its rollups over one set of rows (#139).
+ *
+ * One backend, because a rollup is *derived* from the ledger and nothing else — deriving it from a second copy
+ * of the events would make the two able to disagree, which is the one thing a spend figure must not do.
+ */
+export declare const createMemoryUsageBackend: (options?: {
+    readonly clock?: () => string;
+}) => {
+    usage: UsageStore;
+    rollups: UsageRollupStore;
+};
+export declare const createMemoryUsageStore: () => UsageStore;
+export declare const createMemoryUsageRollupStore: () => UsageRollupStore;
+//# sourceMappingURL=usage.d.ts.map