mneme-sdk 0.0.1

package/README.md

@@ -0,0 +1,89 @@
+# mneme-sdk
+
+TypeScript SDK for **Mneme** — agent-native data layer on Base. Wallet-signed
+requests, opinionated tables built for agents (`memories`, `documents`,
+`events`, `kvs`), pgvector KNN out of the box.
+
+```bash
+bun add mneme-sdk viem
+```
+
+## Quickstart
+
+```ts
+import { privateKeyToAccount } from "viem/accounts";
+import { Mneme } from "mneme-sdk";
+
+const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as `0x${string}`);
+
+const m = new Mneme({
+  account,
+  gatewayUrl: "https://gateway.mnemedb.dev",
+});
+
+// Remember
+await m.memories.insert({
+  text:      "User prefers dark mode and Turkish",
+  embedding: embed("...")   // 1536-dim, your embedder of choice
+});
+
+// Recall by recency
+const { rows } = await m.memories.list({ limit: 20 });
+
+// Recall by meaning (pgvector KNN)
+const { matches } = await m.vectorSearch({
+  table:     "memories",
+  embedding: queryVec,
+  k:         5,
+});
+
+// Key-value store
+await m.kvs.insert({ key: "last_login", value: { at: Date.now() } });
+
+// Append-only event log
+await m.events.insert({ kind: "tool.call", payload: { tool: "search" } });
+```
+
+## Auth
+
+No API keys. Every request is signed by the agent's wallet via EIP-712 typed
+data. The gateway verifies the signature, mints a short-lived Supabase JWT
+with the wallet as `agent_id`, and PostgREST + RLS enforces isolation — every
+agent only sees its own rows.
+
+```ts
+// What gets signed (MnemeRequest typed-data):
+{
+  method:    "POST",
+  path:      "/v1/rows/memories",
+  bodyHash:  keccak256(utf8(requestBody)),
+  timestamp: <unix seconds>,
+  nonce:     <16 random bytes hex>,
+}
+// Domain: { name: "Mneme", version: "1", chainId: 8453 }
+```
+
+## Errors
+
+```ts
+import { MnemeError } from "mneme-sdk";
+
+try {
+  await m.memories.insert({ text: "hi" });
+} catch (e) {
+  if (e instanceof MnemeError) console.error(e.status, e.message);
+}
+```
+
+## Collections
+
+| Collection      | Row shape                                                  |
+|-----------------|------------------------------------------------------------|
+| `m.memories`    | `{ text, embedding?, metadata? }`                          |
+| `m.documents`   | `{ title?, body, embedding?, metadata? }`                  |
+| `m.events`      | `{ kind, payload? }`                                       |
+| `m.kvs`         | `{ key, value }`                                           |
+
+Need a custom table? Edit `gateway/supabase-setup.sql` in the Mneme repo +
+add the table name to `ALLOWED_TABLES` in `gateway/src/db.ts`. Schemas are
+managed at deploy time, not at runtime.

