@letsping/sdk 0.1.5 → 0.2.0

package/dist/integrations/langgraph.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/integrations/langgraph.ts"],"sourcesContent":["import { BaseCheckpointSaver, Checkpoint, CheckpointMetadata, CheckpointTuple } from \"@langchain/langgraph\";\r\nimport { RunnableConfig } from \"@langchain/core/runnables\";\r\nimport { LetsPing } from \"../index\";\r\n\r\ntype StoredCheckpoint = {\r\n    checkpoint: Checkpoint;\r\n    metadata: CheckpointMetadata;\r\n};\r\n\r\nexport class LetsPingCheckpointer extends BaseCheckpointSaver {\r\n    private checkpoints: Record<string, StoredCheckpoint> = {};\r\n\r\n    constructor(public client: LetsPing) {\r\n        super();\r\n    }\r\n\r\n    private getTransport(): (<T = any>(method: string, path: string, body?: any) => Promise<T>) | null {\r\n        const clientAny = this.client as any;\r\n        if (typeof clientAny.request === \"function\") {\r\n            return clientAny.request.bind(this.client);\r\n        }\r\n        return null;\r\n    }\r\n\r\n    private async saveRemote(\r\n        threadId: string,\r\n        checkpointId: string,\r\n        checkpoint: Checkpoint,\r\n        metadata: CheckpointMetadata\r\n    ): Promise<void> {\r\n        const transport = this.getTransport();\r\n        if (!transport) {\r\n            console.warn(\"[LetsPingCheckpointer] Missing underlying transport; falling back to in-memory only.\");\r\n            return;\r\n        }\r\n        try {\r\n            await transport(\"POST\", \"/langgraph/checkpoints\", {\r\n                thread_id: threadId,\r\n                checkpoint_id: checkpointId,\r\n                checkpoint,\r\n                metadata,\r\n            });\r\n        } catch (e) {\r\n            console.warn(\"[LetsPingCheckpointer] Failed to persist checkpoint remotely; falling back to in-memory only.\", e);\r\n        }\r\n    }\r\n\r\n    private async loadRemote(\r\n        threadId: string,\r\n        checkpointId?: string\r\n    ): Promise<StoredCheckpoint | null> {\r\n        const transport = this.getTransport();\r\n        if (!transport) {\r\n            console.warn(\"[LetsPingCheckpointer] Missing underlying transport; using in-memory checkpoints only.\");\r\n            return null;\r\n        }\r\n        const search = checkpointId\r\n            ? `?thread_id=${encodeURIComponent(threadId)}&checkpoint_id=${encodeURIComponent(checkpointId)}`\r\n            : `?thread_id=${encodeURIComponent(threadId)}&latest=1`;\r\n        try {\r\n            const res = await transport<any>(\"GET\", `/langgraph/checkpoints${search}`);\r\n            if (res && res.checkpoint && res.metadata) {\r\n                return { checkpoint: res.checkpoint as Checkpoint, metadata: res.metadata as CheckpointMetadata };\r\n            }\r\n        } catch (e) {\r\n            // If not found or backend unavailable, fall back to local cache only.\r\n            console.warn(\"[LetsPingCheckpointer] Failed to load remote checkpoint\", e);\r\n        }\r\n        return null;\r\n    }\r\n\r\n    private async deleteRemote(threadId: string): Promise<void> {\r\n        const transport = this.getTransport();\r\n        if (!transport) return;\r\n        const search = `?thread_id=${encodeURIComponent(threadId)}`;\r\n        try {\r\n            await transport(\"DELETE\", `/langgraph/checkpoints${search}`);\r\n        } catch (e) {\r\n            console.warn(\"[LetsPingCheckpointer] Failed to delete remote checkpoints\", e);\r\n        }\r\n    }\r\n\r\n    async put(\r\n        config: RunnableConfig,\r\n        checkpoint: Checkpoint,\r\n        metadata: CheckpointMetadata,\r\n        newVersions?: Record<string, string | number>\r\n    ): Promise<RunnableConfig> {\r\n        const threadId = config.configurable?.thread_id;\r\n        const checkpointId = checkpoint.id;\r\n\r\n        if (!threadId || !checkpointId) {\r\n            return config;\r\n        }\r\n\r\n        this.checkpoints[`${threadId}:${checkpointId}`] = { checkpoint, metadata };\r\n        await this.saveRemote(threadId, checkpointId, checkpoint, metadata);\r\n\r\n        return {\r\n            configurable: {\r\n                thread_id: threadId,\r\n                checkpoint_id: checkpointId,\r\n            },\r\n        };\r\n    }\r\n\r\n    // METHODS REQUIRED BY LANGGRAPH V0.1+\r\n    async putWrites(config: RunnableConfig, writes: any, taskId: string): Promise<void> {\r\n        // No-op for V1: LetsPing focuses on primary state parking, not granular sub-task writes.\r\n    }\r\n\r\n    async deleteThread(threadId: string): Promise<void> {\r\n        for (const key of Object.keys(this.checkpoints)) {\r\n            if (key.startsWith(`${threadId}:`)) {\r\n                delete this.checkpoints[key];\r\n            }\r\n        }\r\n        await this.deleteRemote(threadId);\r\n    }\r\n\r\n    async getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined> {\r\n        const threadId = config.configurable?.thread_id;\r\n        const checkpointId = config.configurable?.checkpoint_id;\r\n        if (!threadId) return undefined;\r\n\r\n        // Prefer remote truth, fall back to local cache.\r\n        const remote = await this.loadRemote(threadId, checkpointId);\r\n        if (remote) {\r\n            return { config, checkpoint: remote.checkpoint, metadata: remote.metadata };\r\n        }\r\n\r\n        if (checkpointId) {\r\n            const match = this.checkpoints[`${threadId}:${checkpointId}`];\r\n            if (match) {\r\n                return { config, checkpoint: match.checkpoint, metadata: match.metadata };\r\n            }\r\n        }\r\n\r\n        let latest: CheckpointTuple | undefined;\r\n        for (const [key, val] of Object.entries(this.checkpoints)) {\r\n            if (key.startsWith(`${threadId}:`)) {\r\n                latest = { config, checkpoint: val.checkpoint, metadata: val.metadata };\r\n            }\r\n        }\r\n        return latest;\r\n    }\r\n\r\n    async *list(config: RunnableConfig, options?: any): AsyncGenerator<CheckpointTuple> {\r\n        const threadId = config.configurable?.thread_id;\r\n        if (!threadId) return;\r\n\r\n        const remoteLatest = await this.loadRemote(threadId);\r\n        if (remoteLatest) {\r\n            yield { config, checkpoint: remoteLatest.checkpoint, metadata: remoteLatest.metadata };\r\n        }\r\n\r\n        for (const [key, val] of Object.entries(this.checkpoints)) {\r\n            if (key.startsWith(`${threadId}:`)) {\r\n                yield { config, checkpoint: val.checkpoint, metadata: val.metadata };\r\n            }\r\n        }\r\n    }\r\n}"],"mappings":"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","names":[]}

