@vextlabs/theron-agent-sdk 0.3.0

package/dist/loop/index.js

@@ -0,0 +1,95 @@
+// src/loop/index.ts
+function stepCountIs(n) {
+  return (s) => s.step >= n;
+}
+function costUsdAtLeast(min) {
+  return (s) => s.cost_usd >= min;
+}
+function verifierSatisfied(kernelName) {
+  return (s) => {
+    if (!s.verifier_results) return false;
+    return s.verifier_results.some((r) => r.kernel === kernelName && r.pass === true);
+  };
+}
+function anyOf(...preds) {
+  return (s) => preds.some((p) => p(s));
+}
+function allOf(...preds) {
+  return (s) => preds.every((p) => p(s));
+}
+function verifiedRatchet(opts) {
+  const threshold = opts?.minConfidence ?? 0.6;
+  return (v) => {
+    if (v === void 0) {
+      return { advance: false, reason: "no verdict" };
+    }
+    if (v.verdict !== "sufficient") {
+      return {
+        advance: false,
+        reason: `verdict '${v.verdict}' is not 'sufficient'${v.source ? ` (source: ${v.source})` : ""}`
+      };
+    }
+    if (v.confidence < threshold) {
+      return {
+        advance: false,
+        reason: `verdict is 'sufficient' but confidence ${v.confidence.toFixed(3)} < threshold ${threshold.toFixed(3)}`
+      };
+    }
+    return {
+      advance: true,
+      reason: `verified sufficient at confidence ${v.confidence.toFixed(3)} >= ${threshold.toFixed(3)}${v.source ? ` (source: ${v.source})` : ""}`
+    };
+  };
+}
+async function runImprovementCycle(spec) {
+  const ratchet = spec.ratchet ?? verifiedRatchet();
+  const proposal = await spec.propose();
+  const trial = await spec.trial(proposal);
+  const verdict = await spec.verify(proposal, trial);
+  const decision = ratchet(verdict);
+  return { proposal, trial, verdict, decision };
+}
+var SUMMARY_PREFIX = "[Summary of earlier conversation]";
+async function compactHistory(opts) {
+  const keepRecent = Math.max(1, Math.floor(opts.keepRecent ?? 6));
+  const msgs = opts.messages ?? [];
+  const totalChars = msgs.reduce((n, m) => n + (m.content?.length ?? 0), 0);
+  const maxChars = opts.maxChars ?? 0;
+  if (msgs.length <= keepRecent || maxChars > 0 && totalChars <= maxChars) {
+    return { messages: msgs, compacted: false, droppedCount: 0 };
+  }
+  const older = msgs.slice(0, msgs.length - keepRecent);
+  const recent = msgs.slice(msgs.length - keepRecent);
+  const summary = String(await opts.summarize(older));
+  return {
+    messages: [{ role: "system", content: `${SUMMARY_PREFIX}
+${summary}` }, ...recent],
+    compacted: true,
+    summary,
+    droppedCount: older.length
+  };
+}
+async function runUntil(opts) {
+  const maxSteps = Math.max(1, Math.floor(opts.maxSteps ?? 100));
+  let state = opts.initial;
+  for (let i = 0; i < maxSteps; i++) {
+    state = await opts.step(state, i);
+    if (opts.onCheckpoint) await opts.onCheckpoint(state, i);
+    if (opts.stopWhen(state, i)) return { state, steps: i + 1, stopped: "predicate" };
+  }
+  return { state, steps: maxSteps, stopped: "maxSteps" };
+}
+function boundWorkingSet(items, max) {
+  const cap = Math.max(0, Math.floor(max));
+  if (items.length <= cap) return { kept: items, evicted: [] };
+  const pinned = items.filter((i) => i.pinned);
+  const rest = items.filter((i) => !i.pinned);
+  const slots = Math.max(0, cap - pinned.length);
+  const ranked = [...rest].sort((a, b) => (b.importance ?? 0) - (a.importance ?? 0) || b.seq - a.seq);
+  const keepRest = new Set(ranked.slice(0, slots));
+  const kept = items.filter((i) => i.pinned || keepRest.has(i));
+  const evicted = items.filter((i) => !i.pinned && !keepRest.has(i));
+  return { kept, evicted };
+}
+
+export { allOf, anyOf, boundWorkingSet, compactHistory, costUsdAtLeast, runImprovementCycle, runUntil, stepCountIs, verifiedRatchet, verifierSatisfied };

