@letsping/adapters 0.1.0

package/dist/langchain.d.mts

@@ -0,0 +1,19 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+interface AdapterOptions<T extends z.ZodType> {
+    name: string;
+    description: string;
+    schema: T;
+    apiKey: string;
+    service?: string;
+    priority?: "low" | "medium" | "high" | "critical";
+    timeout?: number;
+}
+/**
+ * Creates a LangChain Tool that pauses execution for human approval.
+ * Compatible with LangGraph and standard Agents.
+ */
+declare function createLetsPingTool<T extends z.ZodType>(options: AdapterOptions<T>): DynamicStructuredTool<any>;
+
+export { createLetsPingTool };

package/dist/langchain.d.ts

@@ -0,0 +1,19 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+interface AdapterOptions<T extends z.ZodType> {
+    name: string;
+    description: string;
+    schema: T;
+    apiKey: string;
+    service?: string;
+    priority?: "low" | "medium" | "high" | "critical";
+    timeout?: number;
+}
+/**
+ * Creates a LangChain Tool that pauses execution for human approval.
+ * Compatible with LangGraph and standard Agents.
+ */
+declare function createLetsPingTool<T extends z.ZodType>(options: AdapterOptions<T>): DynamicStructuredTool<any>;
+
+export { createLetsPingTool };

package/dist/langchain.js