package/examples/langgraph-demo.ts

@@ -0,0 +1,80 @@
+import { StateGraph, START } from "@langchain/langgraph";
+import { LetsPing } from "@letsping/sdk";
+import { LetsPingCheckpointer } from "@letsping/sdk/integrations/langgraph";
+
+type DemoState = {
+  thread_id: string;
+  step: "START" | "NEEDS_APPROVAL" | "DONE";
+  amount: number;
+};
+
+const lp = new LetsPing(process.env.LETSPING_API_KEY!);
+const checkpointer = new LetsPingCheckpointer(lp);
+
+// Chain the methods directly off the instantiation
+const builder = new StateGraph<DemoState>({
+  channels: {
+    thread_id: null,
+    step: null,
+    amount: null,
+  },
+})
+  .addNode("charge_step", async (state: DemoState): Promise<DemoState> => {
+    // On the first pass, ask LetsPing for approval and park state.
+    if (state.step === "START") {
+      const decision = await lp.defer({
+        service: "demo-agent",
+        action: "payments:charge",
+        priority: "high",
+        payload: { amount: state.amount },
+        // Persist enough context so the webhook can resume the same thread.
+        state_snapshot: {
+          thread_id: state.thread_id,
+          input: state,
+        },
+      });
+
+      console.log("Queued LetsPing request id:", decision.id);
+
+      return {
+        ...state,
+        step: "NEEDS_APPROVAL",
+      };
+    }
+
+    // After approval + webhook resume, the graph will be invoked again
+    if (state.step === "NEEDS_APPROVAL") {
+      console.log("Approval received. Performing final charge for:", state.amount);
+      return {
+        ...state,
+        step: "DONE",
+      };
+    }
+
+    return state;
+  })
+  // Notice we are chaining addEdge directly after addNode
+  .addEdge(START, "charge_step");
+
+export const demoGraph = builder.compile({ checkpointer });
+
+if (require.main === module) {
+  (async () => {
+    const threadId = `demo-${Date.now()}`;
+    console.log("Starting demo thread:", threadId);
+
+    await demoGraph.invoke(
+      {
+        thread_id: threadId,
+        step: "START",
+        amount: 500,
+      },
+      { configurable: { thread_id: threadId } },
+    );
+
+    console.log("Demo graph invoked. Wait for LetsPing approval, then webhook will resume.");
+  })().catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letsping/sdk",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "Behavioral Firewall and Cryo-Sleep State Parking for Autonomous Agents",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -10,6 +10,11 @@
       "types": "./dist/index.d.ts",
       "require": "./dist/index.js",
       "import": "./dist/index.mjs"
+    },
+    "./integrations/langgraph": {
+      "types": "./dist/integrations/langgraph.d.ts",
+      "require": "./dist/integrations/langgraph.js",
+      "import": "./dist/integrations/langgraph.mjs"
     }
   },
   "scripts": {
@@ -17,22 +22,31 @@
     "dev": "tsup --watch",
     "clean": "rm -rf dist .turbo"
   },
