@authentify2026/langchain 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 4Sure Technologies LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,47 @@
-# Temporary Holding Version
+# @authentify2026/langchain
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A [LangChain](https://js.langchain.com) tool wrapper around [`@authentify2026/sdk`](https://www.npmjs.com/package/@authentify2026/sdk), so a LangChain agent can call Authentify's `/authorize` gate as a native tool instead of your application hand-rolling a custom tool around a raw `fetch` call.
+
+## Install
+
+```bash
+npm install @authentify2026/langchain @authentify2026/sdk @langchain/core zod
+```
+
+## Usage
+
+```ts
+import { AuthentifyClient } from '@authentify2026/sdk';
+import { createAuthentifyAuthorizeTool } from '@authentify2026/langchain';
+import { ChatOpenAI } from '@langchain/openai'; // or any chat model
+import { createToolCallingAgent, AgentExecutor } from 'langchain/agents';
+
+const authentify = new AuthentifyClient({
+  clientId: process.env.AUTHENTIFY_KEY_ID!,
+  clientSecret: process.env.AUTHENTIFY_KEY_SECRET!,
+  environment: 'production',
+});
+
+const authorizeTool = createAuthentifyAuthorizeTool(authentify);
+
+const agent = await createToolCallingAgent({
+  llm: new ChatOpenAI({ model: 'gpt-4o' }),
+  tools: [authorizeTool /* , ...your other tools */],
+  prompt: /* your prompt, instructing the agent to call authentify_authorize
+             before any account action, and to check `decision` on the
+             result -- 'escalate' means the request is on record awaiting
+             human approval, which is a pending state, not a denial */,
+});
+
+const executor = new AgentExecutor({ agent, tools: [authorizeTool] });
+```
+
+The tool's schema (`action`, `resource: { id, type? }`, `context`, `endUserId`) mirrors `AuthentifyClient.authorize()`'s params directly -- a malformed tool call from the model is rejected by the zod schema before it ever reaches the API.
+
+**Making this the only path**: for the authorization gate to mean anything, the agent's tool list should have no *other*, un-gated way to perform the same action -- e.g. don't also give it a raw HTTP tool that could call the same downstream system directly. Authentify enforces every call that reaches it; it can't enforce a call that never does. See `docs/partner-integration-guide.md`'s go-live checklist for this same point.
+
+Only `authorize()` is wrapped today. If you need a tool around consent-session creation or approval-request approval too, wrap the corresponding `AuthentifyClient` method the same way `tools.ts` does for this one.
+
+## Python
+
+Building a Python-based LangChain agent instead? A Python SDK and LangChain wrapper are available on request during early access -- email support via [authentify.bz/contact](https://authentify.bz/contact).

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { createAuthentifyAuthorizeTool } from './tools';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthentifyAuthorizeTool = void 0;
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "createAuthentifyAuthorizeTool", { enumerable: true, get: function () { return tools_1.createAuthentifyAuthorizeTool; } });

package/dist/tools.d.ts

@@ -0,0 +1,60 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+import type { AuthentifyClient } from '@authentify2026/sdk';
+/**
+ * Wraps AuthentifyClient.authorize() as a LangChain tool, so an agent can
+ * call Authentify's authorization gate as a native tool call instead of
+ * the surrounding application hand-rolling a fetch inside a custom tool.
+ *
+ * The tool's observation is the raw JSON result: `decision` is
+ * `'allow' | 'deny' | 'escalate'` -- treat `escalate` as "not yet
+ * approved, on record for human review" rather than a denial (an
+ * `approvalRequestId` is included when escalated).
+ */
+export declare function createAuthentifyAuthorizeTool(client: AuthentifyClient): DynamicStructuredTool<z.ZodObject<{
+    action: z.ZodOptional<z.ZodString>;
+    resource: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type?: string | undefined;
+    }, {
+        id: string;
+        type?: string | undefined;
+    }>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    endUserId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    resource: {
+        id: string;
+        type?: string | undefined;
+    };
+    action?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+    endUserId?: string | undefined;
+}, {
+    resource: {
+        id: string;
+        type?: string | undefined;
+    };
+    action?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+    endUserId?: string | undefined;
+}>, {
+    resource: {
+        id: string;
+        type?: string | undefined;
+    };
+    action?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+    endUserId?: string | undefined;
+}, {
+    resource: {
+        id: string;
+        type?: string | undefined;
+    };
+    action?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+    endUserId?: string | undefined;
+}, string, unknown, "authentify_authorize">;

package/dist/tools.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthentifyAuthorizeTool = createAuthentifyAuthorizeTool;
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const authorizeSchema = zod_1.z.object({
+    action: zod_1.z.string().optional().describe('The action being requested, e.g. READ, TRANSFER, APPROVE_CLAIM, EXECUTE_LEASE.'),
+    resource: zod_1.z.object({
+        id: zod_1.z.string().describe('The resource this action targets (an account ID, claim ID, lease ID, etc.).'),
+        type: zod_1.z.string().optional().describe('The resource\'s type, if relevant, e.g. CHECKING, INSURANCE_CLAIM, PROPERTY.'),
+    }),
+    context: zod_1.z.record(zod_1.z.unknown()).optional().describe('Free-form domain data, e.g. { amount: 500 } for ceiling-based autonomy, or any other key a customer-authored ' +
+        'rule may reference as context.<key>. Not interpreted by name except "amount".'),
+    endUserId: zod_1.z.string().optional().describe('The retail customer this call is on behalf of, if applicable -- gates on their consent.'),
+});
+/**
+ * Wraps AuthentifyClient.authorize() as a LangChain tool, so an agent can
+ * call Authentify's authorization gate as a native tool call instead of
+ * the surrounding application hand-rolling a fetch inside a custom tool.
+ *
+ * The tool's observation is the raw JSON result: `decision` is
+ * `'allow' | 'deny' | 'escalate'` -- treat `escalate` as "not yet
+ * approved, on record for human review" rather than a denial (an
+ * `approvalRequestId` is included when escalated).
+ */
+function createAuthentifyAuthorizeTool(client) {
+    return new tools_1.DynamicStructuredTool({
+        name: 'authentify_authorize',
+        description: "Check whether the current agent is authorized to perform an action via Authentify. " +
+            "Call this before taking any action that requires authorization (e.g. reading account data, " +
+            "transferring funds, approving a claim). Returns { authorizationRequestId, decision, reason, ... } " +
+            "where decision is 'allow', 'deny', or 'escalate' -- 'escalate' means the request is on record " +
+            "awaiting human approval, not a denial.",
+        schema: authorizeSchema,
+        func: async (input) => {
+            const result = await client.authorize(input);
+            return JSON.stringify(result);
+        },
+    });
+}

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@authentify2026/langchain",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "LangChain tool wrapper for the Authentify authorization API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@authentify2026/sdk": "^0.1.0"
+  },
+  "peerDependencies": {
+    "@langchain/core": ">=0.2.0",
+    "zod": "3.23.8"
+  },
+  "devDependencies": {
+    "@langchain/core": "^1.2.13",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.0",
+    "zod": "3.23.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://authentify.bz/integration",
+  "author": "4Sure Technologies LLC"
+}