@lit-protocol/vincent-ability-sdk 0.0.1-ea

package/CHANGELOG.md

@@ -0,0 +1,64 @@
+# 2.0.0 (2025-08-01)
+
+### 🚀 Features
+
+- Add descriptions on abilities and their api interface params ([0b8ff1e3](https://github.com/LIT-Protocol/Vincent/commit/0b8ff1e3))
+
+### 🩹 Fixes
+
+- Making api version property in bundled things to ease its discovery and usage when validating its compatibility ([aa81d087](https://github.com/LIT-Protocol/Vincent/commit/aa81d087))
+- ### Implement supported Vincent Ability API range ([14f0ece1](https://github.com/LIT-Protocol/Vincent/commit/14f0ece1))
+
+  Added basic Ability API handling to ensure abilities & policies are only used by compatible abilities and policies, and with the correct version of the vincentAbilityClient / app-sdk
+
+  - Added a new jsParam when VincentAbilityClient calls an ability, `vincentAbilityApiVersion`
+  - LIT action wrappers for abilities + policies compare `vincentAbilityApiVersion` to match the major semver range the handler was built with from the ability-sdk
+  - vincentAbilityHandler() is responsible for passing along the value when it evaluates supported policies
+
+### ⚠️ Breaking Changes
+
+- Add support for vincent-contract-sdk using CBOR2 encoded policy parameters ([819fcd11](https://github.com/LIT-Protocol/Vincent/commit/819fcd11))
+- ### `error` is now `runtimeError` and can only be set by `throw ...` ([04f1ca20](https://github.com/LIT-Protocol/Vincent/commit/04f1ca20))
+
+  - Previously, if you had not defined a `deny` or `fail` schema, you could call `deny()` or `fail()` with a string
+  - That string would end up in the ability/policy response as the `error` property instead of `result`
+  - This was problematic because there was no consistent way to identify _un-handled_ error vs. _explicitly returned fail/deny results_
+  - If you don't define a deny or fail schema, you can no longer call those methods with a string.
+  - `error` is now `runtimeError`, and is _only_ set if a lifecycle method `throw`s an Error - in that case it will be the `message` property of the error
+  - If you want to be able to return simple errors in your _result_, you can define a simple deny or fail schema like `z.object({ error: z.string() }`
+
+- ### Add support for explicit `schemaValidationError` ([337a4bde](https://github.com/LIT-Protocol/Vincent/commit/337a4bde))
+
+  - Previously, a failure to validate either input or results of lifecycle method would result in `result: { zodError }` being returned
+  - Now, `result` will be `undefined` and there will be an explicit `schemaValidationError` in the result of the ability / policy
+
+  ```typescript
+  export interface SchemaValidationError {
+    zodError: ZodError<unknown>; // The result of `zod.safeParse().error`
+    phase: string; // Policies: `precheck`|`evaluate`|`commit` - Abilities: `precheck` | `execute`
+    stage: string; // `input` | `output`
+  }
+  ```
+
+### 🧱 Updated Dependencies
+
+- Updated contracts-sdk to 1.0.0
+
+### ❤️ Thank You
+
+- Daryl Collins
+- FedericoAmura @FedericoAmura
+
+## 1.0.2 (2025-07-08)
+
+### 🩹 Fixes
+
+- - Correct type of `PolicyEvaluationResultContext.deniedPolicy` so that `error` is a sibling of `result` ([edc609f5](https://github.com/LIT-Protocol/Vincent/commit/edc609f5))
+- - Fixed a case where a deny response from a policy could be returned without being parsed by its deny result schema ([27a35240](https://github.com/LIT-Protocol/Vincent/commit/27a35240))
+- - Fixed incorrect handling of failure results that resulted in `success: true` responses from abilities that returned fail results ([51087e71](https://github.com/LIT-Protocol/Vincent/commit/51087e71))
+- - Fixed `undefined` being returned to caller instead of the correct `error` string in cases where no fail result schema was defined and an explicit string was passed to `fail()` ([e8f1316a](https://github.com/LIT-Protocol/Vincent/commit/e8f1316a))
+- - Fixed ability result typeguard functions incorrectly returning `false` when they were provided outputs with no `result` (e.g. no return value schema is defined for the lifecycle method) ([cf542969](https://github.com/LIT-Protocol/Vincent/commit/cf542969))
+
+### ❤️ Thank You
+
+- Daryl Collins

package/CONTRIBUTING.md

@@ -0,0 +1,117 @@
+# Contributing to Vincent Ability SDK
+
+This document provides guidelines for contributing to the Vincent Ability SDK project.
+
+## Overview
+
+The Vincent Ability SDK is an SDK exposing utilities to develop Vincent abilities and policies. It provides a type-safe lifecycle system for defining and composing policies and abilities, with strong TypeScript inference support throughout.
+
+## Setup
+
+1. Follow the global setup instructions in the repository root [CONTRIBUTING.md](../../../CONTRIBUTING.md).
+2. Install dependencies:
+   ```bash
+   pnpm install
+   ```
+
+## Development Workflow
+
+### Building
+
+Build the SDK:
+
+```bash
+nx build ability-sdk
+```
+
+### Type Checking
+
+Run type checking:
+
+```bash
+pnpm typecheck
+```
+
+### Watch Mode for Type Checking
+
+Run type checking in watch mode:
+
+```bash
+pnpm watch:type-tests
+```
+
+## Project Structure
+
+- `src/`: Source code
+  - `lib/`
+  - `type-inference-verification/`
+
+## SDK Development Guidelines
+
+1. Maintain strong TypeScript typing throughout the codebase
+2. Use Zod for schema validation
+3. Design APIs that are intuitive and easy to use
+4. Provide comprehensive documentation for all public APIs
+5. Write unit tests for all functionality
+6. Ensure backward compatibility when making changes
+
+## Core Concepts
+
+The SDK is built around these core concepts:
+
+- **Policies**: Encapsulate decision logic (precheck, evaluate, commit) and define their input/output schemas.
+- **Abilities**: Orchestrate multiple policies and expose `precheck` and `execute` lifecycle methods.
+
+## Testing
+
+Write unit tests for all functionality:
+
+```bash
+pnpm test
+```
+
+## Documentation
+
+- Document all public APIs with JSDoc comments
+- Update README.md when adding new features
+- Provide examples for common use cases
+
+## Pull Request Process
+
+1. Ensure your code follows the coding standards
+2. Update documentation if necessary
+3. Include tests for new functionality
+4. Link any related issues in your pull request description
+5. Request a review from a maintainer
+
+## For AI Editors and IDEs
+
+When working with AI-powered editors like Cursor, GitHub Copilot, or other AI assistants in this project directory, please note:
+
+### Context Priority
+
+1. **Primary Context**: When working within the ability-sdk project directory, AI editors should prioritize this CONTRIBUTING.md file and the project's README.md for specific guidance on the Ability SDK.
+
+2. **Secondary Context**: The root-level CONTRIBUTING.md and README.md files provide important context about how this SDK fits into the broader Vincent ecosystem.
+
+### Key Files for Ability SDK Context
+
+- `/packages/libs/ability-sdk/README.md`: Overview of the Ability SDK project
+- `/packages/libs/ability-sdk/CONTRIBUTING.md`: This file, with Ability SDK-specific contribution guidelines
+- `/packages/libs/ability-sdk/src/`: Source code for the Ability SDK
+
+### Related Projects
+
+The Ability SDK is a core component that is used by:
+
+- `policy-spending-limit`: For implementing spending limit policies
+- `ability-erc20-approval`: For implementing ERC20 approval abilities
+- `ability-uniswap-swap`: For implementing Uniswap swap abilities
+
+When working on Ability SDK code, consider these consumers for context, and focus on maintaining backward compatibility and strong type safety.
+
+## Additional Resources
+
+- [Vincent Documentation](https://docs.heyvincent.ai/)
+- [TypeScript Documentation](https://www.typescriptlang.org/docs/)
+- [Zod Documentation](https://zod.dev/)

package/README.md

@@ -0,0 +1,213 @@
+# ability-sdk
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build ability-sdk` to build the library.
+
+## Usage
+
+# Vincent Policy & Ability SDK
+
+This library provides a type-safe lifecycle system for defining and composing **policies** and **abilities**, with strong TypeScript inference support throughout.
+
+## 🧩 Core Concepts
+
+- **Policies** encapsulate decision logic (precheck, evaluate, commit) and define their input/output schemas.
+- **Abilities** orchestrate multiple policies and expose `precheck` and `execute` lifecycle methods.
+- **Context injection** provides `allow()` / `deny()` and `succeed()` / `fail()` methods, with schema-safe return typing.
+- All inference is preserved automatically using `createVincentPolicy`, `createVincentAbilityPolicy`, and `createVincentAbility`.
+
+---
+
+### 🔁 Calling `commit()` on a Policy from within a Ability
+
+Policies can define a `commit()` lifecycle method to finalize changes once an ability executes successfully. These `commit()` functions are injected automatically into the `allowedPolicies` object of the `AbilityContext`.
+
+### Example Policy (max daily spend)
+
+```ts
+import { z } from 'zod';
+import { createVincentPolicy } from '@lit-protocol/vincent-ability-sdk';
+
+import { getAmountSpentToday, adjustDailySpendAmount } from '@my-org/spending-limit-client';
+
+export const dailySpendPolicy = createVincentPolicy({
+  ipfsCid: 'policy-committable',
+  packageName: '@lit-protocol/max-spend-policy',
+
+  abilityParamsSchema: z.object({
+    buySomething: z.boolean(),
+    buyAmount: z.number(),
+  }),
+  userParamsSchema: z.object({
+    perBuyLimit: z.number(),
+    maxAmountPerDay: z.number(),
+  }),
+
+  evalAllowResultSchema: z.object({
+    ok: z.boolean(),
+    amountRemaining: z.number(),
+    amountToSpend: z.number(),
+  }),
+  evalDenyResultSchema: z.union([
+    z.object({
+      reason: z.literal('Buy amount request exceeds per-buy limit'),
+      buyAmount: z.number(),
+    }),
+    z.object({
+      reason: z.enum(['Buy amount request exceeds max amount per day']),
+      buyAmount: z.number(),
+      amountSpentToday: z.number(),
+      amountRemaining: z.number(),
+    }),
+  ]),
+
+  commitParamsSchema: z.object({ amountSpent: z.number() }),
+  commitAllowResultSchema: z.object({
+    transactionId: z.string(),
+    timestamp: z.number(),
+  }),
+  commitDenyResultSchema: z.object({
+    errorCode: z.number().optional(),
+    message: z.string(),
+  }),
+
+  evaluate: async ({ abilityParams, userParams }, context) => {
+    const { maxAmountPerDay, perBuyLimit } = userParams;
+    const { buyAmount } = abilityParams;
+
+    if (buyAmount > perBuyLimit) {
+      return context.deny({
+        reason: 'Buy amount request exceeds per-buy limit',
+        buyAmount,
+      });
+    }
+
+    const amountSpentToday = await getAmountSpentToday(context.delegation.delegator);
+    const amountRemaining = maxAmountPerDay - amountSpentToday;
+
+    if (buyAmount > amountRemaining) {
+      return context.deny({
+        reason: 'Buy amount request exceeds max amount per day',
+        amountSpentToday,
+        buyAmount,
+        amountRemaining,
+      });
+    }
+
+    return context.allow({
+      ok: true,
+      amountRemaining,
+      amountToSpend: buyAmount,
+    });
+  },
+
+  commit: async ({ amountSpent }, context) => {
+    try {
+      const spendCommitResult: { transactionId: string; timestamp: number } =
+        await adjustDailySpendAmount(context.delegation.delegator, amountSpent);
+
+      return context.allow(spendCommitResult);
+    } catch (e: unknown) {
+      if (e instanceof Error) {
+        if ('errorCode' in e) {
+          return context.deny({
+            errorCode: e.errorCode as number,
+            message: e.message,
+          });
+        } else {
+          return context.deny({ message: e.message });
+        }
+      }
+
+      return context.deny({ message: String(e) });
+    }
+  },
+});
+```
+
+---
+
+### Example Ability - Uniswap
+
+```ts
+import { z } from 'zod';
+
+import {
+  createVincentAbilityPolicy,
+  createVincentAbility,
+} from '@lit-protocol/vincent-ability-sdk';
+
+import { dailySpendPolicy } from '@lit-protocol/max-spend-policy';
+
+import uniswapV3Client from '@uniswap/v3-sdk';
+
+const abilityParamsSchema = z.object({
+  buy: z.boolean(),
+  buyAmount: z.number(),
+});
+
+export const myTokenSwapAbility = createVincentAbility({
+  packageName: 'tokenswapability',
+  abilityDescription: 'Token Swap Ability',
+
+  abilityParamsSchema,
+
+  supportedPolicies: [
+    createVincentAbilityPolicy({
+      abilityParamsSchema,
+      PolicyConfig: dailySpendPolicy,
+      abilityParameterMappings: { buy: 'buyAmount' },
+    }),
+  ],
+  executeSuccessSchema: z.object({
+    message: z.string(),
+    amountSpent: z.number().optional(),
+    spendCommitResult: z
+      .object({
+        transactionId: z.string(),
+        timestamp: z.number(),
+      })
+      .optional(),
+  }),
+
+  executeFailSchema: z.object({ error: z.string(), message: z.string() }),
+
+  async execute(abilityParams, { succeed, fail, policiesContext }) {
+    const spendPolicyContext = policiesContext.allowedPolicies['@lit-protocol/max-spend-policy'];
+
+    const amountSpent: number = await uniswapV3Client.performSwap({});
+
+    if (spendPolicyContext) {
+      const spendCommitResult = await spendPolicyContext.commit({
+        amountSpent,
+      });
+
+      if (!spendCommitResult.allow) {
+        return fail({
+          error: `Policy commit denied with code ${spendCommitResult.result.errorCode}`,
+          message: 'Ability executed but policy commit denied',
+        });
+      }
+
+      if (spendCommitResult.allow) {
+        return succeed({
+          amountSpent,
+          spendCommitResult: spendCommitResult.result,
+          message: 'Ability executed and spending limit policy commit completed',
+        });
+      }
+    }
+
+    return succeed({
+      message: 'Ability executed for user without enabled spending limit',
+    });
+  },
+});
+```
+
+## 🧠 Tip
+
+Ability and policy authors should export the result of `createVincentPolicy()` / `createVincentAbility()`

package/dist/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@lit-protocol/vincent-ability-sdk",
+  "version": "0.0.1-ea",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@lit-protocol/vincent-contracts-sdk": "workspace:*",
+    "ethers": "5.8.0",
+    "semver": "^7.7.2",
+    "tslib": "^2.8.1",
+    "zod": "^3.25.64"
+  },
+  "scripts": {
+    "watch:type-tests": "chokidar 'src/**/*' --initial --await-write-finish --delay 100 --silent -c './scripts/run-typecheck.sh'",
+    "typecheck": "./scripts/precommit-check.sh"
+  },
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist/**",
+    "*.md"
+  ],
+  "exports": {
+    ".": {
+      "require": "./dist/src/index.js",
+      "import": "./dist/src/index.js"
+    },
+    "./internal": {
+      "require": "./dist/src/internal.js",
+      "import": "./dist/src/internal.js"
+    }
+  },
+  "devDependencies": {
+    "@types/semver": "^7.7.0",
+    "chokidar-cli": "^3.0.0",
+    "jsonc-eslint-parser": "^2.4.0",
+    "typedoc": "0.27.9",
+    "typedoc-material-theme": "1.3.0",
+    "typedoc-plugin-extras": "^4.0.0",
+    "typedoc-plugin-zod": "^1.4.1"
+  },
+  "type": "commonjs"
+}

package/dist/src/index.d.ts

@@ -0,0 +1,15 @@
+export { createVincentPolicy, createVincentAbilityPolicy } from './lib/policyCore/vincentPolicy';
+export { createVincentAbility } from './lib/abilityCore/vincentAbility';
+export { VINCENT_TOOL_API_VERSION } from './lib/constants';
+export { vincentPolicyHandler } from './lib/handlers/vincentPolicyHandler';
+export { vincentAbilityHandler } from './lib/handlers/vincentAbilityHandler';
+export { asBundledVincentAbility } from './lib/abilityCore/bundledAbility/bundledAbility';
+export { asBundledVincentPolicy } from './lib/policyCore/bundledPolicy/bundledPolicy';
+export { supportedPoliciesForAbility } from './lib/abilityCore/helpers/supportedPoliciesForAbility';
+export type { BundledVincentPolicy } from './lib/policyCore/bundledPolicy/types';
+export type { BundledVincentAbility } from './lib/abilityCore/bundledAbility/types';
+export type { PolicyConfigLifecycleFunction, PolicyConfigCommitFunction, } from './lib/policyCore/policyConfig/types';
+export type { PolicyContext } from './lib/policyCore/policyConfig/context/types';
+export type { VincentAbilityPolicy, BaseContext, PolicyEvaluationResultContext, VincentAbility, AbilityConsumerContext, PolicyConsumerContext, SchemaValidationError, } from './lib/types';
+export type { BaseAbilityContext } from './lib/abilityCore/abilityConfig/context/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AACjG,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAE7E,OAAO,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAC;AAC1F,OAAO,EAAE,sBAAsB,EAAE,MAAM,8CAA8C,CAAC;AACtF,OAAO,EAAE,2BAA2B,EAAE,MAAM,uDAAuD,CAAC;AAEpG,YAAY,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AACjF,YAAY,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AACpF,YAAY,EACV,6BAA6B,EAC7B,0BAA0B,GAC3B,MAAM,qCAAqC,CAAC;AAC7C,YAAY,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAEjF,YAAY,EACV,oBAAoB,EACpB,WAAW,EACX,6BAA6B,EAC7B,cAAc,EACd,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,kBAAkB,EAAE,MAAM,+CAA+C,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedPoliciesForAbility = exports.asBundledVincentPolicy = exports.asBundledVincentAbility = exports.vincentAbilityHandler = exports.vincentPolicyHandler = exports.VINCENT_TOOL_API_VERSION = exports.createVincentAbility = exports.createVincentAbilityPolicy = exports.createVincentPolicy = void 0;
+var vincentPolicy_1 = require("./lib/policyCore/vincentPolicy");
+Object.defineProperty(exports, "createVincentPolicy", { enumerable: true, get: function () { return vincentPolicy_1.createVincentPolicy; } });
+Object.defineProperty(exports, "createVincentAbilityPolicy", { enumerable: true, get: function () { return vincentPolicy_1.createVincentAbilityPolicy; } });
+var vincentAbility_1 = require("./lib/abilityCore/vincentAbility");
+Object.defineProperty(exports, "createVincentAbility", { enumerable: true, get: function () { return vincentAbility_1.createVincentAbility; } });
+var constants_1 = require("./lib/constants");
+Object.defineProperty(exports, "VINCENT_TOOL_API_VERSION", { enumerable: true, get: function () { return constants_1.VINCENT_TOOL_API_VERSION; } });
+var vincentPolicyHandler_1 = require("./lib/handlers/vincentPolicyHandler");
+Object.defineProperty(exports, "vincentPolicyHandler", { enumerable: true, get: function () { return vincentPolicyHandler_1.vincentPolicyHandler; } });
+var vincentAbilityHandler_1 = require("./lib/handlers/vincentAbilityHandler");
+Object.defineProperty(exports, "vincentAbilityHandler", { enumerable: true, get: function () { return vincentAbilityHandler_1.vincentAbilityHandler; } });
+var bundledAbility_1 = require("./lib/abilityCore/bundledAbility/bundledAbility");
+Object.defineProperty(exports, "asBundledVincentAbility", { enumerable: true, get: function () { return bundledAbility_1.asBundledVincentAbility; } });
+var bundledPolicy_1 = require("./lib/policyCore/bundledPolicy/bundledPolicy");
+Object.defineProperty(exports, "asBundledVincentPolicy", { enumerable: true, get: function () { return bundledPolicy_1.asBundledVincentPolicy; } });
+var supportedPoliciesForAbility_1 = require("./lib/abilityCore/helpers/supportedPoliciesForAbility");
+Object.defineProperty(exports, "supportedPoliciesForAbility", { enumerable: true, get: function () { return supportedPoliciesForAbility_1.supportedPoliciesForAbility; } });
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,gEAAiG;AAAxF,oHAAA,mBAAmB,OAAA;AAAE,2HAAA,0BAA0B,OAAA;AACxD,mEAAwE;AAA/D,sHAAA,oBAAoB,OAAA;AAC7B,6CAA2D;AAAlD,qHAAA,wBAAwB,OAAA;AAEjC,4EAA2E;AAAlE,4HAAA,oBAAoB,OAAA;AAC7B,8EAA6E;AAApE,8HAAA,qBAAqB,OAAA;AAE9B,kFAA0F;AAAjF,yHAAA,uBAAuB,OAAA;AAChC,8EAAsF;AAA7E,uHAAA,sBAAsB,OAAA;AAC/B,qGAAoG;AAA3F,0IAAA,2BAA2B,OAAA"}

package/dist/src/internal.d.ts

@@ -0,0 +1,12 @@
+export { getPkpInfo } from './lib/abilityCore/helpers';
+export type { AbilityPolicyMap } from './lib/abilityCore/helpers';
+export { validatePolicies } from './lib/abilityCore/helpers/validatePolicies';
+export { createAbilitySuccessResult } from './lib/abilityCore/helpers/resultCreators';
+export { getSchemaForAbilityResult, validateOrFail } from './lib/abilityCore/helpers/zod';
+export { isAbilityFailureResult } from './lib/abilityCore/helpers/typeGuards';
+export type { AbilityResultFailure, VincentPolicy } from './lib/types';
+export { assertSupportedAbilityVersion } from './lib/assertSupportedAbilityVersion';
+export { getPoliciesAndAppVersion } from './lib/policyCore/policyParameters/getOnchainPolicyParams';
+export { createDenyResult, getSchemaForPolicyResponseResult, isPolicyAllowResponse, isPolicyDenyResponse, validateOrDeny, } from './lib/policyCore/helpers';
+export { LIT_DATIL_PUBKEY_ROUTER_ADDRESS } from './lib/handlers/constants';
+//# sourceMappingURL=internal.d.ts.map

package/dist/src/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/internal.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AACtF,OAAO,EAAE,yBAAyB,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC1F,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEvE,OAAO,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAC;AAGpF,OAAO,EAAE,wBAAwB,EAAE,MAAM,0DAA0D,CAAC;AAGpG,OAAO,EACL,gBAAgB,EAChB,gCAAgC,EAChC,qBAAqB,EACrB,oBAAoB,EACpB,cAAc,GACf,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,+BAA+B,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/src/internal.js

@@ -0,0 +1,32 @@
+"use strict";
+// src/internal.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIT_DATIL_PUBKEY_ROUTER_ADDRESS = exports.validateOrDeny = exports.isPolicyDenyResponse = exports.isPolicyAllowResponse = exports.getSchemaForPolicyResponseResult = exports.createDenyResult = exports.getPoliciesAndAppVersion = exports.assertSupportedAbilityVersion = exports.isAbilityFailureResult = exports.validateOrFail = exports.getSchemaForAbilityResult = exports.createAbilitySuccessResult = exports.validatePolicies = exports.getPkpInfo = void 0;
+// Ability Core - Context + Helpers
+var helpers_1 = require("./lib/abilityCore/helpers");
+Object.defineProperty(exports, "getPkpInfo", { enumerable: true, get: function () { return helpers_1.getPkpInfo; } });
+var validatePolicies_1 = require("./lib/abilityCore/helpers/validatePolicies");
+Object.defineProperty(exports, "validatePolicies", { enumerable: true, get: function () { return validatePolicies_1.validatePolicies; } });
+var resultCreators_1 = require("./lib/abilityCore/helpers/resultCreators");
+Object.defineProperty(exports, "createAbilitySuccessResult", { enumerable: true, get: function () { return resultCreators_1.createAbilitySuccessResult; } });
+var zod_1 = require("./lib/abilityCore/helpers/zod");
+Object.defineProperty(exports, "getSchemaForAbilityResult", { enumerable: true, get: function () { return zod_1.getSchemaForAbilityResult; } });
+Object.defineProperty(exports, "validateOrFail", { enumerable: true, get: function () { return zod_1.validateOrFail; } });
+var typeGuards_1 = require("./lib/abilityCore/helpers/typeGuards");
+Object.defineProperty(exports, "isAbilityFailureResult", { enumerable: true, get: function () { return typeGuards_1.isAbilityFailureResult; } });
+var assertSupportedAbilityVersion_1 = require("./lib/assertSupportedAbilityVersion");
+Object.defineProperty(exports, "assertSupportedAbilityVersion", { enumerable: true, get: function () { return assertSupportedAbilityVersion_1.assertSupportedAbilityVersion; } });
+// Policy Core - Parameter Loading + Decoding
+var getOnchainPolicyParams_1 = require("./lib/policyCore/policyParameters/getOnchainPolicyParams");
+Object.defineProperty(exports, "getPoliciesAndAppVersion", { enumerable: true, get: function () { return getOnchainPolicyParams_1.getPoliciesAndAppVersion; } });
+// Policy Core - Evaluation Helpers
+var helpers_2 = require("./lib/policyCore/helpers");
+Object.defineProperty(exports, "createDenyResult", { enumerable: true, get: function () { return helpers_2.createDenyResult; } });
+Object.defineProperty(exports, "getSchemaForPolicyResponseResult", { enumerable: true, get: function () { return helpers_2.getSchemaForPolicyResponseResult; } });
+Object.defineProperty(exports, "isPolicyAllowResponse", { enumerable: true, get: function () { return helpers_2.isPolicyAllowResponse; } });
+Object.defineProperty(exports, "isPolicyDenyResponse", { enumerable: true, get: function () { return helpers_2.isPolicyDenyResponse; } });
+Object.defineProperty(exports, "validateOrDeny", { enumerable: true, get: function () { return helpers_2.validateOrDeny; } });
+// Constants
+var constants_1 = require("./lib/handlers/constants");
+Object.defineProperty(exports, "LIT_DATIL_PUBKEY_ROUTER_ADDRESS", { enumerable: true, get: function () { return constants_1.LIT_DATIL_PUBKEY_ROUTER_ADDRESS; } });
+//# sourceMappingURL=internal.js.map

package/dist/src/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../../src/internal.ts"],"names":[],"mappings":";AAAA,kBAAkB;;;AAElB,mCAAmC;AAEnC,qDAAuD;AAA9C,qGAAA,UAAU,OAAA;AAGnB,+EAA8E;AAArE,oHAAA,gBAAgB,OAAA;AACzB,2EAAsF;AAA7E,4HAAA,0BAA0B,OAAA;AACnC,qDAA0F;AAAjF,gHAAA,yBAAyB,OAAA;AAAE,qGAAA,cAAc,OAAA;AAClD,mEAA8E;AAArE,oHAAA,sBAAsB,OAAA;AAG/B,qFAAoF;AAA3E,8IAAA,6BAA6B,OAAA;AAEtC,6CAA6C;AAC7C,mGAAoG;AAA3F,kIAAA,wBAAwB,OAAA;AAEjC,mCAAmC;AACnC,oDAMkC;AALhC,2GAAA,gBAAgB,OAAA;AAChB,2HAAA,gCAAgC,OAAA;AAChC,gHAAA,qBAAqB,OAAA;AACrB,+GAAA,oBAAoB,OAAA;AACpB,yGAAA,cAAc,OAAA;AAGhB,YAAY;AACZ,sDAA2E;AAAlE,4HAAA,+BAA+B,OAAA"}

package/dist/src/lib/abilityCore/abilityConfig/context/abilityContext.d.ts

@@ -0,0 +1,28 @@
+import type { z } from 'zod';
+import type { PolicyEvaluationResultContext, AbilityExecutionPolicyContext, AbilityExecutionPolicyEvaluationResult, VincentPolicy } from '../../../types';
+import type { BaseAbilityContext, AbilityContext } from './types';
+/**
+ * Builds an execution-time AbilityContext for use inside `execute()` lifecycle methods.
+ * It upgrades the incoming external policy context with `commit()` methods derived
+ * from the ability's supported policies and schema definitions. Ensures commit calls
+ * are fully typed and validated internally.
+ */
+export declare function createExecutionAbilityContext<PolicyMapByPackageName extends Record<string, any>>(params: {
+    baseContext: BaseAbilityContext<AbilityExecutionPolicyEvaluationResult<PolicyMapByPackageName>>;
+    policiesByPackageName: PolicyMapByPackageName;
+}): AbilityContext<any, any, AbilityExecutionPolicyContext<PolicyMapByPackageName>>;
+/**
+ * Builds a precheck-time AbilityContext for use inside `precheck()` lifecycle methods.
+ * It includes only the evaluated policy metadata and denies commit access,
+ * ensuring developers don’t call commit prematurely. Enforces policy result typing.
+ */
+export declare function createPrecheckAbilityContext<PolicyMapByPackageName extends Record<string, {
+    __schemaTypes: {
+        evalAllowResultSchema?: z.ZodType;
+        evalDenyResultSchema?: z.ZodType;
+    };
+    vincentPolicy: VincentPolicy<any, any, any, any, any, any, any, any, any, any, any, any, any>;
+}>>(params: {
+    baseContext: BaseAbilityContext<PolicyEvaluationResultContext<PolicyMapByPackageName>>;
+}): AbilityContext<any, any, PolicyEvaluationResultContext<PolicyMapByPackageName>>;
+//# sourceMappingURL=abilityContext.d.ts.map

package/dist/src/lib/abilityCore/abilityConfig/context/abilityContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abilityContext.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/abilityCore/abilityConfig/context/abilityContext.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EACV,6BAA6B,EAC7B,6BAA6B,EAC7B,sCAAsC,EACtC,aAAa,EACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAIlE;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,sBAAsB,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAClD,MAAM,EAAE;IACR,WAAW,EAAE,kBAAkB,CAAC,sCAAsC,CAAC,sBAAsB,CAAC,CAAC,CAAC;IAChG,qBAAqB,EAAE,sBAAsB,CAAC;CAC/C,GAAG,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,6BAA6B,CAAC,sBAAsB,CAAC,CAAC,CA8BlF;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,sBAAsB,SAAS,MAAM,CACnC,MAAM,EACN;IACE,aAAa,EAAE;QACb,qBAAqB,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC;QAClC,oBAAoB,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC;KAClC,CAAC;IACF,aAAa,EAAE,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;CAC/F,CACF,EACD,MAAM,EAAE;IACR,WAAW,EAAE,kBAAkB,CAAC,6BAA6B,CAAC,sBAAsB,CAAC,CAAC,CAAC;CACxF,GAAG,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,6BAA6B,CAAC,sBAAsB,CAAC,CAAC,CAQlF"}

package/dist/src/lib/abilityCore/abilityConfig/context/abilityContext.js

@@ -0,0 +1,51 @@
+"use strict";
+// src/lib/abilityCore/abilityConfig/context/abilityContext.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecutionAbilityContext = createExecutionAbilityContext;
+exports.createPrecheckAbilityContext = createPrecheckAbilityContext;
+const resultCreators_1 = require("./resultCreators");
+/**
+ * Builds an execution-time AbilityContext for use inside `execute()` lifecycle methods.
+ * It upgrades the incoming external policy context with `commit()` methods derived
+ * from the ability's supported policies and schema definitions. Ensures commit calls
+ * are fully typed and validated internally.
+ */
+function createExecutionAbilityContext(params) {
+    const { baseContext, policiesByPackageName } = params;
+    const allowedPolicies = {};
+    for (const key of Object.keys(policiesByPackageName)) {
+        const k = key;
+        const entry = baseContext.policiesContext.allowedPolicies[k];
+        if (!entry)
+            continue;
+        allowedPolicies[k] = {
+            ...entry,
+        };
+    }
+    const upgradedPoliciesContext = {
+        evaluatedPolicies: baseContext.policiesContext.evaluatedPolicies,
+        allow: true,
+        deniedPolicy: undefined,
+        allowedPolicies,
+    };
+    return {
+        ...baseContext,
+        policiesContext: upgradedPoliciesContext,
+        succeed: resultCreators_1.createSuccess,
+        fail: resultCreators_1.createFailure,
+    };
+}
+/**
+ * Builds a precheck-time AbilityContext for use inside `precheck()` lifecycle methods.
+ * It includes only the evaluated policy metadata and denies commit access,
+ * ensuring developers don’t call commit prematurely. Enforces policy result typing.
+ */
+function createPrecheckAbilityContext(params) {
+    const { baseContext } = params;
+    return {
+        ...baseContext,
+        succeed: resultCreators_1.createSuccess,
+        fail: resultCreators_1.createFailure,
+    };
+}
+//# sourceMappingURL=abilityContext.js.map

package/dist/src/lib/abilityCore/abilityConfig/context/abilityContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abilityContext.js","sourceRoot":"","sources":["../../../../../../src/lib/abilityCore/abilityConfig/context/abilityContext.ts"],"names":[],"mappings":";AAAA,8DAA8D;;AAqB9D,sEAmCC;AAOD,oEAqBC;AAvED,qDAAgE;AAEhE;;;;;GAKG;AACH,SAAgB,6BAA6B,CAE3C,MAGD;IACC,MAAM,EAAE,WAAW,EAAE,qBAAqB,EAAE,GAAG,MAAM,CAAC;IAEtD,MAAM,eAAe,GACnB,EAA8E,CAAC;IAEjF,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,EAAE,CAAC;QACrD,MAAM,CAAC,GAAG,GAAmC,CAAC;QAC9C,MAAM,KAAK,GAAG,WAAW,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QAE7D,IAAI,CAAC,KAAK;YAAE,SAAS;QAEpB,eAAuB,CAAC,CAAC,CAAC,GAAG;YAC5B,GAAG,KAAK;SACT,CAAC;IACJ,CAAC;IAED,MAAM,uBAAuB,GAA0D;QACrF,iBAAiB,EAAE,WAAW,CAAC,eAAe,CAAC,iBAAiB;QAChE,KAAK,EAAE,IAAI;QACX,YAAY,EAAE,SAAkB;QAChC,eAAe;KAChB,CAAC;IAEF,OAAO;QACL,GAAG,WAAW;QACd,eAAe,EAAE,uBAAuB;QACxC,OAAO,EAAE,8BAA4E;QACrF,IAAI,EAAE,8BAAyE;KAChF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAgB,4BAA4B,CAW1C,MAED;IACC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC;IAE/B,OAAO;QACL,GAAG,WAAW;QACd,OAAO,EAAE,8BAA4E;QACrF,IAAI,EAAE,8BAAyE;KAChF,CAAC;AACJ,CAAC"}

package/dist/src/lib/abilityCore/abilityConfig/context/resultCreators.d.ts

@@ -0,0 +1,18 @@
+import type { ContextSuccess, ContextSuccessNoResult, ContextFailure, ContextFailureNoResult } from './types';
+/**
+ * Wraps a success result with payload
+ */
+export declare function createSuccess<T>(result: T): ContextSuccess<T>;
+/**
+ * Wraps a success result without payload
+ */
+export declare function createSuccessNoResult(): ContextSuccessNoResult;
+/**
+ * Wraps a failure result with payload
+ */
+export declare function createFailure<T>(result: T): ContextFailure<T>;
+/**
+ * Wraps a failure result without payload
+ */
+export declare function createFailureNoResult(): ContextFailureNoResult;
+//# sourceMappingURL=resultCreators.d.ts.map

package/dist/src/lib/abilityCore/abilityConfig/context/resultCreators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resultCreators.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/abilityCore/abilityConfig/context/resultCreators.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,cAAc,EACd,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAIjB;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAM7D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,sBAAsB,CAK9D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAM7D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,sBAAsB,CAM9D"}