package/dist/mcp/index.cjs

@@ -0,0 +1,153 @@
+'use strict';
+
+// src/mcp/index.ts
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+var DEFAULT_TIMEOUT_MS = 12e3;
+var MCPClient = class {
+  config;
+  initialized = false;
+  toolCache = null;
+  constructor(config) {
+    if (!/^[a-z0-9_-]+$/.test(config.slug)) {
+      throw new Error(
+        `MCPClient slug "${config.slug}" must match /^[a-z0-9_-]+$/`
+      );
+    }
+    this.config = { timeout_ms: DEFAULT_TIMEOUT_MS, ...config };
+  }
+  /** Fetch the server's tool catalog. Cached for the lifetime of the client. */
+  async listTools(signal) {
+    if (this.toolCache) return this.toolCache;
+    await this.ensureInitialized(signal);
+    const result = await this.rpc("tools/list", {}, signal);
+    this.toolCache = Array.isArray(result?.tools) ? result.tools : [];
+    return this.toolCache;
+  }
+  /** Call a tool by its bare (non-namespaced) name. Returns the text payload. */
+  async callTool(name, args, signal) {
+    await this.ensureInitialized(signal);
+    const result = await this.rpc(
+      "tools/call",
+      { name, arguments: args },
+      signal
+    );
+    const blocks = Array.isArray(result?.content) ? result.content : [];
+    const text = blocks.map((b) => b.type === "text" && typeof b.text === "string" ? b.text : "").filter(Boolean).join("\n").trim();
+    return text || JSON.stringify(result ?? {}).slice(0, 4e3);
+  }
+  /**
+   * Return the server's tool catalog as SDK Tool[] objects, namespaced so they
+   * compose with tools from other sources without colliding.
+   *
+   * Pass these directly to a Runner. The Runner sees standard SDK tools; it
+   * never has to know MCP existed.
+   */
+  async asTools(signal) {
+    const raw = await this.listTools(signal);
+    return raw.map((t) => this.toSdkTool(t));
+  }
+  /** Health-check: returns toolCount on success, throws on failure. */
+  async probe(signal) {
+    const tools = await this.listTools(signal);
+    return { toolCount: tools.length };
+  }
+  // -------------------------------------------------------------- internals
+  toSdkTool(raw) {
+    const ns = `${this.config.slug}__${raw.name}`.slice(0, 64).replace(/[^a-zA-Z0-9_-]/g, "_");
+    const schema = {
+      name: ns,
+      description: `[${this.config.name}] ${raw.description || raw.name}`,
+      input_schema: raw.inputSchema ?? {
+        type: "object",
+        properties: {}
+      }
+    };
+    const client = this;
+    return {
+      schema,
+      async execute(input, _ctx) {
+        return client.callTool(raw.name, input);
+      }
+    };
+  }
+  async ensureInitialized(signal) {
+    if (this.initialized) return;
+    await this.rpc(
+      "initialize",
+      {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: "theron-agent-sdk", version: "0.1" }
+      },
+      signal
+    );
+    this.rpc("notifications/initialized", {}, signal).catch(() => void 0);
+    this.initialized = true;
+  }
+  async rpc(method, params, externalSignal) {
+    const ac = new AbortController();
+    const timer = setTimeout(
+      () => ac.abort(),
+      this.config.timeout_ms ?? DEFAULT_TIMEOUT_MS
+    );
+    if (externalSignal) {
+      if (externalSignal.aborted) ac.abort();
+      else externalSignal.addEventListener("abort", () => ac.abort());
+    }
+    const body = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.floor(Math.random() * 1e3),
+      method,
+      params
+    };
+    try {
+      const r = await fetch(this.config.url, {
+        method: "POST",
+        signal: ac.signal,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          ...this.config.token ? { Authorization: `Bearer ${this.config.token}` } : {},
+          "MCP-Protocol-Version": MCP_PROTOCOL_VERSION
+        },
+        body: JSON.stringify(body)
+      });
+      if (!r.ok) {
+        const errText = await r.text().catch(() => "");
+        throw new Error(
+          `mcp http ${r.status} on ${method}: ${errText.slice(0, 200)}`
+        );
+      }
+      const ct = r.headers.get("content-type") || "";
+      if (ct.includes("text/event-stream")) {
+        const text = await r.text();
+        const m = text.match(/data:\s*(\{[\s\S]*?\})\s*\n/);
+        if (!m) throw new Error("mcp sse stream had no data event");
+        const env2 = JSON.parse(m[1]);
+        if (env2.error) throw new Error(`mcp error: ${env2.error.message}`);
+        return env2.result;
+      }
+      const env = await r.json();
+      if (env.error) throw new Error(`mcp error: ${env.error.message}`);
+      return env.result;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+async function collectMcpTools(clients, signal) {
+  const lists = await Promise.all(
+    clients.map(async (c) => {
+      try {
+        return await c.asTools(signal);
+      } catch (err) {
+        console.warn(`[mcp] ${c.config.slug} listTools failed:`, err);
+        return [];
+      }
+    })
+  );
+  return lists.flat();
+}
+
+exports.MCPClient = MCPClient;
+exports.collectMcpTools = collectMcpTools;