-  "dependencies": {},
   "peerDependencies": {
+    "@langchain/core": ">=0.1.52",
+    "@langchain/langgraph": ">=0.0.1",
     "@opentelemetry/api": "^1.0.0"
   },
   "peerDependenciesMeta": {
     "@opentelemetry/api": {
       "optional": true
+    },
+    "@langchain/langgraph": {
+      "optional": true
+    },
+    "@langchain/core": {
+      "optional": true
     }
   },
   "devDependencies": {
-    "tsup": "^8.0.0",
-    "typescript": "^5.7.2",
+    "@langchain/core": "^1.1.28",
+    "@langchain/langgraph": "^1.1.5",
+    "@opentelemetry/api": "^1.9.0",
     "@types/node": "^22.0.0",
-    "@opentelemetry/api": "^1.9.0"
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.2"
   },
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/index.ts

@@ -1,6 +1,6 @@
 import { createCipheriv, createDecipheriv, randomBytes, createHmac } from "node:crypto";
 
-let SDK_VERSION = "0.1.5";
+let SDK_VERSION = "0.2.0";
 try {
 
     SDK_VERSION = require("../package.json").version;
@@ -37,6 +37,14 @@ export interface RequestOptions {
     timeoutMs?: number;
 
     role?: string;
+
+    /**
+     * Optional distributed tracing identifiers. If provided, these will be
+     * attached to the request envelope so downstream frameworks can stitch
+     * together multi-agent flows.
+     */
+    trace_id?: string;
+    parent_request_id?: string;
 }
 
 export interface Decision {
@@ -222,14 +230,30 @@ export class LetsPing {
             });
         }
 
+        const traceId = options.trace_id;
+        const parentId = options.parent_request_id;
+
+        // Do not mutate caller payload; attach tracing metadata under a reserved key.
+        const basePayload = options.payload || {};
+        const metaKey = "_lp_meta";
+        const existingMeta = (basePayload as any)[metaKey] || {};
+        const enrichedPayload = {
+            ...basePayload,
+            [metaKey]: {
+                ...existingMeta,
+                ...(traceId ? { trace_id: traceId } : {}),
+                ...(parentId ? { parent_request_id: parentId } : {}),
+            },
+        };
+
         try {
             const res = await this.request<{ id: string, uploadUrl?: string, dek?: string }>("POST", "/ingest", {
                 service: options.service,
                 action: options.action,
-                payload: this._encrypt(options.payload),
+                payload: this._encrypt(enrichedPayload),
                 priority: options.priority || "medium",
                 schema: options.schema,
-                metadata: { role: options.role, sdk: "node" }
+                metadata: { role: options.role, sdk: "node", trace_id: traceId, parent_request_id: parentId }
             });
 
             const { id, uploadUrl, dek } = res;
@@ -325,10 +349,28 @@ export class LetsPing {
             });
         }
 