package/dist/index.cjs

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  COLUMN_TYPES: () => COLUMN_TYPES,
+  Collection: () => Collection,
+  DEFAULT_TABLES: () => DEFAULT_TABLES,
+  MNEME_TYPES: () => MNEME_TYPES,
+  Mneme: () => Mneme,
+  MnemeError: () => MnemeError,
+  signRequest: () => signRequest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/sign.ts
+var import_viem = require("viem");
+var MNEME_TYPES = {
+  MnemeRequest: [
+    { name: "method", type: "string" },
+    { name: "path", type: "string" },
+    { name: "bodyHash", type: "bytes32" },
+    { name: "timestamp", type: "uint256" },
+    { name: "nonce", type: "string" }
+  ]
+};
+async function signRequest(p) {
+  const timestamp = Math.floor(Date.now() / 1e3);
+  const nonce = randomNonce();
+  const bodyHash = (0, import_viem.keccak256)((0, import_viem.toBytes)(p.body));
+  if (!p.account.signTypedData) {
+    throw new Error("Account must support signTypedData (use privateKeyToAccount or a viem LocalAccount)");
+  }
+  const signature = await p.account.signTypedData({
+    domain: { name: p.domainName, version: p.domainVersion, chainId: p.chainId },
+    types: MNEME_TYPES,
+    primaryType: "MnemeRequest",
+    message: {
+      method: p.method,
+      path: p.path,
+      bodyHash,
+      timestamp: BigInt(timestamp),
+      nonce
+    }
+  });
+  return {
+    "X-Mneme-Wallet": p.account.address,
+    "X-Mneme-Timestamp": String(timestamp),
+    "X-Mneme-Nonce": nonce,
+    "Authorization": `Mneme ${signature}`
+  };
+}
+function randomNonce() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/client.ts
+var MnemeError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "MnemeError";
+  }
+  status;
+};
+var Mneme = class {
+  auth;
+  gatewayUrl;
+  chainId;
+  domainName;
+  domainVersion;
+  /** Convenience accessors for the four always-on default tables. */
+  memories;
+  documents;
+  events;
+  kvs;
+  constructor(opts) {
+    this.auth = "accessToken" in opts && opts.accessToken ? { accessToken: opts.accessToken } : { account: opts.account };
+    this.gatewayUrl = opts.gatewayUrl.replace(/\/$/, "");
+    this.chainId = opts.chainId ?? 8453;
+    this.domainName = opts.domainName ?? "Mneme";
+    this.domainVersion = opts.domainVersion ?? "1";
+    this.memories = new Collection(this, "memories");
+    this.documents = new Collection(this, "documents");
+    this.events = new Collection(this, "events");
+    this.kvs = new Collection(this, "kvs");
+  }
+  // ─── DDL ──────────────────────────────────────────────────────────────────
+  createTable(args) {
+    return this.request("POST", "/v1/tables", args);
+  }
+  listTables() {
+    return this.request("GET", "/v1/tables");
+  }
+  // ─── Vector & stats ───────────────────────────────────────────────────────
+  vectorSearch(args) {
+    return this.request("POST", "/v1/vector/search", args);
+  }
+  stats() {
+    return this.request("GET", "/v1/stats");
+  }
+  // ─── Generic CRUD against any table the agent owns ───────────────────────
+  from(table) {
+    return new Collection(this, table);
+  }
+  async request(method, path, body) {
+    const bodyText = body === void 0 ? "" : JSON.stringify(body);
+    const headers = { "Content-Type": "application/json" };
+    if ("accessToken" in this.auth && this.auth.accessToken) {
+      headers["Authorization"] = `Bearer ${this.auth.accessToken}`;
+    } else if ("account" in this.auth && this.auth.account) {
+      const signed = await signRequest({
+        account: this.auth.account,
+        chainId: this.chainId,
+        domainName: this.domainName,
+        domainVersion: this.domainVersion,
+        method,
+        path,
+        body: bodyText
+      });
+      Object.assign(headers, signed);
+    } else {
+      throw new Error("Mneme: either { account } or { accessToken } is required");
+    }
+    const res = await fetch(`${this.gatewayUrl}${path}`, {
+      method,
+      headers,
+      body: method === "GET" ? void 0 : bodyText
+    });
+    const json = await res.json().catch(() => ({}));
+    if (!res.ok) throw new MnemeError(res.status, json.error ?? "request failed");
+    return json;
+  }
+};
+var Collection = class {
+  constructor(mneme, table) {
+    this.mneme = mneme;
+    this.table = table;
+  }
+  mneme;
+  table;
+  insert(rows) {
+    return this.mneme.request(
+      "POST",
+      `/v1/rows/${this.table}`,
+      rows
+    );
+  }
+  list(opts) {
+    const q = new URLSearchParams();
+    if (opts?.limit != null) q.set("limit", String(opts.limit));
+    if (opts?.offset != null) q.set("offset", String(opts.offset));
+    if (opts?.order) q.set("order", opts.order);
+    const qs = q.toString() ? `?${q}` : "";
+    return this.mneme.request("GET", `/v1/rows/${this.table}${qs}`);
+  }
+};
+
+// src/types.ts
+var COLUMN_TYPES = [
+  "text",
+  "int",
+  "bigint",
+  "bool",
+  "jsonb",
+  "timestamptz",
+  "vector",
+  "numeric",
+  "uuid",
+  "date"
+];
+var DEFAULT_TABLES = ["memories", "documents", "events", "kvs"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COLUMN_TYPES,
+  Collection,
+  DEFAULT_TABLES,
+  MNEME_TYPES,
+  Mneme,
+  MnemeError,
+  signRequest
+});

