@authentify2026/agents 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/LICENSE ADDED
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 4Sure Technologies LLC
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
package/README.md CHANGED
@@ -1,3 +1,105 @@
1
- # Temporary Holding Version
2
-
3
- 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.
1
+ # @authentify2026/agents
2
+
3
+ Authentify guards for agent frameworks. Every tool call your agent makes is
4
+ authorized by [Authentify](https://authentify.bz) **before it runs**: in code,
5
+ not as a tool the model may choose to skip.
6
+
7
+ Supported: **OpenAI Agents SDK**, **Anthropic (Claude) tool use** and
8
+ **MCP servers**. There are no framework dependencies; each adapter is typed
9
+ by the shape of the framework's tools.
10
+
11
+ ```
12
+ npm install @authentify2026/agents @authentify2026/sdk
13
+ ```
14
+
15
+ ## 1. Describe your tools once
16
+
17
+ ```ts
18
+ import { AuthentifyClient } from '@authentify2026/sdk';
19
+ import type { ToolPolicy } from '@authentify2026/agents';
20
+
21
+ const authentify = new AuthentifyClient({ apiKey: process.env.AUTHENTIFY_API_KEY! });
22
+
23
+ const policy: ToolPolicy = {
24
+ tools: {
25
+ // tool name -> the authorization request for one call
26
+ transfer_funds: (a) => ({ action: 'XFR', resource: { type: 'account', id: a.from }, context: { amount: a.amount } }),
27
+ approve_claim: (a) => ({ action: 'APPROVE_CLAIM', resource: { type: 'claim', id: a.claimId } }),
28
+ get_balance: () => 'skip', // read-only: explicitly unchecked
29
+ },
30
+ endUserId: currentCustomer.id, // optional: gate on that customer's consent
31
+ };
32
+ ```
33
+
34
+ The guards fail closed:
35
+
36
+ | Outcome | What happens |
37
+ |---|---|
38
+ | allow | The tool runs |
39
+ | deny | Not run; the model is told it was denied and not to retry |
40
+ | escalate | Not run; the model is told it awaits human approval (with the approval request id) |
41
+ | Authentify unreachable or erroring | Not run |
42
+ | Tool missing from `tools` | Not run (set `unlisted: 'skip'` to allow) |
43
+
44
+ Every decision is sealed into your Authentify audit chain.
45
+
46
+ ## 2. Wrap your framework
47
+
48
+ ### OpenAI Agents SDK
49
+
50
+ ```ts
51
+ import { Agent, run, tool } from '@openai/agents';
52
+ import { guardOpenAITools } from '@authentify2026/agents';
53
+
54
+ const agent = new Agent({
55
+ name: 'Treasury assistant',
56
+ tools: guardOpenAITools([transferFunds, getBalance], authentify, policy),
57
+ });
58
+ await run(agent, 'Move $50 from checking to savings');
59
+ ```
60
+
61
+ Hosted tools (web search, code interpreter) run on OpenAI's side and can't be
62
+ intercepted; `guardOpenAITool` throws if given one.
63
+
64
+ ### Anthropic (Claude) tool use
65
+
66
+ ```ts
67
+ import Anthropic from '@anthropic-ai/sdk';
68
+ import { createAnthropicToolRunner } from '@authentify2026/agents';
69
+
70
+ const runTools = createAnthropicToolRunner(authentify, policy, {
71
+ transfer_funds: (input) => payments.transfer(input),
72
+ get_balance: (input) => accounts.balance(input.account),
73
+ });
74
+
75
+ const message = await anthropic.messages.create({ model, max_tokens: 1024, tools, messages });
76
+ if (message.stop_reason === 'tool_use') {
77
+ messages.push({ role: 'assistant', content: message.content });
78
+ messages.push({ role: 'user', content: await runTools.all(message.content) });
79
+ }
80
+ ```
81
+
82
+ ### MCP servers
83
+
84
+ Guarding the server covers every client that connects: Claude Desktop,
85
+ Cursor or your own agent.
86
+
87
+ ```ts
88
+ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
89
+ import { createMcpGuard } from '@authentify2026/agents';
90
+
91
+ const guard = createMcpGuard(authentify, policy);
92
+ server.registerTool('transfer_funds', { description, inputSchema },
93
+ guard('transfer_funds', async (args) => ({ content: [{ type: 'text', text: await transfer(args) }] })));
94
+ ```
95
+
96
+ ## Options
97
+
98
+ Each adapter accepts `{ onBlocked: 'throw' }`, which throws
99
+ `ToolCallBlockedError` instead of returning the explanation to the model.
100
+ `authorizeToolCall(client, policy, name, args)` is the framework-free core
101
+ if you run your own tool loop.
102
+
103
+ LangChain: see [`@authentify2026/langchain`](https://www.npmjs.com/package/@authentify2026/langchain).
104
+
105
+ MIT licensed. © 4Sure Technologies LLC.
@@ -0,0 +1,36 @@
1
+ import { type AuthentifyGuard, type ToolPolicy } from './policy';
2
+ export interface AnthropicToolUseBlock {
3
+ type: 'tool_use';
4
+ id: string;
5
+ name: string;
6
+ input: unknown;
7
+ }
8
+ export interface AnthropicToolResultBlock {
9
+ type: 'tool_result';
10
+ tool_use_id: string;
11
+ content: string;
12
+ is_error?: boolean;
13
+ }
14
+ export type AnthropicToolHandler = (input: any, block: AnthropicToolUseBlock) => unknown | Promise<unknown>;
15
+ export interface AnthropicToolRunnerOptions {
16
+ /**
17
+ * `'result'` (default): a blocked call becomes an `is_error` tool_result
18
+ * telling the model what happened, so the conversation carries on.
19
+ * `'throw'`: throw ToolCallBlockedError instead.
20
+ */
21
+ onBlocked?: 'result' | 'throw';
22
+ }
23
+ /**
24
+ * Runs Claude's tool_use blocks through Authentify before your handlers.
25
+ *
26
+ * const run = createAnthropicToolRunner(authentify, policy, { transfer_funds: doTransfer });
27
+ * const results = await run.all(message.content);
28
+ * messages.push({ role: 'user', content: results });
29
+ *
30
+ * A handler only runs on an allow. Handler errors propagate unchanged.
31
+ */
32
+ export declare function createAnthropicToolRunner(client: AuthentifyGuard, policy: ToolPolicy, handlers: Record<string, AnthropicToolHandler>, options?: AnthropicToolRunnerOptions): ((block: AnthropicToolUseBlock) => Promise<AnthropicToolResultBlock>) & {
33
+ all: (content: ReadonlyArray<{
34
+ type: string;
35
+ }>) => Promise<AnthropicToolResultBlock[]>;
36
+ };
@@ -0,0 +1,39 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.createAnthropicToolRunner = createAnthropicToolRunner;
4
+ const policy_1 = require("./policy");
5
+ /**
6
+ * Runs Claude's tool_use blocks through Authentify before your handlers.
7
+ *
8
+ * const run = createAnthropicToolRunner(authentify, policy, { transfer_funds: doTransfer });
9
+ * const results = await run.all(message.content);
10
+ * messages.push({ role: 'user', content: results });
11
+ *
12
+ * A handler only runs on an allow. Handler errors propagate unchanged.
13
+ */
14
+ function createAnthropicToolRunner(client, policy, handlers, options = {}) {
15
+ async function run(block) {
16
+ const check = await (0, policy_1.authorizeToolCall)(client, policy, block.name, block.input);
17
+ if (!check.allowed) {
18
+ if (options.onBlocked === 'throw')
19
+ throw new policy_1.ToolCallBlockedError(block.name, check);
20
+ return { type: 'tool_result', tool_use_id: block.id, content: check.message, is_error: true };
21
+ }
22
+ const handler = Object.prototype.hasOwnProperty.call(handlers, block.name) ? handlers[block.name] : undefined;
23
+ if (!handler) {
24
+ return { type: 'tool_result', tool_use_id: block.id, content: `No handler is registered for "${block.name}".`, is_error: true };
25
+ }
26
+ const output = await handler(block.input, block);
27
+ return { type: 'tool_result', tool_use_id: block.id, content: typeof output === 'string' ? output : JSON.stringify(output ?? null) };
28
+ }
29
+ /** Every tool_use block in an assistant message's content, in order. */
30
+ async function all(content) {
31
+ const results = [];
32
+ for (const block of content) {
33
+ if (block.type === 'tool_use')
34
+ results.push(await run(block));
35
+ }
36
+ return results;
37
+ }
38
+ return Object.assign(run, { all });
39
+ }
@@ -0,0 +1,8 @@
1
+ export { authorizeToolCall, ToolCallBlockedError } from './policy';
2
+ export type { AuthentifyGuard, ToolAuthorization, ToolPolicy, ToolCallCheck } from './policy';
3
+ export { createAnthropicToolRunner } from './anthropic';
4
+ export type { AnthropicToolUseBlock, AnthropicToolResultBlock, AnthropicToolHandler, AnthropicToolRunnerOptions } from './anthropic';
5
+ export { guardOpenAITool, guardOpenAITools } from './openai';
6
+ export type { OpenAIFunctionToolLike, GuardOpenAIToolOptions } from './openai';
7
+ export { createMcpGuard } from './mcp';
8
+ export type { McpCallToolResult, McpToolHandler, McpGuardOptions } from './mcp';
package/dist/index.js ADDED
@@ -0,0 +1,13 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.createMcpGuard = exports.guardOpenAITools = exports.guardOpenAITool = exports.createAnthropicToolRunner = exports.ToolCallBlockedError = exports.authorizeToolCall = void 0;
4
+ var policy_1 = require("./policy");
5
+ Object.defineProperty(exports, "authorizeToolCall", { enumerable: true, get: function () { return policy_1.authorizeToolCall; } });
6
+ Object.defineProperty(exports, "ToolCallBlockedError", { enumerable: true, get: function () { return policy_1.ToolCallBlockedError; } });
7
+ var anthropic_1 = require("./anthropic");
8
+ Object.defineProperty(exports, "createAnthropicToolRunner", { enumerable: true, get: function () { return anthropic_1.createAnthropicToolRunner; } });
9
+ var openai_1 = require("./openai");
10
+ Object.defineProperty(exports, "guardOpenAITool", { enumerable: true, get: function () { return openai_1.guardOpenAITool; } });
11
+ Object.defineProperty(exports, "guardOpenAITools", { enumerable: true, get: function () { return openai_1.guardOpenAITools; } });
12
+ var mcp_1 = require("./mcp");
13
+ Object.defineProperty(exports, "createMcpGuard", { enumerable: true, get: function () { return mcp_1.createMcpGuard; } });
package/dist/mcp.d.ts ADDED
@@ -0,0 +1,31 @@
1
+ import { type AuthentifyGuard, type ToolPolicy } from './policy';
2
+ export interface McpCallToolResult {
3
+ content: Array<{
4
+ type: 'text';
5
+ text: string;
6
+ } | {
7
+ type: string;
8
+ [key: string]: unknown;
9
+ }>;
10
+ isError?: boolean;
11
+ [key: string]: unknown;
12
+ }
13
+ export type McpToolHandler<Args = any, Extra = any> = (args: Args, extra: Extra) => McpCallToolResult | Promise<McpCallToolResult>;
14
+ export interface McpGuardOptions {
15
+ /**
16
+ * `'result'` (default): a blocked call returns an `isError` result the
17
+ * model can read. `'throw'`: throw ToolCallBlockedError (the MCP SDK then
18
+ * reports it to the client as a tool error).
19
+ */
20
+ onBlocked?: 'result' | 'throw';
21
+ }
22
+ /**
23
+ * Wraps tool handlers so each call is checked with Authentify first:
24
+ *
25
+ * const guard = createMcpGuard(authentify, policy);
26
+ * server.registerTool('transfer_funds', { inputSchema }, guard('transfer_funds', doTransfer));
27
+ *
28
+ * Pass the same name you register the tool under; it selects the policy
29
+ * entry. For tools with an input schema (the handler receives arguments).
30
+ */
31
+ export declare function createMcpGuard(client: AuthentifyGuard, policy: ToolPolicy, options?: McpGuardOptions): <Args, Extra>(toolName: string, handler: McpToolHandler<Args, Extra>) => McpToolHandler<Args, Extra>;
package/dist/mcp.js ADDED
@@ -0,0 +1,26 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.createMcpGuard = createMcpGuard;
4
+ const policy_1 = require("./policy");
5
+ /**
6
+ * Wraps tool handlers so each call is checked with Authentify first:
7
+ *
8
+ * const guard = createMcpGuard(authentify, policy);
9
+ * server.registerTool('transfer_funds', { inputSchema }, guard('transfer_funds', doTransfer));
10
+ *
11
+ * Pass the same name you register the tool under; it selects the policy
12
+ * entry. For tools with an input schema (the handler receives arguments).
13
+ */
14
+ function createMcpGuard(client, policy, options = {}) {
15
+ return function guard(toolName, handler) {
16
+ return async (args, extra) => {
17
+ const check = await (0, policy_1.authorizeToolCall)(client, policy, toolName, args);
18
+ if (!check.allowed) {
19
+ if (options.onBlocked === 'throw')
20
+ throw new policy_1.ToolCallBlockedError(toolName, check);
21
+ return { content: [{ type: 'text', text: check.message }], isError: true };
22
+ }
23
+ return handler(args, extra);
24
+ };
25
+ };
26
+ }
@@ -0,0 +1,18 @@
1
+ import { type AuthentifyGuard, type ToolPolicy } from './policy';
2
+ export interface OpenAIFunctionToolLike {
3
+ type: 'function';
4
+ name: string;
5
+ invoke: (runContext: any, input: string, details?: any) => Promise<unknown>;
6
+ }
7
+ export interface GuardOpenAIToolOptions {
8
+ /**
9
+ * `'result'` (default): a blocked call returns the explanation as the
10
+ * tool's output, so the model can tell the user. `'throw'`: throw
11
+ * ToolCallBlockedError, which ends the run.
12
+ */
13
+ onBlocked?: 'result' | 'throw';
14
+ }
15
+ /** The same tool, checked with Authentify before every call. */
16
+ export declare function guardOpenAITool<T extends OpenAIFunctionToolLike>(tool: T, client: AuthentifyGuard, policy: ToolPolicy, options?: GuardOpenAIToolOptions): T;
17
+ /** guardOpenAITool for each tool: `new Agent({ tools: guardOpenAITools([...], authentify, policy) })`. */
18
+ export declare function guardOpenAITools<T extends OpenAIFunctionToolLike>(tools: T[], client: AuthentifyGuard, policy: ToolPolicy, options?: GuardOpenAIToolOptions): T[];
package/dist/openai.js ADDED
@@ -0,0 +1,40 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.guardOpenAITool = guardOpenAITool;
4
+ exports.guardOpenAITools = guardOpenAITools;
5
+ const policy_1 = require("./policy");
6
+ /** The same tool, checked with Authentify before every call. */
7
+ function guardOpenAITool(tool, client, policy, options = {}) {
8
+ if (tool.type !== 'function' || typeof tool.invoke !== 'function') {
9
+ // Hosted tools (web search, code interpreter...) run on OpenAI's side
10
+ // and can't be intercepted here; refuse rather than pass one through
11
+ // looking guarded.
12
+ throw new TypeError(`guardOpenAITool: "${tool.name}" is not a function tool, so its calls can't be checked.`);
13
+ }
14
+ const invoke = tool.invoke.bind(tool);
15
+ return {
16
+ ...tool,
17
+ invoke: async (runContext, input, details) => {
18
+ let args;
19
+ try {
20
+ args = input ? JSON.parse(input) : {};
21
+ }
22
+ catch {
23
+ args = undefined;
24
+ }
25
+ const check = args === undefined
26
+ ? { allowed: false, reason: 'unavailable', message: `The arguments for "${tool.name}" were not valid JSON, so it was not run.` }
27
+ : await (0, policy_1.authorizeToolCall)(client, policy, tool.name, args);
28
+ if (!check.allowed) {
29
+ if (options.onBlocked === 'throw')
30
+ throw new policy_1.ToolCallBlockedError(tool.name, check);
31
+ return check.message;
32
+ }
33
+ return invoke(runContext, input, details);
34
+ },
35
+ };
36
+ }
37
+ /** guardOpenAITool for each tool: `new Agent({ tools: guardOpenAITools([...], authentify, policy) })`. */
38
+ function guardOpenAITools(tools, client, policy, options) {
39
+ return tools.map((t) => guardOpenAITool(t, client, policy, options));
40
+ }
@@ -0,0 +1,52 @@
1
+ import type { AuthorizeParams, AuthorizeResponse } from '@authentify2026/sdk';
2
+ /** Anything with the SDK's guard(): an AuthentifyClient (@authentify2026/sdk >= 0.4). */
3
+ export interface AuthentifyGuard {
4
+ guard(params: AuthorizeParams): Promise<AuthorizeResponse>;
5
+ }
6
+ /**
7
+ * How one tool call becomes an Authentify authorization request. Return the
8
+ * request to check, or `'skip'` for a tool that needs no authorization (say,
9
+ * a read-only lookup), which makes the decision explicit in your code.
10
+ */
11
+ export type ToolAuthorization = (args: any) => AuthorizeParams | 'skip';
12
+ export interface ToolPolicy {
13
+ /** One entry per tool name the agent can call. */
14
+ tools: Record<string, ToolAuthorization>;
15
+ /**
16
+ * Tools missing from `tools`: `'deny'` (the default) blocks them without
17
+ * calling Authentify, so a tool added later can't run unchecked.
18
+ * `'skip'` lets them run.
19
+ */
20
+ unlisted?: 'deny' | 'skip';
21
+ /** Applied to every request that doesn't set its own endUserId. */
22
+ endUserId?: string;
23
+ }
24
+ export type ToolCallCheck = {
25
+ allowed: true;
26
+ response?: AuthorizeResponse;
27
+ } | {
28
+ allowed: false;
29
+ reason: 'denied' | 'escalated' | 'unavailable' | 'unlisted';
30
+ /** Written for the model: what happened and what to do next. */
31
+ message: string;
32
+ response?: AuthorizeResponse;
33
+ /** The underlying error, for your logs. Never included in `message`. */
34
+ error?: unknown;
35
+ };
36
+ /**
37
+ * Checks one tool call with Authentify before it runs. Fails closed: a
38
+ * denial, an escalation to human approval, an unlisted tool and any error
39
+ * (including one thrown by the policy's own mapping) all come back as
40
+ * `allowed: false`.
41
+ */
42
+ export declare function authorizeToolCall(client: AuthentifyGuard, policy: ToolPolicy, toolName: string, args: unknown): Promise<ToolCallCheck>;
43
+ /** Thrown by the adapters when configured with `onBlocked: 'throw'`. */
44
+ export declare class ToolCallBlockedError extends Error {
45
+ readonly toolName: string;
46
+ readonly check: Extract<ToolCallCheck, {
47
+ allowed: false;
48
+ }>;
49
+ constructor(toolName: string, check: Extract<ToolCallCheck, {
50
+ allowed: false;
51
+ }>);
52
+ }
package/dist/policy.js ADDED
@@ -0,0 +1,93 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.ToolCallBlockedError = void 0;
4
+ exports.authorizeToolCall = authorizeToolCall;
5
+ function isDecisionError(err) {
6
+ // Checked by shape, not instanceof: the app and this package may load
7
+ // different copies of the SDK.
8
+ return !!err && typeof err === 'object' && err.name === 'AuthentifyDecisionError';
9
+ }
10
+ /**
11
+ * Checks one tool call with Authentify before it runs. Fails closed: a
12
+ * denial, an escalation to human approval, an unlisted tool and any error
13
+ * (including one thrown by the policy's own mapping) all come back as
14
+ * `allowed: false`.
15
+ */
16
+ async function authorizeToolCall(client, policy, toolName, args) {
17
+ const map = Object.prototype.hasOwnProperty.call(policy.tools, toolName) ? policy.tools[toolName] : undefined;
18
+ if (!map) {
19
+ if (policy.unlisted === 'skip')
20
+ return { allowed: true };
21
+ return {
22
+ allowed: false,
23
+ reason: 'unlisted',
24
+ message: `The tool "${toolName}" is not authorized for this agent. Do not retry it; tell the user it isn't available.`,
25
+ };
26
+ }
27
+ let params;
28
+ try {
29
+ params = map(args ?? {});
30
+ }
31
+ catch (err) {
32
+ // The mapping's own error can carry internal details; the model only
33
+ // gets a generic explanation.
34
+ return {
35
+ allowed: false,
36
+ reason: 'unavailable',
37
+ message: `The call to "${toolName}" could not be checked, so it was not run.`,
38
+ error: err,
39
+ };
40
+ }
41
+ if (params === 'skip')
42
+ return { allowed: true };
43
+ if (policy.endUserId && !params.endUserId)
44
+ params = { ...params, endUserId: policy.endUserId };
45
+ try {
46
+ return { allowed: true, response: await client.guard(params) };
47
+ }
48
+ catch (err) {
49
+ if (!isDecisionError(err)) {
50
+ return {
51
+ allowed: false,
52
+ reason: 'unavailable',
53
+ message: `Authorization for "${toolName}" could not be confirmed, so it was not run. Try again later.`,
54
+ error: err,
55
+ };
56
+ }
57
+ const response = err.response;
58
+ if (err.reason === 'escalated') {
59
+ const ref = response?.approvalRequestId ? ` (approval request ${response.approvalRequestId})` : '';
60
+ return {
61
+ allowed: false,
62
+ reason: 'escalated',
63
+ response,
64
+ message: `"${toolName}" needs human approval before it can run${ref}. It has not been run. Tell the user it is awaiting approval; do not retry it now.`,
65
+ };
66
+ }
67
+ if (err.reason === 'denied') {
68
+ const why = response?.reason ? `: ${response.reason}` : '';
69
+ return {
70
+ allowed: false,
71
+ reason: 'denied',
72
+ response,
73
+ message: `Authentify denied "${toolName}"${why}. It was not run. Do not retry it; tell the user it isn't permitted.`,
74
+ };
75
+ }
76
+ return {
77
+ allowed: false,
78
+ reason: 'unavailable',
79
+ response,
80
+ message: `Authorization for "${toolName}" could not be confirmed, so it was not run. Try again later.`,
81
+ };
82
+ }
83
+ }
84
+ /** Thrown by the adapters when configured with `onBlocked: 'throw'`. */
85
+ class ToolCallBlockedError extends Error {
86
+ constructor(toolName, check) {
87
+ super(check.message);
88
+ this.name = 'ToolCallBlockedError';
89
+ this.toolName = toolName;
90
+ this.check = check;
91
+ }
92
+ }
93
+ exports.ToolCallBlockedError = ToolCallBlockedError;
package/package.json CHANGED
@@ -1,6 +1,33 @@
1
- {
2
- "name": "@authentify2026/agents",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
1
+ {
2
+ "name": "@authentify2026/agents",
3
+ "version": "0.1.0",
4
+ "description": "Authentify guards for agent frameworks: every tool call is authorized before it runs (OpenAI Agents SDK, Anthropic tool use, MCP servers)",
5
+ "main": "dist/index.js",
6
+ "types": "dist/index.d.ts",
7
+ "files": [
8
+ "dist"
9
+ ],
10
+ "scripts": {
11
+ "build": "tsc",
12
+ "typecheck": "tsc --noEmit",
13
+ "prepack": "npm run build"
14
+ },
15
+ "keywords": ["authentify", "ai-agents", "authorization", "openai-agents", "anthropic", "mcp", "tool-use"],
16
+ "license": "MIT",
17
+ "engines": {
18
+ "node": ">=18"
19
+ },
20
+ "peerDependencies": {
21
+ "@authentify2026/sdk": ">=0.4.0"
22
+ },
23
+ "devDependencies": {
24
+ "@authentify2026/sdk": "^0.4.0",
25
+ "@types/node": "^20.0.0",
26
+ "typescript": "^5.5.0"
27
+ },
28
+ "publishConfig": {
29
+ "access": "public"
30
+ },
31
+ "homepage": "https://authentify.bz/integration",
32
+ "author": "4Sure Technologies LLC"
33
+ }