package/dist/mcp/index.d.cts

@@ -0,0 +1,69 @@
+import { Tool } from '../tools/index.cjs';
+import 'zod';
+
+interface McpServerConfig {
+    /** Display label ("Linear", "GitHub", ...). */
+    name: string;
+    /** Stable slug used in the namespaced tool name (matches /^[a-z0-9_-]+$/). */
+    slug: string;
+    /** Streamable-HTTP MCP server URL. */
+    url: string;
+    /** Optional bearer token; sent as `Authorization: Bearer <token>`. */
+    token?: string;
+    /** Per-call timeout. Default 12s. */
+    timeout_ms?: number;
+}
+interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+/**
+ * MCPClient — one instance per connected MCP server.
+ *
+ * Example:
+ *   const client = new MCPClient({
+ *     name: "Linear",
+ *     slug: "linear",
+ *     url: "https://mcp.linear.app/sse",
+ *     token: process.env.LINEAR_MCP_TOKEN,
+ *   });
+ *   const tools = await client.asTools();
+ *   // tools[0].schema.name === "linear__create_issue"
+ *   await runner.run(agent, { query: "open a ticket about X", tools });
+ */
+declare class MCPClient {
+    readonly config: McpServerConfig;
+    private initialized;
+    private toolCache;
+    constructor(config: McpServerConfig);
+    /** Fetch the server's tool catalog. Cached for the lifetime of the client. */
+    listTools(signal?: AbortSignal): Promise<McpTool[]>;
+    /** Call a tool by its bare (non-namespaced) name. Returns the text payload. */
+    callTool(name: string, args: unknown, signal?: AbortSignal): Promise<string>;
+    /**
+     * Return the server's tool catalog as SDK Tool[] objects, namespaced so they
+     * compose with tools from other sources without colliding.
+     *
+     * Pass these directly to a Runner. The Runner sees standard SDK tools; it
+     * never has to know MCP existed.
+     */
+    asTools(signal?: AbortSignal): Promise<Tool[]>;
+    /** Health-check: returns toolCount on success, throws on failure. */
+    probe(signal?: AbortSignal): Promise<{
+        toolCount: number;
+    }>;
+    private toSdkTool;
+    private ensureInitialized;
+    private rpc;
+}
+/**
+ * Combine multiple MCP clients into a single namespaced Tool[]. Use when an
+ * agent should see every tool from every connected server in one call.
+ *
+ *   const tools = await collectMcpTools([github, postgres, docker]);
+ *   await runner.run(agent, { query, tools });
+ */
+declare function collectMcpTools(clients: MCPClient[], signal?: AbortSignal): Promise<Tool[]>;
+
+export { MCPClient, type McpServerConfig, type McpTool, collectMcpTools };