package/dist/index.d.cts

@@ -0,0 +1,169 @@
+import { Account } from 'viem';
+
+declare const COLUMN_TYPES: readonly ["text", "int", "bigint", "bool", "jsonb", "timestamptz", "vector", "numeric", "uuid", "date"];
+type ColumnType = (typeof COLUMN_TYPES)[number];
+interface ColumnDef {
+    name: string;
+    type: ColumnType;
+    /** Required when `type === "vector"`. 1–4096. */
+    dim?: number;
+    nullable?: boolean;
+    unique?: boolean;
+    primaryKey?: boolean;
+}
+interface CreateTableArgs {
+    name: string;
+    columns: ColumnDef[];
+}
+interface ColumnInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+}
+interface TableInfo {
+    name: string;
+    isDefault: boolean;
+    rowCount: number;
+    columns: ColumnInfo[];
+}
+interface VectorSearchArgs {
+    table: string;
+    column: string;
+    embedding: number[];
+    k?: number;
+}
+declare const DEFAULT_TABLES: readonly ["memories", "documents", "events", "kvs"];
+type DefaultTable = (typeof DEFAULT_TABLES)[number];
+interface MemoryRow {
+    id?: number;
+    text: string;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+}
+interface DocumentRow {
+    id?: number;
+    title?: string;
+    body: string;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+}
+interface EventRow {
+    id?: number;
+    kind: string;
+    payload?: Record<string, unknown>;
+    created_at?: string;
+}
+interface KvRow {
+    key: string;
+    value: unknown;
+    updated_at?: string;
+}
+
+type MnemeAuth = {
+    account: Account;
+    accessToken?: never;
+} | {
+    accessToken: string;
+    account?: never;
+};
+type MnemeOptions = MnemeAuth & {
+    gatewayUrl: string;
+    chainId?: number;
+    domainName?: string;
+    domainVersion?: string;
+};
+interface StatsResponse {
+    tables: Record<string, number>;
+    totals: {
+        rows: number;
+        default_tables: number;
+        custom_tables: number;
+        vector_searches_today: number;
+        mneme_burned_total: number;
+    };
+}
+declare class MnemeError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+declare class Mneme {
+    private auth;
+    private gatewayUrl;
+    private chainId;
+    private domainName;
+    private domainVersion;
+    /** Convenience accessors for the four always-on default tables. */
+    readonly memories: Collection<MemoryRow>;
+    readonly documents: Collection<DocumentRow>;
+    readonly events: Collection<EventRow>;
+    readonly kvs: Collection<KvRow>;
+    constructor(opts: MnemeOptions);
+    createTable(args: CreateTableArgs): Promise<{
+        ok: true;
+        table: string;
+    }>;
+    listTables(): Promise<{
+        tables: TableInfo[];
+    }>;
+    vectorSearch(args: VectorSearchArgs): Promise<{
+        matches: unknown[];
+    }>;
+    stats(): Promise<StatsResponse>;
+    from<T = unknown>(table: string): Collection<T>;
+    request<T = unknown>(method: string, path: string, body?: unknown): Promise<T>;
+}
+declare class Collection<T = unknown> {
+    private mneme;
+    readonly table: string;
+    constructor(mneme: Mneme, table: string);
+    insert(rows: T | T[]): Promise<{
+        inserted: number;
+        rows: T[];
+    }>;
+    list(opts?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+    }): Promise<{
+        rows: T[];
+    }>;
+}
+
+declare const MNEME_TYPES: {
+    readonly MnemeRequest: readonly [{
+        readonly name: "method";
+        readonly type: "string";
+    }, {
+        readonly name: "path";
+        readonly type: "string";
+    }, {
+        readonly name: "bodyHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "string";
+    }];
+};
+interface SignRequestParams {
+    account: Account;
+    chainId: number;
+    domainName: string;
+    domainVersion: string;
+    method: string;
+    path: string;
+    body: string;
+}
+interface SignedHeaders {
+    "X-Mneme-Wallet": string;
+    "X-Mneme-Timestamp": string;
+    "X-Mneme-Nonce": string;
+    "Authorization": string;
+}
+declare function signRequest(p: SignRequestParams): Promise<SignedHeaders>;
+
+export { COLUMN_TYPES, Collection, type ColumnDef, type ColumnInfo, type ColumnType, type CreateTableArgs, DEFAULT_TABLES, type DefaultTable, type DocumentRow, type EventRow, type KvRow, MNEME_TYPES, type MemoryRow, Mneme, type MnemeAuth, MnemeError, type MnemeOptions, type SignRequestParams, type SignedHeaders, type StatsResponse, type TableInfo, type VectorSearchArgs, signRequest };

