@sente-labs/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,103 @@
+"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, {
+  Sente: () => Sente,
+  SenteError: () => SenteError
+});
+module.exports = __toCommonJS(index_exports);
+var SenteError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "SenteError";
+  }
+  status;
+  body;
+};
+function qs(o) {
+  const p = new URLSearchParams();
+  for (const [k, v] of Object.entries(o)) if (v !== void 0 && v !== null) p.set(k, String(v));
+  const s = p.toString();
+  return s ? `?${s}` : "";
+}
+var Sente = class {
+  #apiKey;
+  #baseUrl;
+  #fetch;
+  constructor(opts) {
+    this.#apiKey = opts.apiKey;
+    this.#baseUrl = opts.baseUrl ?? "https://api.sente.run";
+    this.#fetch = opts.fetch ?? ((url, init) => fetch(url, init));
+  }
+  async #req(method, path, body) {
+    const res = await this.#fetch(`${this.#baseUrl}${path}`, {
+      method,
+      headers: { authorization: `Bearer ${this.#apiKey}`, "content-type": "application/json" },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new SenteError(res.status, `${method} ${path} \u2192 ${res.status}`, await res.text().catch(() => null));
+    }
+    if (res.status === 204) return void 0;
+    return await res.json();
+  }
+  identities = {
+    create: (input = {}) => this.#req("POST", "/v1/identities", input),
+    get: (id) => this.#req("GET", `/v1/identities/${id}`),
+    list: () => this.#req("GET", "/v1/identities")
+  };
+  messages = {
+    list: (identityId, opts = {}) => this.#req("GET", `/v1/messages${qs({ identityId, ...opts })}`),
+    get: (id) => this.#req("GET", `/v1/messages/${id}`),
+    /** Long-poll for the next matching message; resolves to null on timeout. */
+    waitFor: async (identityId, opts = {}) => await this.#req("GET", `/v1/messages/wait${qs({ identityId, ...opts })}`) ?? null,
+    /**
+     * Continuously yield messages as they arrive (client-side long-poll loop). Break out of the
+     * `for await` to stop. For production, prefer webhooks (push) over this (poll).
+     */
+    stream: (identityId, opts = {}) => {
+      const messages = this.messages;
+      return (async function* () {
+        let since = opts.since;
+        for (; ; ) {
+          const msg = await messages.waitFor(identityId, { since, timeout: opts.timeout ?? 25 });
+          if (msg) {
+            yield msg;
+            since = msg.createdAt;
+          }
+        }
+      })();
+    }
+  };
+  webhooks = {
+    /** Register YOUR endpoint with Sente so it delivers events there (you build/host the endpoint). */
+    register: (input) => this.#req("POST", "/v1/webhooks", input),
+    list: () => this.#req("GET", "/v1/webhooks"),
+    delete: (id) => this.#req("DELETE", `/v1/webhooks/${id}`)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Sente,
+  SenteError
+});

package/dist/index.d.ts

@@ -0,0 +1,81 @@
+export type Identity = {
+    id: string;
+    name: string | null;
+    description?: string | null;
+    email: string;
+    createdAt?: string;
+};
+export type Message = {
+    id: string;
+    identityId: string;
+    direction: "inbound" | "outbound";
+    fromAddr: string;
+    toAddr: string;
+    subject: string | null;
+    parsed?: unknown;
+    annotation?: unknown;
+    createdAt: string;
+};
+export type Webhook = {
+    id: string;
+    url: string;
+    events: string[];
+    identityId: string | null;
+    createdAt?: string;
+};
+export type SenteOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    /** Override the fetch implementation (handy for tests). */
+    fetch?: (url: string, init?: RequestInit) => Promise<Response>;
+};
+export declare class SenteError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, message: string, body: unknown);
+}
+export declare class Sente {
+    #private;
+    constructor(opts: SenteOptions);
+    identities: {
+        create: (input?: {
+            name?: string;
+            description?: string;
+        }) => Promise<Identity>;
+        get: (id: string) => Promise<Identity>;
+        list: () => Promise<Identity[]>;
+    };
+    messages: {
+        list: (identityId: string, opts?: {
+            since?: string;
+            direction?: "inbound" | "outbound";
+            limit?: number;
+        }) => Promise<Message[]>;
+        get: (id: string) => Promise<Message>;
+        /** Long-poll for the next matching message; resolves to null on timeout. */
+        waitFor: (identityId: string, opts?: {
+            since?: string;
+            timeout?: number;
+        }) => Promise<Message | null>;
+        /**
+         * Continuously yield messages as they arrive (client-side long-poll loop). Break out of the
+         * `for await` to stop. For production, prefer webhooks (push) over this (poll).
+         */
+        stream: (identityId: string, opts?: {
+            since?: string;
+            timeout?: number;
+        }) => AsyncGenerator<Message>;
+    };
+    webhooks: {
+        /** Register YOUR endpoint with Sente so it delivers events there (you build/host the endpoint). */
+        register: (input: {
+            url: string;
+            events: string[];
+            identityId?: string;
+        }) => Promise<Webhook & {
+            secret: string;
+        }>;
+        list: () => Promise<Webhook[]>;
+        delete: (id: string) => Promise<void>;
+    };
+}