+        const traceId = options.trace_id;
+        const parentId = options.parent_request_id;
+        const basePayload = options.payload || {};
+        const metaKey = "_lp_meta";
+        const existingMeta = (basePayload as any)[metaKey] || {};
+        const enrichedPayload = {
+            ...basePayload,
+            [metaKey]: {
+                ...existingMeta,
+                ...(traceId ? { trace_id: traceId } : {}),
+                ...(parentId ? { parent_request_id: parentId } : {}),
+            },
+        };
+
         try {
             const res = await this.request<{ id: string, uploadUrl?: string, dek?: string }>("POST", "/ingest", {
-                ...options,
-                payload: this._encrypt(options.payload),
+                service: options.service,
+                action: options.action,
+                payload: this._encrypt(enrichedPayload),
+                priority: options.priority || "medium",
+                schema: options.schema,
+                metadata: { role: options.role, sdk: "node", trace_id: traceId, parent_request_id: parentId },
             });
             if (res.uploadUrl && options.state_snapshot) {
                 try {
@@ -436,11 +478,29 @@ export class LetsPing {
         signatureHeader: string,
         webhookSecret: string
     ): Promise<{ id: string; event: string; data: Decision; state_snapshot?: Record<string, any> }> {
-        const hmac = createHmac("sha256", webhookSecret).update(payloadStr).digest("hex");
         const sigParts = signatureHeader.split(",").map(p => p.split("="));
         const sigMap = Object.fromEntries(sigParts);
 
-        if (sigMap["v1"] !== hmac) {
+        const rawTs = sigMap["t"];
+        const rawSig = sigMap["v1"];
+        if (!rawTs || !rawSig) {
+            throw new LetsPingError("LetsPing Error: Missing webhook signature fields", 401);
+        }
+
+        const ts = Number(rawTs);
+        if (!Number.isFinite(ts)) {
+            throw new LetsPingError("LetsPing Error: Invalid webhook timestamp", 401);
+        }
+
+        const now = Date.now();
+        const skewMs = Math.abs(now - ts);
+        const maxSkewMs = 5 * 60 * 1000; // 5 minutes
+        if (skewMs > maxSkewMs) {
+            throw new LetsPingError("LetsPing Error: Webhook replay window exceeded", 401);
+        }
+
+        const expected = createHmac("sha256", webhookSecret).update(payloadStr).digest("hex");
+        if (rawSig !== expected) {
             throw new LetsPingError("LetsPing Error: Invalid webhook signature", 401);
         }
 

package/src/integrations/langgraph.ts

@@ -0,0 +1,163 @@
+import { BaseCheckpointSaver, Checkpoint, CheckpointMetadata, CheckpointTuple } from "@langchain/langgraph";
+import { RunnableConfig } from "@langchain/core/runnables";
+import { LetsPing } from "../index";
+
+type StoredCheckpoint = {
+    checkpoint: Checkpoint;
+    metadata: CheckpointMetadata;
+};
+
+export class LetsPingCheckpointer extends BaseCheckpointSaver {
+    private checkpoints: Record<string, StoredCheckpoint> = {};
+
+    constructor(public client: LetsPing) {
+        super();
+    }
+
+    private getTransport(): (<T = any>(method: string, path: string, body?: any) => Promise<T>) | null {
+        const clientAny = this.client as any;
+        if (typeof clientAny.request === "function") {
+            return clientAny.request.bind(this.client);
+        }
+        return null;
+    }
+
+    private async saveRemote(
+        threadId: string,
+        checkpointId: string,
+        checkpoint: Checkpoint,
+        metadata: CheckpointMetadata
+    ): Promise<void> {
+        const transport = this.getTransport();
+        if (!transport) {
+            console.warn("[LetsPingCheckpointer] Missing underlying transport; falling back to in-memory only.");
+            return;
+        }
+        try {
+            await transport("POST", "/langgraph/checkpoints", {
+                thread_id: threadId,
+                checkpoint_id: checkpointId,
+                checkpoint,
+                metadata,
+            });
+        } catch (e) {
+            console.warn("[LetsPingCheckpointer] Failed to persist checkpoint remotely; falling back to in-memory only.", e);
+        }
+    }
+
+    private async loadRemote(
+        threadId: string,
+        checkpointId?: string
+    ): Promise<StoredCheckpoint | null> {
+        const transport = this.getTransport();
+        if (!transport) {
+            console.warn("[LetsPingCheckpointer] Missing underlying transport; using in-memory checkpoints only.");
+            return null;
+        }
+        const search = checkpointId
+            ? `?thread_id=${encodeURIComponent(threadId)}&checkpoint_id=${encodeURIComponent(checkpointId)}`
+            : `?thread_id=${encodeURIComponent(threadId)}&latest=1`;
+        try {
+            const res = await transport<any>("GET", `/langgraph/checkpoints${search}`);
+            if (res && res.checkpoint && res.metadata) {
+                return { checkpoint: res.checkpoint as Checkpoint, metadata: res.metadata as CheckpointMetadata };
+            }
+        } catch (e) {
+            // If not found or backend unavailable, fall back to local cache only.
+            console.warn("[LetsPingCheckpointer] Failed to load remote checkpoint", e);
+        }
+        return null;
+    }
+
+    private async deleteRemote(threadId: string): Promise<void> {
+        const transport = this.getTransport();
+        if (!transport) return;
+        const search = `?thread_id=${encodeURIComponent(threadId)}`;
+        try {
+            await transport("DELETE", `/langgraph/checkpoints${search}`);
+        } catch (e) {
+            console.warn("[LetsPingCheckpointer] Failed to delete remote checkpoints", e);
+        }
+    }
+
+    async put(
+        config: RunnableConfig,
+        checkpoint: Checkpoint,
+        metadata: CheckpointMetadata,
+        newVersions?: Record<string, string | number>
+    ): Promise<RunnableConfig> {
+        const threadId = config.configurable?.thread_id;
+        const checkpointId = checkpoint.id;
+
+        if (!threadId || !checkpointId) {
+            return config;
+        }
+
+        this.checkpoints[`${threadId}:${checkpointId}`] = { checkpoint, metadata };
+        await this.saveRemote(threadId, checkpointId, checkpoint, metadata);
+
+        return {
+            configurable: {
+                thread_id: threadId,
+                checkpoint_id: checkpointId,
+            },
+        };
+    }
+
+    // METHODS REQUIRED BY LANGGRAPH V0.1+
+    async putWrites(config: RunnableConfig, writes: any, taskId: string): Promise<void> {
+        // No-op for V1: LetsPing focuses on primary state parking, not granular sub-task writes.
+    }
+
+    async deleteThread(threadId: string): Promise<void> {
+        for (const key of Object.keys(this.checkpoints)) {
+            if (key.startsWith(`${threadId}:`)) {
+                delete this.checkpoints[key];
+            }
+        }
+        await this.deleteRemote(threadId);
+    }
+
+    async getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined> {
+        const threadId = config.configurable?.thread_id;
+        const checkpointId = config.configurable?.checkpoint_id;
+        if (!threadId) return undefined;
+
+        // Prefer remote truth, fall back to local cache.
+        const remote = await this.loadRemote(threadId, checkpointId);
+        if (remote) {
+            return { config, checkpoint: remote.checkpoint, metadata: remote.metadata };
+        }
+
+        if (checkpointId) {
+            const match = this.checkpoints[`${threadId}:${checkpointId}`];
+            if (match) {
+                return { config, checkpoint: match.checkpoint, metadata: match.metadata };
+            }
+        }
+
+        let latest: CheckpointTuple | undefined;
+        for (const [key, val] of Object.entries(this.checkpoints)) {
+            if (key.startsWith(`${threadId}:`)) {
+                latest = { config, checkpoint: val.checkpoint, metadata: val.metadata };
+            }
+        }
+        return latest;
+    }
+
+    async *list(config: RunnableConfig, options?: any): AsyncGenerator<CheckpointTuple> {
+        const threadId = config.configurable?.thread_id;
+        if (!threadId) return;
+
+        const remoteLatest = await this.loadRemote(threadId);
+        if (remoteLatest) {
+            yield { config, checkpoint: remoteLatest.checkpoint, metadata: remoteLatest.metadata };
+        }
+
+        for (const [key, val] of Object.entries(this.checkpoints)) {
+            if (key.startsWith(`${threadId}:`)) {
+                yield { config, checkpoint: val.checkpoint, metadata: val.metadata };
+            }
+        }
+    }
+}

package/tsup.config.ts

@@ -1,7 +1,7 @@
 import { defineConfig } from "tsup";
 
 export default defineConfig({
-    entry: ["src/index.ts"],
+    entry: ["src/index.ts", "src/integrations/langgraph.ts"],
     format: ["cjs", "esm"],
     dts: true,
     clean: true,