package/dist/index.d.ts

@@ -0,0 +1,169 @@
+import { Account } from 'viem';
+
+declare const COLUMN_TYPES: readonly ["text", "int", "bigint", "bool", "jsonb", "timestamptz", "vector", "numeric", "uuid", "date"];
+type ColumnType = (typeof COLUMN_TYPES)[number];
+interface ColumnDef {
+    name: string;
+    type: ColumnType;
+    /** Required when `type === "vector"`. 1–4096. */
+    dim?: number;
+    nullable?: boolean;
+    unique?: boolean;
+    primaryKey?: boolean;
+}
+interface CreateTableArgs {
+    name: string;
+    columns: ColumnDef[];
+}
+interface ColumnInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+}
+interface TableInfo {
+    name: string;
+    isDefault: boolean;
+    rowCount: number;
+    columns: ColumnInfo[];
+}
+interface VectorSearchArgs {
+    table: string;
+    column: string;
+    embedding: number[];
+    k?: number;
+}
+declare const DEFAULT_TABLES: readonly ["memories", "documents", "events", "kvs"];
+type DefaultTable = (typeof DEFAULT_TABLES)[number];
+interface MemoryRow {
+    id?: number;
+    text: string;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+}
+interface DocumentRow {
+    id?: number;
+    title?: string;
+    body: string;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+}
+interface EventRow {
+    id?: number;
+    kind: string;
+    payload?: Record<string, unknown>;
+    created_at?: string;
+}
+interface KvRow {
+    key: string;
+    value: unknown;
+    updated_at?: string;
+}
+
+type MnemeAuth = {
+    account: Account;
+    accessToken?: never;
+} | {
+    accessToken: string;
+    account?: never;
+};
+type MnemeOptions = MnemeAuth & {
+    gatewayUrl: string;
+    chainId?: number;
+    domainName?: string;
+    domainVersion?: string;
+};
+interface StatsResponse {
+    tables: Record<string, number>;
+    totals: {
+        rows: number;
+        default_tables: number;
+        custom_tables: number;
+        vector_searches_today: number;
+        mneme_burned_total: number;
+    };
+}
+declare class MnemeError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+declare class Mneme {
+    private auth;
+    private gatewayUrl;
+    private chainId;
+    private domainName;
+    private domainVersion;
+    /** Convenience accessors for the four always-on default tables. */
+    readonly memories: Collection<MemoryRow>;
+    readonly documents: Collection<DocumentRow>;
+    readonly events: Collection<EventRow>;
+    readonly kvs: Collection<KvRow>;
+    constructor(opts: MnemeOptions);
+    createTable(args: CreateTableArgs): Promise<{
+        ok: true;
+        table: string;
+    }>;
+    listTables(): Promise<{
+        tables: TableInfo[];
+    }>;
+    vectorSearch(args: VectorSearchArgs): Promise<{
+        matches: unknown[];
+    }>;
+    stats(): Promise<StatsResponse>;
+    from<T = unknown>(table: string): Collection<T>;
+    request<T = unknown>(method: string, path: string, body?: unknown): Promise<T>;
+}
+declare class Collection<T = unknown> {
+    private mneme;
+    readonly table: string;
+    constructor(mneme: Mneme, table: string);
+    insert(rows: T | T[]): Promise<{
+        inserted: number;
+        rows: T[];
+    }>;
+    list(opts?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+    }): Promise<{
+        rows: T[];
+    }>;
+}
+
+declare const MNEME_TYPES: {
+    readonly MnemeRequest: readonly [{
+        readonly name: "method";
+        readonly type: "string";
+    }, {
+        readonly name: "path";
+        readonly type: "string";
+    }, {
+        readonly name: "bodyHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "string";
+    }];
+};
+interface SignRequestParams {
+    account: Account;
+    chainId: number;
+    domainName: string;
+    domainVersion: string;
+    method: string;
+    path: string;
+    body: string;
+}
+interface SignedHeaders {
+    "X-Mneme-Wallet": string;
+    "X-Mneme-Timestamp": string;
+    "X-Mneme-Nonce": string;
+    "Authorization": string;
+}
+declare function signRequest(p: SignRequestParams): Promise<SignedHeaders>;
+
+export { COLUMN_TYPES, Collection, type ColumnDef, type ColumnInfo, type ColumnType, type CreateTableArgs, DEFAULT_TABLES, type DefaultTable, type DocumentRow, type EventRow, type KvRow, MNEME_TYPES, type MemoryRow, Mneme, type MnemeAuth, MnemeError, type MnemeOptions, type SignRequestParams, type SignedHeaders, type StatsResponse, type TableInfo, type VectorSearchArgs, signRequest };