package/dist/mcp/index.d.ts

@@ -0,0 +1,69 @@
+import { Tool } from '../tools/index.js';
+import 'zod';
+
+interface McpServerConfig {
+    /** Display label ("Linear", "GitHub", ...). */
+    name: string;
+    /** Stable slug used in the namespaced tool name (matches /^[a-z0-9_-]+$/). */
+    slug: string;
+    /** Streamable-HTTP MCP server URL. */
+    url: string;
+    /** Optional bearer token; sent as `Authorization: Bearer <token>`. */
+    token?: string;
+    /** Per-call timeout. Default 12s. */
+    timeout_ms?: number;
+}
+interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+/**
+ * MCPClient — one instance per connected MCP server.
+ *
+ * Example:
+ *   const client = new MCPClient({
+ *     name: "Linear",
+ *     slug: "linear",
+ *     url: "https://mcp.linear.app/sse",
+ *     token: process.env.LINEAR_MCP_TOKEN,
+ *   });
+ *   const tools = await client.asTools();
+ *   // tools[0].schema.name === "linear__create_issue"
+ *   await runner.run(agent, { query: "open a ticket about X", tools });
+ */
+declare class MCPClient {
+    readonly config: McpServerConfig;
+    private initialized;
+    private toolCache;
+    constructor(config: McpServerConfig);
+    /** Fetch the server's tool catalog. Cached for the lifetime of the client. */
+    listTools(signal?: AbortSignal): Promise<McpTool[]>;
+    /** Call a tool by its bare (non-namespaced) name. Returns the text payload. */
+    callTool(name: string, args: unknown, signal?: AbortSignal): Promise<string>;
+    /**
+     * Return the server's tool catalog as SDK Tool[] objects, namespaced so they
+     * compose with tools from other sources without colliding.
+     *
+     * Pass these directly to a Runner. The Runner sees standard SDK tools; it
+     * never has to know MCP existed.
+     */
+    asTools(signal?: AbortSignal): Promise<Tool[]>;
+    /** Health-check: returns toolCount on success, throws on failure. */
+    probe(signal?: AbortSignal): Promise<{
+        toolCount: number;
+    }>;
+    private toSdkTool;
+    private ensureInitialized;
+    private rpc;
+}
+/**
+ * Combine multiple MCP clients into a single namespaced Tool[]. Use when an
+ * agent should see every tool from every connected server in one call.
+ *
+ *   const tools = await collectMcpTools([github, postgres, docker]);
+ *   await runner.run(agent, { query, tools });
+ */
+declare function collectMcpTools(clients: MCPClient[], signal?: AbortSignal): Promise<Tool[]>;
+
+export { MCPClient, type McpServerConfig, type McpTool, collectMcpTools };

package/dist/mcp/index.js