@@ -0,0 +1,73 @@
+"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/langchain.ts
+var langchain_exports = {};
+__export(langchain_exports, {
+  createLetsPingTool: () => createLetsPingTool
+});
+module.exports = __toCommonJS(langchain_exports);
+var import_tools = require("@langchain/core/tools");
+var import_sdk = require("@letsping/sdk");
+function createLetsPingTool(options) {
+  if (!options.apiKey) {
+    throw new Error("LetsPing Adapter Error: 'apiKey' is required.");
+  }
+  const lp = new import_sdk.LetsPing(options.apiKey);
+  return new import_tools.DynamicStructuredTool({
+    name: options.name,
+    description: `${options.description} [SYSTEM NOTE: This tool pauses execution until a human approves the request via LetsPing. Do not expect an immediate result.]`,
+    schema: options.schema,
+    func: async (args) => {
+      try {
+        const decision = await lp.ask({
+          service: options.service || "langchain-agent",
+          action: options.name,
+          priority: options.priority || "medium",
+          payload: args,
+          schema: options.schema,
+          timeoutMs: options.timeout
+        });
+        if (decision.status === "REJECTED") {
+          return JSON.stringify({
+            status: "REJECTED",
+            message: "The human operator denied this request. Do not proceed with the action.",
+            metadata: decision.metadata
+          });
+        }
+        return JSON.stringify({
+          status: "APPROVED",
+          approved_input: decision.patched_payload || decision.payload,
+          metadata: decision.metadata
+        });
+      } catch (error) {
+        return JSON.stringify({
+          status: "ERROR",
+          error: error.message || "Unknown error during LetsPing approval process",
+          suggestion: "Inform the user that the request for approval failed or timed out."
+        });
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLetsPingTool
+});
+//# sourceMappingURL=langchain.js.map

package/dist/langchain.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/langchain.ts"],"sourcesContent":["import { DynamicStructuredTool } from \"@langchain/core/tools\";\r\nimport { LetsPing } from \"@letsping/sdk\";\r\nimport { z } from \"zod\";\r\n\r\ninterface AdapterOptions<T extends z.ZodType> {\r\n    name: string;\r\n    description: string;\r\n    schema: T;\r\n    apiKey: string;\r\n    service?: string;\r\n    priority?: \"low\" | \"medium\" | \"high\" | \"critical\";\r\n    timeout?: number;\r\n}\r\n\r\n/**\r\n * Creates a LangChain Tool that pauses execution for human approval.\r\n * Compatible with LangGraph and standard Agents.\r\n */\r\nexport function createLetsPingTool<T extends z.ZodType>(options: AdapterOptions<T>) {\r\n    if (!options.apiKey) {\r\n        throw new Error(\"LetsPing Adapter Error: 'apiKey' is required.\");\r\n    }\r\n\r\n    const lp = new LetsPing(options.apiKey);\r\n\r\n    return new DynamicStructuredTool({\r\n        name: options.name,\r\n        description: `${options.description} [SYSTEM NOTE: This tool pauses execution until a human approves the request via LetsPing. Do not expect an immediate result.]`,\r\n        schema: options.schema as any,\r\n        func: async (args: any) => {\r\n            try {\r\n                const decision = await lp.ask({\r\n                    service: options.service || \"langchain-agent\",\r\n                    action: options.name,\r\n                    priority: options.priority || \"medium\",\r\n                    payload: args,\r\n                    schema: options.schema,\r\n                    timeoutMs: options.timeout\r\n                });\r\n\r\n                if (decision.status === \"REJECTED\") {\r\n                    return JSON.stringify({\r\n                        status: \"REJECTED\",\r\n                        message: \"The human operator denied this request. Do not proceed with the action.\",\r\n                        metadata: decision.metadata\r\n                    });\r\n                }\r\n\r\n                return JSON.stringify({\r\n                    status: \"APPROVED\",\r\n                    approved_input: decision.patched_payload || decision.payload,\r\n                    metadata: decision.metadata\r\n                });\r\n\r\n            } catch (error: any) {\r\n                return JSON.stringify({\r\n                    status: \"ERROR\",\r\n                    error: error.message || \"Unknown error during LetsPing approval process\",\r\n                    suggestion: \"Inform the user that the request for approval failed or timed out.\"\r\n                });\r\n            }\r\n        }\r\n    });\r\n}"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAsC;AACtC,iBAAyB;AAiBlB,SAAS,mBAAwC,SAA4B;AAChF,MAAI,CAAC,QAAQ,QAAQ;AACjB,UAAM,IAAI,MAAM,+CAA+C;AAAA,EACnE;AAEA,QAAM,KAAK,IAAI,oBAAS,QAAQ,MAAM;AAEtC,SAAO,IAAI,mCAAsB;AAAA,IAC7B,MAAM,QAAQ;AAAA,IACd,aAAa,GAAG,QAAQ,WAAW;AAAA,IACnC,QAAQ,QAAQ;AAAA,IAChB,MAAM,OAAO,SAAc;AACvB,UAAI;AACA,cAAM,WAAW,MAAM,GAAG,IAAI;AAAA,UAC1B,SAAS,QAAQ,WAAW;AAAA,UAC5B,QAAQ,QAAQ;AAAA,UAChB,UAAU,QAAQ,YAAY;AAAA,UAC9B,SAAS;AAAA,UACT,QAAQ,QAAQ;AAAA,UAChB,WAAW,QAAQ;AAAA,QACvB,CAAC;AAED,YAAI,SAAS,WAAW,YAAY;AAChC,iBAAO,KAAK,UAAU;AAAA,YAClB,QAAQ;AAAA,YACR,SAAS;AAAA,YACT,UAAU,SAAS;AAAA,UACvB,CAAC;AAAA,QACL;AAEA,eAAO,KAAK,UAAU;AAAA,UAClB,QAAQ;AAAA,UACR,gBAAgB,SAAS,mBAAmB,SAAS;AAAA,UACrD,UAAU,SAAS;AAAA,QACvB,CAAC;AAAA,MAEL,SAAS,OAAY;AACjB,eAAO,KAAK,UAAU;AAAA,UAClB,QAAQ;AAAA,UACR,OAAO,MAAM,WAAW;AAAA,UACxB,YAAY;AAAA,QAChB,CAAC;AAAA,MACL;AAAA,IACJ;AAAA,EACJ,CAAC;AACL;","names":[]}

package/dist/langchain.mjs

@@ -0,0 +1,48 @@
+// src/langchain.ts
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { LetsPing } from "@letsping/sdk";
+function createLetsPingTool(options) {
+  if (!options.apiKey) {
+    throw new Error("LetsPing Adapter Error: 'apiKey' is required.");
+  }
+  const lp = new LetsPing(options.apiKey);
+  return new DynamicStructuredTool({
+    name: options.name,
+    description: `${options.description} [SYSTEM NOTE: This tool pauses execution until a human approves the request via LetsPing. Do not expect an immediate result.]`,
+    schema: options.schema,
+    func: async (args) => {
+      try {
+        const decision = await lp.ask({
+          service: options.service || "langchain-agent",
+          action: options.name,
+          priority: options.priority || "medium",
+          payload: args,
+          schema: options.schema,
+          timeoutMs: options.timeout
+        });
+        if (decision.status === "REJECTED") {
+          return JSON.stringify({
+            status: "REJECTED",
+            message: "The human operator denied this request. Do not proceed with the action.",
+            metadata: decision.metadata
+          });
+        }
+        return JSON.stringify({
+          status: "APPROVED",
+          approved_input: decision.patched_payload || decision.payload,
+          metadata: decision.metadata
+        });
+      } catch (error) {
+        return JSON.stringify({
+          status: "ERROR",
+          error: error.message || "Unknown error during LetsPing approval process",
+          suggestion: "Inform the user that the request for approval failed or timed out."
+        });
+      }
+    }
+  });
+}
+export {
+  createLetsPingTool
+};
+//# sourceMappingURL=langchain.mjs.map

package/dist/langchain.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/langchain.ts"],"sourcesContent":["import { DynamicStructuredTool } from \"@langchain/core/tools\";\r\nimport { LetsPing } from \"@letsping/sdk\";\r\nimport { z } from \"zod\";\r\n\r\ninterface AdapterOptions<T extends z.ZodType> {\r\n    name: string;\r\n    description: string;\r\n    schema: T;\r\n    apiKey: string;\r\n    service?: string;\r\n    priority?: \"low\" | \"medium\" | \"high\" | \"critical\";\r\n    timeout?: number;\r\n}\r\n\r\n/**\r\n * Creates a LangChain Tool that pauses execution for human approval.\r\n * Compatible with LangGraph and standard Agents.\r\n */\r\nexport function createLetsPingTool<T extends z.ZodType>(options: AdapterOptions<T>) {\r\n    if (!options.apiKey) {\r\n        throw new Error(\"LetsPing Adapter Error: 'apiKey' is required.\");\r\n    }\r\n\r\n    const lp = new LetsPing(options.apiKey);\r\n\r\n    return new DynamicStructuredTool({\r\n        name: options.name,\r\n        description: `${options.description} [SYSTEM NOTE: This tool pauses execution until a human approves the request via LetsPing. Do not expect an immediate result.]`,\r\n        schema: options.schema as any,\r\n        func: async (args: any) => {\r\n            try {\r\n                const decision = await lp.ask({\r\n                    service: options.service || \"langchain-agent\",\r\n                    action: options.name,\r\n                    priority: options.priority || \"medium\",\r\n                    payload: args,\r\n                    schema: options.schema,\r\n                    timeoutMs: options.timeout\r\n                });\r\n\r\n                if (decision.status === \"REJECTED\") {\r\n                    return JSON.stringify({\r\n                        status: \"REJECTED\",\r\n                        message: \"The human operator denied this request. Do not proceed with the action.\",\r\n                        metadata: decision.metadata\r\n                    });\r\n                }\r\n\r\n                return JSON.stringify({\r\n                    status: \"APPROVED\",\r\n                    approved_input: decision.patched_payload || decision.payload,\r\n                    metadata: decision.metadata\r\n                });\r\n\r\n            } catch (error: any) {\r\n                return JSON.stringify({\r\n                    status: \"ERROR\",\r\n                    error: error.message || \"Unknown error during LetsPing approval process\",\r\n                    suggestion: \"Inform the user that the request for approval failed or timed out.\"\r\n                });\r\n            }\r\n        }\r\n    });\r\n}"],"mappings":";AAAA,SAAS,6BAA6B;AACtC,SAAS,gBAAgB;AAiBlB,SAAS,mBAAwC,SAA4B;AAChF,MAAI,CAAC,QAAQ,QAAQ;AACjB,UAAM,IAAI,MAAM,+CAA+C;AAAA,EACnE;AAEA,QAAM,KAAK,IAAI,SAAS,QAAQ,MAAM;AAEtC,SAAO,IAAI,sBAAsB;AAAA,IAC7B,MAAM,QAAQ;AAAA,IACd,aAAa,GAAG,QAAQ,WAAW;AAAA,IACnC,QAAQ,QAAQ;AAAA,IAChB,MAAM,OAAO,SAAc;AACvB,UAAI;AACA,cAAM,WAAW,MAAM,GAAG,IAAI;AAAA,UAC1B,SAAS,QAAQ,WAAW;AAAA,UAC5B,QAAQ,QAAQ;AAAA,UAChB,UAAU,QAAQ,YAAY;AAAA,UAC9B,SAAS;AAAA,UACT,QAAQ,QAAQ;AAAA,UAChB,WAAW,QAAQ;AAAA,QACvB,CAAC;AAED,YAAI,SAAS,WAAW,YAAY;AAChC,iBAAO,KAAK,UAAU;AAAA,YAClB,QAAQ;AAAA,YACR,SAAS;AAAA,YACT,UAAU,SAAS;AAAA,UACvB,CAAC;AAAA,QACL;AAEA,eAAO,KAAK,UAAU;AAAA,UAClB,QAAQ;AAAA,UACR,gBAAgB,SAAS,mBAAmB,SAAS;AAAA,UACrD,UAAU,SAAS;AAAA,QACvB,CAAC;AAAA,MAEL,SAAS,OAAY;AACjB,eAAO,KAAK,UAAU;AAAA,UAClB,QAAQ;AAAA,UACR,OAAO,MAAM,WAAW;AAAA,UACxB,YAAY;AAAA,QAChB,CAAC;AAAA,MACL;AAAA,IACJ;AAAA,EACJ,CAAC;AACL;","names":[]}

package/dist/vercel.d.mts

@@ -0,0 +1,101 @@
+import * as ai from 'ai';
+import { z } from 'zod';
+
+interface AdapterOptions<T extends z.ZodType> {
+    name: string;
+    description: string;
+    schema: T;
+    apiKey: string;
+    service?: string;
+    priority?: "low" | "medium" | "high" | "critical";
+    timeout?: number;
+}
+/**
+ * Creates a Vercel AI SDK Tool that pauses execution for human approval.
+ * @example
+ * const tools = {
+ * refund: letsPing({
+ * name: "refund_user",
+ * description: "Refund a user transaction",
+ * schema: z.object({ amount: z.number() }),
+ * apiKey: process.env.LETSPING_API_KEY!
+ * })
+ * }
+ */
+declare function letsPing<T extends z.ZodType>(options: AdapterOptions<T>): ai.CoreTool<T, {
+    status: string;
+    message: string;
+    metadata: {
+        resolved_at: string;
+        actor_id: string;
+        method?: string;
+    } | undefined;
+    rejection_reason: any;
+    original_input?: undefined;
+    approved_input?: undefined;
+    error?: undefined;
+    suggestion?: undefined;
+} | {
+    status: string;
+    original_input: T extends ai.Schema<any> ? T["_type"] : T extends z.ZodTypeAny ? z.TypeOf<T> : never;
+    approved_input: any;
+    metadata: {
+        resolved_at: string;
+        actor_id: string;
+        method?: string;
+    } | undefined;
+    message?: undefined;
+    rejection_reason?: undefined;
+    error?: undefined;
+    suggestion?: undefined;
+} | {
+    status: string;
+    error: any;
+    suggestion: string;
+    message?: undefined;
+    metadata?: undefined;
+    rejection_reason?: undefined;
+    original_input?: undefined;
+    approved_input?: undefined;
+}> & {
+    execute: (args: T extends ai.Schema<any> ? T["_type"] : T extends z.ZodTypeAny ? z.TypeOf<T> : never, options: {
+        abortSignal?: AbortSignal;
+    }) => PromiseLike<{
+        status: string;
+        message: string;
+        metadata: {
+            resolved_at: string;
+            actor_id: string;
+            method?: string;
+        } | undefined;
+        rejection_reason: any;
+        original_input?: undefined;
+        approved_input?: undefined;
+        error?: undefined;
+        suggestion?: undefined;
+    } | {
+        status: string;
+        original_input: T extends ai.Schema<any> ? T["_type"] : T extends z.ZodTypeAny ? z.TypeOf<T> : never;
+        approved_input: any;
+        metadata: {
+            resolved_at: string;
+            actor_id: string;
+            method?: string;
+        } | undefined;
+        message?: undefined;
+        rejection_reason?: undefined;
+        error?: undefined;
+        suggestion?: undefined;
+    } | {
+        status: string;
+        error: any;
+        suggestion: string;
+        message?: undefined;
+        metadata?: undefined;
+        rejection_reason?: undefined;
+        original_input?: undefined;
+        approved_input?: undefined;
+    }>;
+};
+
+export { letsPing };

package/dist/vercel.d.ts

@@ -0,0 +1,101 @@
+import * as ai from 'ai';
+import { z } from 'zod';
+
+interface AdapterOptions<T extends z.ZodType> {
+    name: string;
+    description: string;
+    schema: T;
+    apiKey: string;
+    service?: string;
+    priority?: "low" | "medium" | "high" | "critical";
+    timeout?: number;
+}
+/**
+ * Creates a Vercel AI SDK Tool that pauses execution for human approval.
+ * @example
+ * const tools = {
+ * refund: letsPing({
+ * name: "refund_user",
+ * description: "Refund a user transaction",
+ * schema: z.object({ amount: z.number() }),
+ * apiKey: process.env.LETSPING_API_KEY!
+ * })
+ * }
+ */
+declare function letsPing<T extends z.ZodType>(options: AdapterOptions<T>): ai.CoreTool<T, {
+    status: string;
+    message: string;
+    metadata: {
+        resolved_at: string;
+        actor_id: string;
+        method?: string;
+    } | undefined;
+    rejection_reason: any;
+    original_input?: undefined;
+    approved_input?: undefined;
+    error?: undefined;
+    suggestion?: undefined;
+} | {
+    status: string;
+    original_input: T extends ai.Schema<any> ? T["_type"] : T extends z.ZodTypeAny ? z.TypeOf<T> : never;
+    approved_input: any;
+    metadata: {
+        resolved_at: string;
+        actor_id: string;
+        method?: string;
+    } | undefined;
+    message?: undefined;
+    rejection_reason?: undefined;
+    error?: undefined;
+    suggestion?: undefined;
+} | {
+    status: string;
+    error: any;
+    suggestion: string;
+    message?: undefined;
+    metadata?: undefined;
+    rejection_reason?: undefined;
+    original_input?: undefined;
+    approved_input?: undefined;
+}> & {
+    execute: (args: T extends ai.Schema<any> ? T["_type"] : T extends z.ZodTypeAny ? z.TypeOf<T> : never, options: {
+        abortSignal?: AbortSignal;
+    }) => PromiseLike<{
+        status: string;
+        message: string;
+        metadata: {
+            resolved_at: string;
+            actor_id: string;
+            method?: string;
+        } | undefined;
+        rejection_reason: any;
+        original_input?: undefined;
+        approved_input?: undefined;
+        error?: undefined;
+        suggestion?: undefined;
+    } | {
+        status: string;
+        original_input: T extends ai.Schema<any> ? T["_type"] : T extends z.ZodTypeAny ? z.TypeOf<T> : never;
+        approved_input: any;
+        metadata: {
+            resolved_at: string;
+            actor_id: string;
+            method?: string;
+        } | undefined;
+        message?: undefined;
+        rejection_reason?: undefined;
+        error?: undefined;
+        suggestion?: undefined;
+    } | {
+        status: string;
+        error: any;
+        suggestion: string;
+        message?: undefined;
+        metadata?: undefined;
+        rejection_reason?: undefined;
+        original_input?: undefined;
+        approved_input?: undefined;
+    }>;
+};
+
+export { letsPing };

package/dist/vercel.js

@@ -0,0 +1,74 @@
+"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/vercel.ts
+var vercel_exports = {};
+__export(vercel_exports, {
+  letsPing: () => letsPing
+});
+module.exports = __toCommonJS(vercel_exports);
+var import_ai = require("ai");
+var import_sdk = require("@letsping/sdk");
+function letsPing(options) {
+  if (!options.apiKey) {
+    throw new Error("LetsPing Adapter Error: 'apiKey' is required.");
+  }
+  const lp = new import_sdk.LetsPing(options.apiKey);
+  return (0, import_ai.tool)({
+    description: `${options.description} [SYSTEM NOTE: This tool pauses execution to wait for human approval. Do not expect an immediate result.]`,
+    parameters: options.schema,
+    execute: async (args) => {
+      try {
+        const decision = await lp.ask({
+          service: options.service || "vercel-ai-sdk",
+          action: options.name,
+          priority: options.priority || "medium",
+          payload: args,
+          schema: options.schema,
+          timeoutMs: options.timeout
+        });
+        if (decision.status === "REJECTED") {
+          return {
+            status: "REJECTED",
+            message: "The human operator explicitly denied this action. Do not proceed.",
+            metadata: decision.metadata,
+            rejection_reason: decision.rejection_reason || "No reason provided"
+          };
+        }
+        return {
+          status: "APPROVED",
+          original_input: args,
+          approved_input: decision.patched_payload || decision.payload,
+          metadata: decision.metadata
+        };
+      } catch (error) {
+        return {
+          status: "ERROR",
+          error: error.message || "Control plane unreachable or request timed out.",
+          suggestion: "Inform the user that the request for approval failed."
+        };
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  letsPing
+});
+//# sourceMappingURL=vercel.js.map

package/dist/vercel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vercel.ts"],"sourcesContent":["import { tool as createVercelTool } from \"ai\";\r\nimport { LetsPing } from \"@letsping/sdk\";\r\nimport { z } from \"zod\";\r\n\r\ninterface AdapterOptions<T extends z.ZodType> {\r\n    name: string;\r\n    description: string;\r\n    schema: T;\r\n    apiKey: string;\r\n    service?: string;\r\n    priority?: \"low\" | \"medium\" | \"high\" | \"critical\";\r\n    timeout?: number;\r\n}\r\n\r\n/**\r\n * Creates a Vercel AI SDK Tool that pauses execution for human approval.\r\n * @example\r\n * const tools = {\r\n * refund: letsPing({\r\n * name: \"refund_user\",\r\n * description: \"Refund a user transaction\",\r\n * schema: z.object({ amount: z.number() }),\r\n * apiKey: process.env.LETSPING_API_KEY!\r\n * })\r\n * }\r\n */\r\nexport function letsPing<T extends z.ZodType>(options: AdapterOptions<T>) {\r\n    if (!options.apiKey) {\r\n        throw new Error(\"LetsPing Adapter Error: 'apiKey' is required.\");\r\n    }\r\n\r\n    const lp = new LetsPing(options.apiKey);\r\n\r\n    return createVercelTool({\r\n        description: `${options.description} [SYSTEM NOTE: This tool pauses execution to wait for human approval. Do not expect an immediate result.]`,\r\n        parameters: options.schema,\r\n        execute: async (args) => {\r\n            try {\r\n                const decision = await lp.ask({\r\n                    service: options.service || \"vercel-ai-sdk\",\r\n                    action: options.name,\r\n                    priority: options.priority || \"medium\",\r\n                    payload: args,\r\n                    schema: options.schema,\r\n                    timeoutMs: options.timeout\r\n                });\r\n\r\n                if (decision.status === \"REJECTED\") {\r\n                    return {\r\n                        status: \"REJECTED\",\r\n                        message: \"The human operator explicitly denied this action. Do not proceed.\",\r\n                        metadata: decision.metadata,\r\n                        rejection_reason: (decision as any).rejection_reason || \"No reason provided\"\r\n                    };\r\n                }\r\n\r\n                return {\r\n                    status: \"APPROVED\",\r\n                    original_input: args,\r\n                    approved_input: decision.patched_payload || decision.payload,\r\n                    metadata: decision.metadata\r\n                };\r\n\r\n            } catch (error: any) {\r\n                return {\r\n                    status: \"ERROR\",\r\n                    error: error.message || \"Control plane unreachable or request timed out.\",\r\n                    suggestion: \"Inform the user that the request for approval failed.\"\r\n                };\r\n            }\r\n        },\r\n    });\r\n}"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAyC;AACzC,iBAAyB;AAyBlB,SAAS,SAA8B,SAA4B;AACtE,MAAI,CAAC,QAAQ,QAAQ;AACjB,UAAM,IAAI,MAAM,+CAA+C;AAAA,EACnE;AAEA,QAAM,KAAK,IAAI,oBAAS,QAAQ,MAAM;AAEtC,aAAO,UAAAA,MAAiB;AAAA,IACpB,aAAa,GAAG,QAAQ,WAAW;AAAA,IACnC,YAAY,QAAQ;AAAA,IACpB,SAAS,OAAO,SAAS;AACrB,UAAI;AACA,cAAM,WAAW,MAAM,GAAG,IAAI;AAAA,UAC1B,SAAS,QAAQ,WAAW;AAAA,UAC5B,QAAQ,QAAQ;AAAA,UAChB,UAAU,QAAQ,YAAY;AAAA,UAC9B,SAAS;AAAA,UACT,QAAQ,QAAQ;AAAA,UAChB,WAAW,QAAQ;AAAA,QACvB,CAAC;AAED,YAAI,SAAS,WAAW,YAAY;AAChC,iBAAO;AAAA,YACH,QAAQ;AAAA,YACR,SAAS;AAAA,YACT,UAAU,SAAS;AAAA,YACnB,kBAAmB,SAAiB,oBAAoB;AAAA,UAC5D;AAAA,QACJ;AAEA,eAAO;AAAA,UACH,QAAQ;AAAA,UACR,gBAAgB;AAAA,UAChB,gBAAgB,SAAS,mBAAmB,SAAS;AAAA,UACrD,UAAU,SAAS;AAAA,QACvB;AAAA,MAEJ,SAAS,OAAY;AACjB,eAAO;AAAA,UACH,QAAQ;AAAA,UACR,OAAO,MAAM,WAAW;AAAA,UACxB,YAAY;AAAA,QAChB;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ,CAAC;AACL;","names":["createVercelTool"]}

package/dist/vercel.mjs

@@ -0,0 +1,49 @@
+// src/vercel.ts
+import { tool as createVercelTool } from "ai";
+import { LetsPing } from "@letsping/sdk";
+function letsPing(options) {
+  if (!options.apiKey) {
+    throw new Error("LetsPing Adapter Error: 'apiKey' is required.");
+  }
+  const lp = new LetsPing(options.apiKey);
+  return createVercelTool({
+    description: `${options.description} [SYSTEM NOTE: This tool pauses execution to wait for human approval. Do not expect an immediate result.]`,
+    parameters: options.schema,
+    execute: async (args) => {
+      try {
+        const decision = await lp.ask({
+          service: options.service || "vercel-ai-sdk",
+          action: options.name,
+          priority: options.priority || "medium",
+          payload: args,
+          schema: options.schema,
+          timeoutMs: options.timeout
+        });
+        if (decision.status === "REJECTED") {
+          return {
+            status: "REJECTED",
+            message: "The human operator explicitly denied this action. Do not proceed.",
+            metadata: decision.metadata,
+            rejection_reason: decision.rejection_reason || "No reason provided"
+          };
+        }
+        return {
+          status: "APPROVED",
+          original_input: args,
+          approved_input: decision.patched_payload || decision.payload,
+          metadata: decision.metadata
+        };
+      } catch (error) {
+        return {
+          status: "ERROR",
+          error: error.message || "Control plane unreachable or request timed out.",
+          suggestion: "Inform the user that the request for approval failed."
+        };
+      }
+    }
+  });
+}
+export {
+  letsPing
+};
+//# sourceMappingURL=vercel.mjs.map

package/dist/vercel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vercel.ts"],"sourcesContent":["import { tool as createVercelTool } from \"ai\";\r\nimport { LetsPing } from \"@letsping/sdk\";\r\nimport { z } from \"zod\";\r\n\r\ninterface AdapterOptions<T extends z.ZodType> {\r\n    name: string;\r\n    description: string;\r\n    schema: T;\r\n    apiKey: string;\r\n    service?: string;\r\n    priority?: \"low\" | \"medium\" | \"high\" | \"critical\";\r\n    timeout?: number;\r\n}\r\n\r\n/**\r\n * Creates a Vercel AI SDK Tool that pauses execution for human approval.\r\n * @example\r\n * const tools = {\r\n * refund: letsPing({\r\n * name: \"refund_user\",\r\n * description: \"Refund a user transaction\",\r\n * schema: z.object({ amount: z.number() }),\r\n * apiKey: process.env.LETSPING_API_KEY!\r\n * })\r\n * }\r\n */\r\nexport function letsPing<T extends z.ZodType>(options: AdapterOptions<T>) {\r\n    if (!options.apiKey) {\r\n        throw new Error(\"LetsPing Adapter Error: 'apiKey' is required.\");\r\n    }\r\n\r\n    const lp = new LetsPing(options.apiKey);\r\n\r\n    return createVercelTool({\r\n        description: `${options.description} [SYSTEM NOTE: This tool pauses execution to wait for human approval. Do not expect an immediate result.]`,\r\n        parameters: options.schema,\r\n        execute: async (args) => {\r\n            try {\r\n                const decision = await lp.ask({\r\n                    service: options.service || \"vercel-ai-sdk\",\r\n                    action: options.name,\r\n                    priority: options.priority || \"medium\",\r\n                    payload: args,\r\n                    schema: options.schema,\r\n                    timeoutMs: options.timeout\r\n                });\r\n\r\n                if (decision.status === \"REJECTED\") {\r\n                    return {\r\n                        status: \"REJECTED\",\r\n                        message: \"The human operator explicitly denied this action. Do not proceed.\",\r\n                        metadata: decision.metadata,\r\n                        rejection_reason: (decision as any).rejection_reason || \"No reason provided\"\r\n                    };\r\n                }\r\n\r\n                return {\r\n                    status: \"APPROVED\",\r\n                    original_input: args,\r\n                    approved_input: decision.patched_payload || decision.payload,\r\n                    metadata: decision.metadata\r\n                };\r\n\r\n            } catch (error: any) {\r\n                return {\r\n                    status: \"ERROR\",\r\n                    error: error.message || \"Control plane unreachable or request timed out.\",\r\n                    suggestion: \"Inform the user that the request for approval failed.\"\r\n                };\r\n            }\r\n        },\r\n    });\r\n}"],"mappings":";AAAA,SAAS,QAAQ,wBAAwB;AACzC,SAAS,gBAAgB;AAyBlB,SAAS,SAA8B,SAA4B;AACtE,MAAI,CAAC,QAAQ,QAAQ;AACjB,UAAM,IAAI,MAAM,+CAA+C;AAAA,EACnE;AAEA,QAAM,KAAK,IAAI,SAAS,QAAQ,MAAM;AAEtC,SAAO,iBAAiB;AAAA,IACpB,aAAa,GAAG,QAAQ,WAAW;AAAA,IACnC,YAAY,QAAQ;AAAA,IACpB,SAAS,OAAO,SAAS;AACrB,UAAI;AACA,cAAM,WAAW,MAAM,GAAG,IAAI;AAAA,UAC1B,SAAS,QAAQ,WAAW;AAAA,UAC5B,QAAQ,QAAQ;AAAA,UAChB,UAAU,QAAQ,YAAY;AAAA,UAC9B,SAAS;AAAA,UACT,QAAQ,QAAQ;AAAA,UAChB,WAAW,QAAQ;AAAA,QACvB,CAAC;AAED,YAAI,SAAS,WAAW,YAAY;AAChC,iBAAO;AAAA,YACH,QAAQ;AAAA,YACR,SAAS;AAAA,YACT,UAAU,SAAS;AAAA,YACnB,kBAAmB,SAAiB,oBAAoB;AAAA,UAC5D;AAAA,QACJ;AAEA,eAAO;AAAA,UACH,QAAQ;AAAA,UACR,gBAAgB;AAAA,UAChB,gBAAgB,SAAS,mBAAmB,SAAS;AAAA,UACrD,UAAU,SAAS;AAAA,QACvB;AAAA,MAEJ,SAAS,OAAY;AACjB,eAAO;AAAA,UACH,QAAQ;AAAA,UACR,OAAO,MAAM,WAAW;AAAA,UACxB,YAAY;AAAA,QAChB;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ,CAAC;AACL;","names":[]}

package/package.json

@@ -0,0 +1,44 @@
+{
+    "name": "@letsping/adapters",
+    "version": "0.1.0",
+    "description": "Drop-in Human-in-the-Loop adapters for Vercel AI SDK and LangChain",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        "./vercel": {
+            "types": "./dist/vercel.d.ts",
+            "import": "./dist/vercel.js",
+            "require": "./dist/vercel.js"
+        },
+        "./langchain": {
+            "types": "./dist/langchain.d.ts",
+            "import": "./dist/langchain.js",
+            "require": "./dist/langchain.js"
+        }
+    },
+    "scripts": {
+        "build": "tsup",
+        "dev": "tsup --watch",
+        "clean": "rm -rf dist .turbo"
+    },
+    "peerDependencies": {
+        "@langchain/core": ">=0.1.0",
+        "ai": ">=2.0.0",
+        "zod": ">=3.0.0"
+    },
+    "dependencies": {
+        "@letsping/sdk": "^0.1.0"
+    },
+    "devDependencies": {
+        "tsup": "^8.0.0",
+        "typescript": "^5.0.0",
+        "@types/node": "^20.0.0",
+        "ai": "^3.0.0",
+        "@langchain/core": "^0.1.0",
+        "zod": "^3.0.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}