@absolutejs/mcp 0.11.3 → 0.13.0

package/dist/manifest.js

@@ -63,22 +63,22 @@ var TypeSystemPolicy;
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var exports_value = {};
 __export(exports_value, {
-  IsUndefined: () => IsUndefined2,
-  IsUint8Array: () => IsUint8Array,
-  IsSymbol: () => IsSymbol,
-  IsString: () => IsString,
-  IsRegExp: () => IsRegExp,
-  IsObject: () => IsObject2,
-  IsNumber: () => IsNumber2,
-  IsNull: () => IsNull,
-  IsIterator: () => IsIterator,
-  IsFunction: () => IsFunction,
-  IsDate: () => IsDate,
-  IsBoolean: () => IsBoolean,
-  IsBigInt: () => IsBigInt,
-  IsAsyncIterator: () => IsAsyncIterator,
+  HasPropertyKey: () => HasPropertyKey,
   IsArray: () => IsArray2,
-  HasPropertyKey: () => HasPropertyKey
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsBigInt: () => IsBigInt,
+  IsBoolean: () => IsBoolean,
+  IsDate: () => IsDate,
+  IsFunction: () => IsFunction,
+  IsIterator: () => IsIterator,
+  IsNull: () => IsNull,
+  IsNumber: () => IsNumber2,
+  IsObject: () => IsObject2,
+  IsRegExp: () => IsRegExp,
+  IsString: () => IsString,
+  IsSymbol: () => IsSymbol,
+  IsUint8Array: () => IsUint8Array,
+  IsUndefined: () => IsUndefined2
 });
 function HasPropertyKey(value, key) {
   return key in value;
@@ -683,7 +683,7 @@ function Literal(value, options) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs
-function Boolean(options) {
+function Boolean2(options) {
   return CreateType({ [Kind]: "Boolean", type: "boolean" }, options);
 }
 
@@ -705,7 +705,7 @@ function String2(options) {
 // node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs
 function* FromUnion(syntax) {
   const trim = syntax.trim().replace(/"|'/g, "");
-  return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String2() : yield (() => {
+  return trim === "boolean" ? yield Boolean2() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String2() : yield (() => {
     const literals = trim.split("|").map((literal) => Literal(literal.trim()));
     return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
   })();
@@ -1097,57 +1097,57 @@ function Unknown(options) {
 // node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
 var exports_type = {};
 __export(exports_type, {
-  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError,
-  IsVoid: () => IsVoid2,
-  IsUnsafe: () => IsUnsafe2,
-  IsUnknown: () => IsUnknown2,
-  IsUnionLiteral: () => IsUnionLiteral,
-  IsUnion: () => IsUnion2,
-  IsUndefined: () => IsUndefined4,
-  IsUint8Array: () => IsUint8Array3,
-  IsTuple: () => IsTuple2,
-  IsTransform: () => IsTransform2,
-  IsThis: () => IsThis2,
-  IsTemplateLiteral: () => IsTemplateLiteral2,
-  IsSymbol: () => IsSymbol3,
-  IsString: () => IsString3,
-  IsSchema: () => IsSchema2,
-  IsRegExp: () => IsRegExp3,
-  IsRef: () => IsRef2,
-  IsRecursive: () => IsRecursive,
-  IsRecord: () => IsRecord2,
-  IsReadonly: () => IsReadonly2,
-  IsProperties: () => IsProperties,
-  IsPromise: () => IsPromise2,
-  IsOptional: () => IsOptional2,
-  IsObject: () => IsObject4,
-  IsNumber: () => IsNumber4,
-  IsNull: () => IsNull3,
-  IsNot: () => IsNot2,
-  IsNever: () => IsNever2,
-  IsMappedResult: () => IsMappedResult2,
-  IsMappedKey: () => IsMappedKey2,
-  IsLiteralValue: () => IsLiteralValue2,
-  IsLiteralString: () => IsLiteralString,
-  IsLiteralNumber: () => IsLiteralNumber,
-  IsLiteralBoolean: () => IsLiteralBoolean,
-  IsLiteral: () => IsLiteral2,
-  IsKindOf: () => IsKindOf2,
-  IsKind: () => IsKind2,
-  IsIterator: () => IsIterator3,
-  IsIntersect: () => IsIntersect2,
-  IsInteger: () => IsInteger2,
-  IsImport: () => IsImport,
-  IsFunction: () => IsFunction3,
-  IsDate: () => IsDate3,
-  IsConstructor: () => IsConstructor2,
-  IsComputed: () => IsComputed2,
-  IsBoolean: () => IsBoolean3,
-  IsBigInt: () => IsBigInt3,
-  IsAsyncIterator: () => IsAsyncIterator3,
-  IsArray: () => IsArray4,
+  IsAny: () => IsAny2,
   IsArgument: () => IsArgument2,
-  IsAny: () => IsAny2
+  IsArray: () => IsArray4,
+  IsAsyncIterator: () => IsAsyncIterator3,
+  IsBigInt: () => IsBigInt3,
+  IsBoolean: () => IsBoolean3,
+  IsComputed: () => IsComputed2,
+  IsConstructor: () => IsConstructor2,
+  IsDate: () => IsDate3,
+  IsFunction: () => IsFunction3,
+  IsImport: () => IsImport,
+  IsInteger: () => IsInteger2,
+  IsIntersect: () => IsIntersect2,
+  IsIterator: () => IsIterator3,
+  IsKind: () => IsKind2,
+  IsKindOf: () => IsKindOf2,
+  IsLiteral: () => IsLiteral2,
+  IsLiteralBoolean: () => IsLiteralBoolean,
+  IsLiteralNumber: () => IsLiteralNumber,
+  IsLiteralString: () => IsLiteralString,
+  IsLiteralValue: () => IsLiteralValue2,
+  IsMappedKey: () => IsMappedKey2,
+  IsMappedResult: () => IsMappedResult2,
+  IsNever: () => IsNever2,
+  IsNot: () => IsNot2,
+  IsNull: () => IsNull3,
+  IsNumber: () => IsNumber4,
+  IsObject: () => IsObject4,
+  IsOptional: () => IsOptional2,
+  IsPromise: () => IsPromise2,
+  IsProperties: () => IsProperties,
+  IsReadonly: () => IsReadonly2,
+  IsRecord: () => IsRecord2,
+  IsRecursive: () => IsRecursive,
+  IsRef: () => IsRef2,
+  IsRegExp: () => IsRegExp3,
+  IsSchema: () => IsSchema2,
+  IsString: () => IsString3,
+  IsSymbol: () => IsSymbol3,
+  IsTemplateLiteral: () => IsTemplateLiteral2,
+  IsThis: () => IsThis2,
+  IsTransform: () => IsTransform2,
+  IsTuple: () => IsTuple2,
+  IsUint8Array: () => IsUint8Array3,
+  IsUndefined: () => IsUndefined4,
+  IsUnion: () => IsUnion2,
+  IsUnionLiteral: () => IsUnionLiteral,
+  IsUnknown: () => IsUnknown2,
+  IsUnsafe: () => IsUnsafe2,
+  IsVoid: () => IsVoid2,
+  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError
 });
 class TypeGuardUnknownTypeError extends TypeBoxError {
 }
@@ -2498,68 +2498,68 @@ function Void(options) {
 // node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
 var exports_type2 = {};
 __export(exports_type2, {
-  Void: () => Void,
-  Uppercase: () => Uppercase,
-  Unsafe: () => Unsafe,
-  Unknown: () => Unknown,
-  Union: () => Union,
-  Undefined: () => Undefined,
-  Uncapitalize: () => Uncapitalize,
-  Uint8Array: () => Uint8Array2,
-  Tuple: () => Tuple,
-  Transform: () => Transform,
-  TemplateLiteral: () => TemplateLiteral,
-  Symbol: () => Symbol2,
-  String: () => String2,
-  ReturnType: () => ReturnType,
-  Rest: () => Rest,
-  Required: () => Required,
-  RegExp: () => RegExp2,
-  Ref: () => Ref,
-  Recursive: () => Recursive,
-  Record: () => Record,
-  ReadonlyOptional: () => ReadonlyOptional,
-  Readonly: () => Readonly,
-  Promise: () => Promise2,
-  Pick: () => Pick,
-  Partial: () => Partial,
-  Parameters: () => Parameters,
-  Optional: () => Optional,
-  Omit: () => Omit,
-  Object: () => Object2,
-  Number: () => Number2,
-  Null: () => Null,
-  Not: () => Not,
-  Never: () => Never,
-  Module: () => Module,
-  Mapped: () => Mapped,
-  Lowercase: () => Lowercase,
-  Literal: () => Literal,
-  KeyOf: () => KeyOf,
-  Iterator: () => Iterator,
-  Intersect: () => Intersect,
-  Integer: () => Integer,
-  Instantiate: () => Instantiate,
-  InstanceType: () => InstanceType,
-  Index: () => Index,
-  Function: () => Function,
-  Extract: () => Extract,
-  Extends: () => Extends,
-  Exclude: () => Exclude,
-  Enum: () => Enum,
-  Date: () => Date2,
-  ConstructorParameters: () => ConstructorParameters,
-  Constructor: () => Constructor,
-  Const: () => Const,
-  Composite: () => Composite,
-  Capitalize: () => Capitalize,
-  Boolean: () => Boolean,
-  BigInt: () => BigInt,
-  Awaited: () => Awaited,
-  AsyncIterator: () => AsyncIterator,
-  Array: () => Array2,
+  Any: () => Any,
   Argument: () => Argument,
-  Any: () => Any
+  Array: () => Array2,
+  AsyncIterator: () => AsyncIterator,
+  Awaited: () => Awaited,
+  BigInt: () => BigInt,
+  Boolean: () => Boolean2,
+  Capitalize: () => Capitalize,
+  Composite: () => Composite,
+  Const: () => Const,
+  Constructor: () => Constructor,
+  ConstructorParameters: () => ConstructorParameters,
+  Date: () => Date2,
+  Enum: () => Enum,
+  Exclude: () => Exclude,
+  Extends: () => Extends,
+  Extract: () => Extract,
+  Function: () => Function,
+  Index: () => Index,
+  InstanceType: () => InstanceType,
+  Instantiate: () => Instantiate,
+  Integer: () => Integer,
+  Intersect: () => Intersect,
+  Iterator: () => Iterator,
+  KeyOf: () => KeyOf,
+  Literal: () => Literal,
+  Lowercase: () => Lowercase,
+  Mapped: () => Mapped,
+  Module: () => Module,
+  Never: () => Never,
+  Not: () => Not,
+  Null: () => Null,
+  Number: () => Number2,
+  Object: () => Object2,
+  Omit: () => Omit,
+  Optional: () => Optional,
+  Parameters: () => Parameters,
+  Partial: () => Partial,
+  Pick: () => Pick,
+  Promise: () => Promise2,
+  Readonly: () => Readonly,
+  ReadonlyOptional: () => ReadonlyOptional,
+  Record: () => Record,
+  Recursive: () => Recursive,
+  Ref: () => Ref,
+  RegExp: () => RegExp2,
+  Required: () => Required,
+  Rest: () => Rest,
+  ReturnType: () => ReturnType,
+  String: () => String2,
+  Symbol: () => Symbol2,
+  TemplateLiteral: () => TemplateLiteral,
+  Transform: () => Transform,
+  Tuple: () => Tuple,
+  Uint8Array: () => Uint8Array2,
+  Uncapitalize: () => Uncapitalize,
+  Undefined: () => Undefined,
+  Union: () => Union,
+  Unknown: () => Unknown,
+  Unsafe: () => Unsafe,
+  Uppercase: () => Uppercase,
+  Void: () => Void
 });
 
 // node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
@@ -2718,6 +2718,79 @@ var serializedTool = Type.Object({
   input: jsonSchemaObject,
   kind: Type.Union([Type.Literal("runtime"), Type.Literal("workspace")])
 });
+var productId = Type.String({ pattern: "^[a-z][a-z0-9_-]{0,63}$" });
+var productCopy = {
+  description: Type.String({ minLength: 1 }),
+  id: productId,
+  title: Type.String({ minLength: 1 })
+};
+var productOperation = Type.Union([
+  Type.Literal("aggregate"),
+  Type.Literal("create"),
+  Type.Literal("delete"),
+  Type.Literal("detail"),
+  Type.Literal("list"),
+  Type.Literal("update")
+]);
+var productProjection = Type.Object({
+  blocks: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    category: Type.String({ minLength: 1 }),
+    componentExport: Type.String({ minLength: 1 }),
+    frameworks: Type.Optional(Type.Array(Type.Union(clientFrameworks.map((framework) => Type.Literal(framework))))),
+    props: jsonSchemaObject
+  }))),
+  connections: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    envKeys: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    kind: Type.Union([
+      Type.Literal("none"),
+      Type.Literal("oauth"),
+      Type.Literal("secret")
+    ]),
+    setupTool: Type.Optional(Type.String({ pattern: TOOL_NAME_PATTERN.source })),
+    testTool: Type.Optional(Type.String({ pattern: TOOL_NAME_PATTERN.source }))
+  }))),
+  dataSources: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    operations: Type.Array(productOperation, { minItems: 1 }),
+    schema: jsonSchemaObject,
+    tools: Type.Optional(Type.Partial(Type.Object({
+      aggregate: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      create: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      delete: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      detail: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      list: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      update: Type.String({ pattern: TOOL_NAME_PATTERN.source })
+    })))
+  }))),
+  events: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    schema: jsonSchemaObject,
+    source: Type.Union([
+      Type.Literal("data"),
+      Type.Literal("package"),
+      Type.Literal("ui"),
+      Type.Literal("webhook")
+    ])
+  }))),
+  healthChecks: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    tool: Type.String({ pattern: TOOL_NAME_PATTERN.source })
+  }))),
+  releaseChecks: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    healthCheckIds: Type.Optional(Type.Array(productId)),
+    severity: Type.Union([
+      Type.Literal("blocking"),
+      Type.Literal("warning")
+    ])
+  }))),
+  workflowActions: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    tool: Type.String({ pattern: TOOL_NAME_PATTERN.source })
+  })))
+});
 var manifestSchema = Type.Object({
   contract: Type.Union([Type.Literal(1), Type.Literal(2)]),
   discovery: Type.Optional(Type.Object({
@@ -2743,6 +2816,14 @@ var manifestSchema = Type.Object({
     tagline: Type.String({ minLength: 1 })
   }),
   implements: Type.Optional(Type.Array(adapterImplementation)),
+  integration: Type.Optional(Type.Object({
+    description: Type.Optional(Type.String({ minLength: 1 })),
+    mode: Type.Union([
+      Type.Literal("adapter"),
+      Type.Literal("code-first"),
+      Type.Literal("recipe")
+    ])
+  })),
   lifecycle: Type.Optional(Type.Array(lifecycleStep)),
   presets: Type.Optional(Type.Array(Type.Object({
     description: Type.Optional(Type.String()),
@@ -2750,6 +2831,7 @@ var manifestSchema = Type.Object({
     title: Type.String(),
     values: Type.Record(Type.String(), Type.Unknown())
   }))),
+  product: Type.Optional(productProjection),
   requires: Type.Optional(manifestRequirements),
   settings: jsonSchemaObject,
   slots: Type.Optional(Type.Record(Type.String(), adapterSlot)),
@@ -2779,7 +2861,9 @@ var manifest = defineManifest()({
     tagline: "Let AI assistants connect to your site and use its tools."
   },
   requires: {
-    peers: [{ name: "elysia", range: ">=1.1.0", reason: "plugin host" }]
+    peers: [
+      { name: "elysia", range: "^2.0.0-beta.6", reason: "plugin host" }
+    ]
   },
   settings: Type.Object({
     instructions: Type.Optional(Type.String({

package/dist/manifest.json

@@ -35,7 +35,7 @@
 		"peers": [
 			{
 				"name": "elysia",
-				"range": ">=1.1.0",
+				"range": "^2.0.0-beta.6",
 				"reason": "plugin host"
 			}
 		]

package/dist/src/commerce.d.ts

@@ -0,0 +1,50 @@
+/** Host commerce eligibility, not payment authorization. All inputs are
+ * server-owned; never derive a permissive profile from clientInfo alone. */
+export declare const COMMERCE_POLICY_VERSION = "2026-09-10.1";
+export declare const COMMERCE_POLICY_SOURCES: Readonly<{
+    claude: "https://support.claude.com/en/articles/13454812-use-interactive-connectors-in-claude";
+    chatgpt: "https://developers.openai.com/plugins/app-guidelines#commerce-and-monetization";
+    chatgptCheckout: "https://developers.openai.com/plugins/build/monetization";
+    cursorMarketplace: "https://cursor.com/marketplace-publisher-terms";
+}>;
+export type CommerceAction = "entitlement_status" | "informational_link" | "paid_access" | "pricing" | "external_checkout" | "saved_method_purchase" | "new_method_collection" | "subscription" | "automatic_refill";
+export type CommerceCategory = "physical_goods" | "digital_service" | "usage_credits" | "subscription";
+export type CommerceProfile = "claude-interactive" | "chatgpt-plugin" | "cursor-marketplace" | "direct-mcp" | "self-hosted" | "unknown";
+export type CommerceRequirement = {
+    action: CommerceAction;
+    /** All product categories this tool can expose, including every cart line.
+     * Dynamic catalogs must be classified by the server before registration. */
+    categories: readonly CommerceCategory[];
+};
+export type CommerceReview = {
+    id: string;
+    profile: CommerceProfile;
+    actions: readonly CommerceAction[];
+    categories: readonly CommerceCategory[];
+    reviewedAt: string;
+    expiresAt: string;
+    sourceUrls: readonly string[];
+};
+export type CommerceContext = {
+    /** Ambiguous channels are evaluated as the intersection of their rules. */
+    profiles: readonly CommerceProfile[];
+    reviews?: readonly CommerceReview[];
+    /** Reviewed and tested capabilities; these do not establish permission. */
+    capabilities?: {
+        externalLinks?: boolean;
+        interactiveUi?: boolean;
+        nativePaymentSheet?: boolean;
+    };
+};
+export type CommerceDecision = {
+    allowed: boolean;
+    status: "permitted" | "restricted" | "unverified";
+    reason: string;
+    policyVersion: string;
+    sourceUrls: string[];
+    reviewIds: string[];
+};
+/** Published restrictions cannot be overridden by a deployment review.
+ * Unverified paths need explicit, fresh server-side review evidence. */
+export declare const evaluateCommerce: (req: CommerceRequirement, context: CommerceContext, now?: Date) => CommerceDecision;
+export { createCreditBalanceTool, type McpCreditBalance } from "./creditStatus";

package/dist/src/creditStatus.d.ts

@@ -0,0 +1,13 @@
+import type { McpTool } from "./types";
+/** Service credits, not currency or the host model's token usage. */
+export type McpCreditBalance = {
+    allowance: number;
+    consumed: number;
+    remaining: number;
+    periodEnd: string | null;
+};
+/** Account identity belongs in the bound reader, never model input. Keep this
+ * tool outside paid-work balance gates so exhausted users can recover. */
+export declare const createCreditBalanceTool: (options: {
+    read: () => McpCreditBalance | Promise<McpCreditBalance>;
+}) => McpTool;

package/dist/src/index.d.ts

@@ -42,3 +42,5 @@ export { createSessionRegistry, type SessionRegistry } from "./sessions";
 export { createMemoryMcpTaskStore, publicMcpTask } from "./tasks";
 export { createPostgresMcpSessionStore, createPostgresMcpTaskStore, mcpPostgresSchemaSql, type McpSqlClient, type McpSqlResult, } from "./postgres";
 export type { McpAgencyOptions, McpAudioContent, McpElicitAnswer, McpElicitationRequest, McpElicitBus, McpElicitResult, McpFormElicitationRequest, McpSessionStore, McpAuthResult, McpCallGate, McpCallMeta, McpContent, McpImageContent, McpPromptArgument, McpPromptDefinition, McpPrompts, McpResource, McpResourceLink, McpResources, McpServerConfig, McpServerInfo, McpTextContent, McpTask, McpTaskStatus, McpTaskStore, McpTasksOptions, McpTool, McpToolAnnotations, McpToolCallContext, McpToolContext, McpToolRegistry, McpToolResult, McpToolReturn, McpUrlElicitationRequest, } from "./types";
+export * from "./commerce";
+export { createCreditBalanceTool, type McpCreditBalance } from "./creditStatus";

package/dist/src/types.d.ts

@@ -1,3 +1,4 @@
+import type { CommerceContext, CommerceRequirement } from "./commerce";
 import type { Agency, AgentActor } from "@absolutejs/agency";
 import type { ToolAuthorization } from "@absolutejs/manifest";
 /** MCP behaviour hints, passed straight through to the client on `tools/list`.
@@ -122,6 +123,8 @@ export type McpToolCallContext = {
 };
 /** One callable tool. `inputSchema` is a JSON Schema object. */
 export type McpTool = {
+    /** Server-owned commerce classification; fails closed without commerce context. */
+    commerce?: CommerceRequirement;
     annotations?: McpToolAnnotations;
     /** OpenID AuthZEN COAZ opt-in marker. When true, inputSchema MUST carry an
      *  `x-coaz-mapping`; hosts should evaluate it before invoking the handler. */
@@ -265,6 +268,12 @@ export type McpServerInfo = {
     version: string;
 };
 export type McpServerConfig<Caller> = {
+    /** Resolve trusted deployment policy afresh for discovery and execution.
+     * Does not replace agency approval, ownership, or payment confirmation. */
+    commerce?: (context: {
+        caller: Caller;
+        name: string;
+    }) => CommerceContext | Promise<CommerceContext>;
     /** Per-tool action policy enforcement, approval, leases, and receipts. */
     agency?: McpAgencyOptions<Caller>;
     /** Resolve the request into a caller, or a reason for the 401. The package