package/dist/index.js

@@ -0,0 +1,77 @@
+// src/index.ts
+var SenteError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "SenteError";
+  }
+  status;
+  body;
+};
+function qs(o) {
+  const p = new URLSearchParams();
+  for (const [k, v] of Object.entries(o)) if (v !== void 0 && v !== null) p.set(k, String(v));
+  const s = p.toString();
+  return s ? `?${s}` : "";
+}
+var Sente = class {
+  #apiKey;
+  #baseUrl;
+  #fetch;
+  constructor(opts) {
+    this.#apiKey = opts.apiKey;
+    this.#baseUrl = opts.baseUrl ?? "https://api.sente.run";
+    this.#fetch = opts.fetch ?? ((url, init) => fetch(url, init));
+  }
+  async #req(method, path, body) {
+    const res = await this.#fetch(`${this.#baseUrl}${path}`, {
+      method,
+      headers: { authorization: `Bearer ${this.#apiKey}`, "content-type": "application/json" },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new SenteError(res.status, `${method} ${path} \u2192 ${res.status}`, await res.text().catch(() => null));
+    }
+    if (res.status === 204) return void 0;
+    return await res.json();
+  }
+  identities = {
+    create: (input = {}) => this.#req("POST", "/v1/identities", input),
+    get: (id) => this.#req("GET", `/v1/identities/${id}`),
+    list: () => this.#req("GET", "/v1/identities")
+  };
+  messages = {
+    list: (identityId, opts = {}) => this.#req("GET", `/v1/messages${qs({ identityId, ...opts })}`),
+    get: (id) => this.#req("GET", `/v1/messages/${id}`),
+    /** Long-poll for the next matching message; resolves to null on timeout. */
+    waitFor: async (identityId, opts = {}) => await this.#req("GET", `/v1/messages/wait${qs({ identityId, ...opts })}`) ?? null,
+    /**
+     * Continuously yield messages as they arrive (client-side long-poll loop). Break out of the
+     * `for await` to stop. For production, prefer webhooks (push) over this (poll).
+     */
+    stream: (identityId, opts = {}) => {
+      const messages = this.messages;
+      return (async function* () {
+        let since = opts.since;
+        for (; ; ) {
+          const msg = await messages.waitFor(identityId, { since, timeout: opts.timeout ?? 25 });
+          if (msg) {
+            yield msg;
+            since = msg.createdAt;
+          }
+        }
+      })();
+    }
+  };
+  webhooks = {
+    /** Register YOUR endpoint with Sente so it delivers events there (you build/host the endpoint). */
+    register: (input) => this.#req("POST", "/v1/webhooks", input),
+    list: () => this.#req("GET", "/v1/webhooks"),
+    delete: (id) => this.#req("DELETE", `/v1/webhooks/${id}`)
+  };
+};
+export {
+  Sente,
+  SenteError
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@sente-labs/sdk",
+  "version": "0.1.0",
+  "description": "Typed client for the Sente API — managed email identities for AI agents.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shim2k/sente-labs.git",
+    "directory": "sente/packages/sdk"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "tsup": "^8.0.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9",
+    "app": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --clean && tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}