@@ -0,0 +1,150 @@
+// src/mcp/index.ts
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+var DEFAULT_TIMEOUT_MS = 12e3;
+var MCPClient = class {
+  config;
+  initialized = false;
+  toolCache = null;
+  constructor(config) {
+    if (!/^[a-z0-9_-]+$/.test(config.slug)) {
+      throw new Error(
+        `MCPClient slug "${config.slug}" must match /^[a-z0-9_-]+$/`
+      );
+    }
+    this.config = { timeout_ms: DEFAULT_TIMEOUT_MS, ...config };
+  }
+  /** Fetch the server's tool catalog. Cached for the lifetime of the client. */
+  async listTools(signal) {
+    if (this.toolCache) return this.toolCache;
+    await this.ensureInitialized(signal);
+    const result = await this.rpc("tools/list", {}, signal);
+    this.toolCache = Array.isArray(result?.tools) ? result.tools : [];
+    return this.toolCache;
+  }
+  /** Call a tool by its bare (non-namespaced) name. Returns the text payload. */
+  async callTool(name, args, signal) {
+    await this.ensureInitialized(signal);
+    const result = await this.rpc(
+      "tools/call",
+      { name, arguments: args },
+      signal
+    );
+    const blocks = Array.isArray(result?.content) ? result.content : [];
+    const text = blocks.map((b) => b.type === "text" && typeof b.text === "string" ? b.text : "").filter(Boolean).join("\n").trim();
+    return text || JSON.stringify(result ?? {}).slice(0, 4e3);
+  }
+  /**
+   * Return the server's tool catalog as SDK Tool[] objects, namespaced so they
+   * compose with tools from other sources without colliding.
+   *
+   * Pass these directly to a Runner. The Runner sees standard SDK tools; it
+   * never has to know MCP existed.
+   */
+  async asTools(signal) {
+    const raw = await this.listTools(signal);
+    return raw.map((t) => this.toSdkTool(t));
+  }
+  /** Health-check: returns toolCount on success, throws on failure. */
+  async probe(signal) {
+    const tools = await this.listTools(signal);
+    return { toolCount: tools.length };
+  }
+  // -------------------------------------------------------------- internals
+  toSdkTool(raw) {
+    const ns = `${this.config.slug}__${raw.name}`.slice(0, 64).replace(/[^a-zA-Z0-9_-]/g, "_");
+    const schema = {
+      name: ns,
+      description: `[${this.config.name}] ${raw.description || raw.name}`,
+      input_schema: raw.inputSchema ?? {
+        type: "object",
+        properties: {}
+      }
+    };
+    const client = this;
+    return {
+      schema,
+      async execute(input, _ctx) {
+        return client.callTool(raw.name, input);
+      }
+    };
+  }
+  async ensureInitialized(signal) {
+    if (this.initialized) return;
+    await this.rpc(
+      "initialize",
+      {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: "theron-agent-sdk", version: "0.1" }
+      },
+      signal
+    );
+    this.rpc("notifications/initialized", {}, signal).catch(() => void 0);
+    this.initialized = true;
+  }
+  async rpc(method, params, externalSignal) {
+    const ac = new AbortController();
+    const timer = setTimeout(
+      () => ac.abort(),
+      this.config.timeout_ms ?? DEFAULT_TIMEOUT_MS
+    );
+    if (externalSignal) {
+      if (externalSignal.aborted) ac.abort();
+      else externalSignal.addEventListener("abort", () => ac.abort());
+    }
+    const body = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.floor(Math.random() * 1e3),
+      method,
+      params
+    };
+    try {
+      const r = await fetch(this.config.url, {
+        method: "POST",
+        signal: ac.signal,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          ...this.config.token ? { Authorization: `Bearer ${this.config.token}` } : {},
+          "MCP-Protocol-Version": MCP_PROTOCOL_VERSION
+        },
+        body: JSON.stringify(body)
+      });
+      if (!r.ok) {
+        const errText = await r.text().catch(() => "");
+        throw new Error(
+          `mcp http ${r.status} on ${method}: ${errText.slice(0, 200)}`
+        );
+      }
+      const ct = r.headers.get("content-type") || "";
+      if (ct.includes("text/event-stream")) {
+        const text = await r.text();
+        const m = text.match(/data:\s*(\{[\s\S]*?\})\s*\n/);
+        if (!m) throw new Error("mcp sse stream had no data event");
+        const env2 = JSON.parse(m[1]);
+        if (env2.error) throw new Error(`mcp error: ${env2.error.message}`);
+        return env2.result;
+      }
+      const env = await r.json();
+      if (env.error) throw new Error(`mcp error: ${env.error.message}`);
+      return env.result;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+async function collectMcpTools(clients, signal) {
+  const lists = await Promise.all(
+    clients.map(async (c) => {
+      try {
+        return await c.asTools(signal);
+      } catch (err) {
+        console.warn(`[mcp] ${c.config.slug} listTools failed:`, err);
+        return [];
+      }
+    })
+  );
+  return lists.flat();
+}
+
+export { MCPClient, collectMcpTools };