package/dist/index.js

@@ -0,0 +1,168 @@
+// src/sign.ts
+import { keccak256, toBytes } from "viem";
+var MNEME_TYPES = {
+  MnemeRequest: [
+    { name: "method", type: "string" },
+    { name: "path", type: "string" },
+    { name: "bodyHash", type: "bytes32" },
+    { name: "timestamp", type: "uint256" },
+    { name: "nonce", type: "string" }
+  ]
+};
+async function signRequest(p) {
+  const timestamp = Math.floor(Date.now() / 1e3);
+  const nonce = randomNonce();
+  const bodyHash = keccak256(toBytes(p.body));
+  if (!p.account.signTypedData) {
+    throw new Error("Account must support signTypedData (use privateKeyToAccount or a viem LocalAccount)");
+  }
+  const signature = await p.account.signTypedData({
+    domain: { name: p.domainName, version: p.domainVersion, chainId: p.chainId },
+    types: MNEME_TYPES,
+    primaryType: "MnemeRequest",
+    message: {
+      method: p.method,
+      path: p.path,
+      bodyHash,
+      timestamp: BigInt(timestamp),
+      nonce
+    }
+  });
+  return {
+    "X-Mneme-Wallet": p.account.address,
+    "X-Mneme-Timestamp": String(timestamp),
+    "X-Mneme-Nonce": nonce,
+    "Authorization": `Mneme ${signature}`
+  };
+}
+function randomNonce() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/client.ts
+var MnemeError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "MnemeError";
+  }
+  status;
+};
+var Mneme = class {
+  auth;
+  gatewayUrl;
+  chainId;
+  domainName;
+  domainVersion;
+  /** Convenience accessors for the four always-on default tables. */
+  memories;
+  documents;
+  events;
+  kvs;
+  constructor(opts) {
+    this.auth = "accessToken" in opts && opts.accessToken ? { accessToken: opts.accessToken } : { account: opts.account };
+    this.gatewayUrl = opts.gatewayUrl.replace(/\/$/, "");
+    this.chainId = opts.chainId ?? 8453;
+    this.domainName = opts.domainName ?? "Mneme";
+    this.domainVersion = opts.domainVersion ?? "1";
+    this.memories = new Collection(this, "memories");
+    this.documents = new Collection(this, "documents");
+    this.events = new Collection(this, "events");
+    this.kvs = new Collection(this, "kvs");
+  }
+  // ─── DDL ──────────────────────────────────────────────────────────────────
+  createTable(args) {
+    return this.request("POST", "/v1/tables", args);
+  }
+  listTables() {
+    return this.request("GET", "/v1/tables");
+  }
+  // ─── Vector & stats ───────────────────────────────────────────────────────
+  vectorSearch(args) {
+    return this.request("POST", "/v1/vector/search", args);
+  }
+  stats() {
+    return this.request("GET", "/v1/stats");
+  }
+  // ─── Generic CRUD against any table the agent owns ───────────────────────
+  from(table) {
+    return new Collection(this, table);
+  }
+  async request(method, path, body) {
+    const bodyText = body === void 0 ? "" : JSON.stringify(body);
+    const headers = { "Content-Type": "application/json" };
+    if ("accessToken" in this.auth && this.auth.accessToken) {
+      headers["Authorization"] = `Bearer ${this.auth.accessToken}`;
+    } else if ("account" in this.auth && this.auth.account) {
+      const signed = await signRequest({
+        account: this.auth.account,
+        chainId: this.chainId,
+        domainName: this.domainName,
+        domainVersion: this.domainVersion,
+        method,
+        path,
+        body: bodyText
+      });
+      Object.assign(headers, signed);
+    } else {
+      throw new Error("Mneme: either { account } or { accessToken } is required");
+    }
+    const res = await fetch(`${this.gatewayUrl}${path}`, {
+      method,
+      headers,
+      body: method === "GET" ? void 0 : bodyText
+    });
+    const json = await res.json().catch(() => ({}));
+    if (!res.ok) throw new MnemeError(res.status, json.error ?? "request failed");
+    return json;
+  }
+};
+var Collection = class {
+  constructor(mneme, table) {
+    this.mneme = mneme;
+    this.table = table;
+  }
+  mneme;
+  table;
+  insert(rows) {
+    return this.mneme.request(
+      "POST",
+      `/v1/rows/${this.table}`,
+      rows
+    );
+  }
+  list(opts) {
+    const q = new URLSearchParams();
+    if (opts?.limit != null) q.set("limit", String(opts.limit));
+    if (opts?.offset != null) q.set("offset", String(opts.offset));
+    if (opts?.order) q.set("order", opts.order);
+    const qs = q.toString() ? `?${q}` : "";
+    return this.mneme.request("GET", `/v1/rows/${this.table}${qs}`);
+  }
+};
+
+// src/types.ts
+var COLUMN_TYPES = [
+  "text",
+  "int",
+  "bigint",
+  "bool",
+  "jsonb",
+  "timestamptz",
+  "vector",
+  "numeric",
+  "uuid",
+  "date"
+];
+var DEFAULT_TABLES = ["memories", "documents", "events", "kvs"];
+export {
+  COLUMN_TYPES,
+  Collection,
+  DEFAULT_TABLES,
+  MNEME_TYPES,
+  Mneme,
+  MnemeError,
+  signRequest
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "mneme-sdk",
+  "version": "0.0.1",
+  "description": "TypeScript SDK for Mneme — agent-native Postgres database platform on Base. Wallet-auth, runtime DDL, pgvector built-in.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types":   "./dist/index.d.ts",
+      "import":  "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build":     "tsup src/index.ts --format esm,cjs --dts --clean",
+    "dev":       "tsup src/index.ts --format esm,cjs --dts --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "mneme",
+    "agent",
+    "database",
+    "postgres",
+    "pgvector",
+    "vector",
+    "base",
+    "wallet",
+    "eip712",
+    "mcp",
+    "ai"
+  ],
+  "license": "MIT",
+  "homepage": "https://mnemedb.dev",
+  "repository": {
+    "type": "git",
+    "url":  "https://github.com/mnemedb/mnemedb.git",
+    "directory": "sdk"
+  },
+  "author": "mnemedb",
+  "peerDependencies": {
+    "viem": "^2.21.0"
+  },
+  "devDependencies": {
+    "tsup":       "^8.0.0",
+    "typescript": "^5.6.0",
+    "viem":       "^2.21.0"
+  }
+}