package/dist/memory/index.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/memory/index.ts
+var Memory = class {
+};
+var InMemoryStore = class extends Memory {
+  records = /* @__PURE__ */ new Map();
+  async set(record) {
+    const id = record.id ?? `mem_${Math.random().toString(36).slice(2)}_${Date.now()}`;
+    const full = {
+      ...record,
+      id,
+      created_at: record.created_at ?? Date.now(),
+      last_accessed_at: record.last_accessed_at ?? Date.now()
+    };
+    this.records.set(id, full);
+    return full;
+  }
+  async get(id) {
+    const r = this.records.get(id);
+    if (r) {
+      r.last_accessed_at = Date.now();
+    }
+    return r;
+  }
+  async query(q) {
+    let results = Array.from(this.records.values());
+    if (q.tenant_id !== void 0) {
+      results = results.filter((r) => r.tenant_id === q.tenant_id);
+    }
+    if (q.key !== void 0) {
+      results = results.filter((r) => r.key === q.key);
+    }
+    if (q.tags !== void 0 && q.tags.length > 0) {
+      results = results.filter((r) => r.tags?.some((t) => q.tags.includes(t)));
+    }
+    if (q.semantic_query !== void 0) {
+      const ql = q.semantic_query.toLowerCase();
+      results = results.filter((r) => r.value.toLowerCase().includes(ql));
+    }
+    results.sort((a, b) => b.last_accessed_at - a.last_accessed_at);
+    if (q.limit !== void 0) {
+      results = results.slice(0, q.limit);
+    }
+    return results;
+  }
+  async delete(id) {
+    this.records.delete(id);
+  }
+};
+
+exports.InMemoryStore = InMemoryStore;
+exports.Memory = Memory;

package/dist/memory/index.d.cts

@@ -0,0 +1,73 @@
+interface MemoryRecord {
+    /** Unique identifier. */
+    id: string;
+    /** Key for retrieval. */
+    key: string;
+    /** The actual content. */
+    value: string;
+    /** Tenant scope (multi-tenant deployments). Always filter on this in
+     *  production — there is no implicit isolation. */
+    tenant_id?: string;
+    /** Optional tags for categorization. */
+    tags?: string[];
+    /** When this memory was created. */
+    created_at: number;
+    /** When this memory was last accessed (for LRU eviction). */
+    last_accessed_at: number;
+    /** Optional embedding for semantic search (1024-dim float32). */
+    embedding?: number[];
+}
+interface MemoryQuery {
+    /** Filter by tenant. */
+    tenant_id?: string;
+    /** Exact key lookup. */
+    key?: string;
+    /** Tag-based filter. */
+    tags?: string[];
+    /** Semantic search by similarity to this query string. */
+    semantic_query?: string;
+    /** Max records to return. */
+    limit?: number;
+}
+/**
+ * Memory — abstract interface; implementations plug in any backend.
+ *
+ * Built-in implementations:
+ *   - InMemoryStore (default; for development)
+ *   - For production, plug in pgvector, R2, SQLite, etc. by extending Memory.
+ *
+ * Minimal usage:
+ *   const mem = new InMemoryStore();
+ *   await mem.set({
+ *     key: "user_name", value: "Annalea",
+ *     created_at: Date.now(), last_accessed_at: Date.now(),
+ *   });
+ *   const records = await mem.query({ key: "user_name" });
+ */
+declare abstract class Memory {
+    abstract set(record: Omit<MemoryRecord, "id"> & {
+        id?: string;
+    }): Promise<MemoryRecord>;
+    abstract get(id: string): Promise<MemoryRecord | undefined>;
+    abstract query(q: MemoryQuery): Promise<MemoryRecord[]>;
+    abstract delete(id: string): Promise<void>;
+}
+/**
+ * InMemoryStore — default Memory implementation. Volatile; for development.
+ * Production should swap in a persistent backend.
+ *
+ * NOTE: this implementation does NOT enforce tenant isolation at the storage
+ * layer — `query({ tenant_id })` filters but does not partition. Production
+ * backends should partition by tenant at the storage layer.
+ */
+declare class InMemoryStore extends Memory {
+    private records;
+    set(record: Omit<MemoryRecord, "id"> & {
+        id?: string;
+    }): Promise<MemoryRecord>;
+    get(id: string): Promise<MemoryRecord | undefined>;
+    query(q: MemoryQuery): Promise<MemoryRecord[]>;
+    delete(id: string): Promise<void>;
+}
+
+export { InMemoryStore, Memory, type MemoryQuery, type MemoryRecord };