@frontmcp/sdk 0.1.0

package/src/records/app.record.d.ts

@@ -0,0 +1,19 @@
+import { Token, Type } from '../interfaces';
+import { LocalAppMetadata, RemoteAppMetadata } from '../metadata';
+import { AppEntry } from '../entries';
+export declare enum AppKind {
+    LOCAL_CLASS = "LOCAL_CLASS",
+    REMOTE_VALUE = "REMOTE_VALUE"
+}
+export type AppClassToken = {
+    kind: AppKind.LOCAL_CLASS;
+    provide: Type<AppEntry>;
+    metadata: LocalAppMetadata;
+};
+export type AppValue = {
+    kind: AppKind.REMOTE_VALUE;
+    provide: Token<AppEntry>;
+    useValue: AppEntry;
+    metadata: RemoteAppMetadata;
+};
+export type AppRecord = AppClassToken | AppValue;

package/src/records/app.record.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppKind = void 0;
+var AppKind;
+(function (AppKind) {
+    AppKind["LOCAL_CLASS"] = "LOCAL_CLASS";
+    AppKind["REMOTE_VALUE"] = "REMOTE_VALUE";
+})(AppKind || (exports.AppKind = AppKind = {}));
+//# sourceMappingURL=app.record.js.map

package/src/records/app.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.record.js","sourceRoot":"","sources":["../../../src/records/app.record.ts"],"names":[],"mappings":";;;AAIA,IAAY,OAGX;AAHD,WAAY,OAAO;IACjB,sCAA2B,CAAA;IAC3B,wCAA6B,CAAA;AAC/B,CAAC,EAHW,OAAO,uBAAP,OAAO,QAGlB","sourcesContent":["import { Token, Type } from '../interfaces';\nimport { LocalAppMetadata, RemoteAppMetadata } from '../metadata';\nimport { AppEntry } from '../entries';\n\nexport enum AppKind {\n  LOCAL_CLASS = 'LOCAL_CLASS',\n  REMOTE_VALUE = 'REMOTE_VALUE',\n}\n\nexport type AppClassToken = {\n  kind: AppKind.LOCAL_CLASS;\n  provide: Type<AppEntry>;\n  metadata: LocalAppMetadata\n};\n\nexport type AppValue = {\n  kind: AppKind.REMOTE_VALUE;\n  provide: Token<AppEntry>;\n  useValue: AppEntry;\n  metadata: RemoteAppMetadata\n};\n\nexport type AppRecord =\n  | AppClassToken\n  | AppValue\n"]}

package/src/records/auth-provider.record.d.ts

@@ -0,0 +1,37 @@
+import { ClassType, FrontMcpAuth, Token, Type, ValueType } from '../interfaces';
+import { AuthProviderMetadata } from '../metadata';
+import { AuthOptions } from '../types';
+export declare enum AuthProviderKind {
+    CLASS_TOKEN = "CLASS_TOKEN",
+    CLASS = "CLASS",
+    VALUE = "VALUE",
+    FACTORY = "FACTORY",
+    PRIMARY = "PRIMARY"
+}
+export interface AuthProviderClassTokenRecord {
+    kind: AuthProviderKind.CLASS_TOKEN;
+    provide: Type;
+    metadata: AuthProviderMetadata;
+}
+export interface AuthProviderClassRecord extends ClassType<any> {
+    kind: AuthProviderKind.CLASS;
+    metadata: AuthProviderMetadata;
+}
+export interface AuthProviderValueRecord extends ValueType<any> {
+    kind: AuthProviderKind.VALUE;
+    metadata: AuthProviderMetadata;
+}
+export interface AuthProviderFactoryRecord {
+    kind: AuthProviderKind.FACTORY;
+    provide: Token;
+    inject: () => readonly Token[];
+    useFactory: (...args: any[]) => any | Promise<any>;
+    metadata: AuthProviderMetadata;
+}
+export type PrimaryAuthRecord = {
+    kind: AuthProviderKind.PRIMARY;
+    provide: Token<FrontMcpAuth>;
+    useValue: FrontMcpAuth;
+    metadata: AuthOptions;
+};
+export type AuthProviderRecord = AuthProviderClassTokenRecord | AuthProviderClassRecord | AuthProviderValueRecord | AuthProviderFactoryRecord | PrimaryAuthRecord;

package/src/records/auth-provider.record.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthProviderKind = void 0;
+var AuthProviderKind;
+(function (AuthProviderKind) {
+    AuthProviderKind["CLASS_TOKEN"] = "CLASS_TOKEN";
+    AuthProviderKind["CLASS"] = "CLASS";
+    AuthProviderKind["VALUE"] = "VALUE";
+    AuthProviderKind["FACTORY"] = "FACTORY";
+    AuthProviderKind["PRIMARY"] = "PRIMARY";
+})(AuthProviderKind || (exports.AuthProviderKind = AuthProviderKind = {}));
+//# sourceMappingURL=auth-provider.record.js.map

package/src/records/auth-provider.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-provider.record.js","sourceRoot":"","sources":["../../../src/records/auth-provider.record.ts"],"names":[],"mappings":";;;AAIA,IAAY,gBAMX;AAND,WAAY,gBAAgB;IAC1B,+CAA2B,CAAA;IAC3B,mCAAe,CAAA;IACf,mCAAe,CAAA;IACf,uCAAmB,CAAA;IACnB,uCAAmB,CAAA;AACrB,CAAC,EANW,gBAAgB,gCAAhB,gBAAgB,QAM3B","sourcesContent":["import { ClassType, FrontMcpAuth, Token, Type, ValueType } from '../interfaces';\nimport { AuthProviderMetadata } from '../metadata';\nimport { AuthOptions } from '../types';\n\nexport enum AuthProviderKind {\n  CLASS_TOKEN = 'CLASS_TOKEN',\n  CLASS = 'CLASS',\n  VALUE = 'VALUE',\n  FACTORY = 'FACTORY',\n  PRIMARY = 'PRIMARY',\n}\n\nexport interface AuthProviderClassTokenRecord {\n  kind: AuthProviderKind.CLASS_TOKEN;\n  provide: Type,\n  metadata: AuthProviderMetadata;\n}\n\nexport interface AuthProviderClassRecord extends ClassType<any> {\n  kind: AuthProviderKind.CLASS;\n  metadata: AuthProviderMetadata;\n}\n\nexport interface AuthProviderValueRecord extends ValueType<any> {\n  kind: AuthProviderKind.VALUE;\n  metadata: AuthProviderMetadata;\n}\n\nexport interface AuthProviderFactoryRecord {\n  kind: AuthProviderKind.FACTORY;\n  provide: Token;\n  inject: () => readonly Token[];\n  useFactory: (...args: any[]) => any | Promise<any>;\n  metadata: AuthProviderMetadata;\n}\n\nexport type PrimaryAuthRecord = {\n  kind: AuthProviderKind.PRIMARY;\n  provide: Token<FrontMcpAuth>;\n  useValue: FrontMcpAuth;\n  metadata: AuthOptions;\n};\n\n\nexport type AuthProviderRecord =\n  | AuthProviderClassTokenRecord\n  | AuthProviderClassRecord\n  | AuthProviderValueRecord\n  | AuthProviderFactoryRecord\n  | PrimaryAuthRecord\n\n\n"]}

package/src/records/flow.record.d.ts

@@ -0,0 +1,11 @@
+import { FlowType } from '../interfaces';
+import { FlowMetadata } from '../metadata';
+export declare enum FlowKind {
+    CLASS_TOKEN = "CLASS_TOKEN"
+}
+export type FlowClassToken = {
+    kind: FlowKind.CLASS_TOKEN;
+    provide: FlowType;
+    metadata: FlowMetadata<never>;
+};
+export type FlowRecord = FlowClassToken;

package/src/records/flow.record.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowKind = void 0;
+var FlowKind;
+(function (FlowKind) {
+    FlowKind["CLASS_TOKEN"] = "CLASS_TOKEN";
+})(FlowKind || (exports.FlowKind = FlowKind = {}));
+//# sourceMappingURL=flow.record.js.map

package/src/records/flow.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.record.js","sourceRoot":"","sources":["../../../src/records/flow.record.ts"],"names":[],"mappings":";;;AAGA,IAAY,QAEX;AAFD,WAAY,QAAQ;IAClB,uCAA2B,CAAA;AAC7B,CAAC,EAFW,QAAQ,wBAAR,QAAQ,QAEnB","sourcesContent":["import { FlowType } from '../interfaces';\nimport { FlowMetadata } from '../metadata';\n\nexport enum FlowKind {\n  CLASS_TOKEN = 'CLASS_TOKEN',\n}\n\nexport type FlowClassToken = {\n  kind: FlowKind.CLASS_TOKEN;\n  provide: FlowType;\n  metadata: FlowMetadata<never>\n};\n\nexport type FlowRecord =\n  | FlowClassToken\n"]}

package/src/records/index.d.ts

@@ -0,0 +1,11 @@
+export * from './scope.record';
+export * from './flow.record';
+export * from './app.record';
+export * from './provider.record';
+export * from './auth-provider.record';
+export * from './plugin.record';
+export * from './adapter.record';
+export * from './tool.record';
+export * from './resource.record';
+export * from './prompt.record';
+export * from './logger.record';

package/src/records/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./scope.record"), exports);
+tslib_1.__exportStar(require("./flow.record"), exports);
+tslib_1.__exportStar(require("./app.record"), exports);
+tslib_1.__exportStar(require("./provider.record"), exports);
+tslib_1.__exportStar(require("./auth-provider.record"), exports);
+tslib_1.__exportStar(require("./plugin.record"), exports);
+tslib_1.__exportStar(require("./adapter.record"), exports);
+tslib_1.__exportStar(require("./tool.record"), exports);
+tslib_1.__exportStar(require("./resource.record"), exports);
+tslib_1.__exportStar(require("./prompt.record"), exports);
+tslib_1.__exportStar(require("./logger.record"), exports);
+//# sourceMappingURL=index.js.map

package/src/records/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/records/index.ts"],"names":[],"mappings":";;;AAAA,yDAA+B;AAC/B,wDAA8B;AAC9B,uDAA6B;AAC7B,4DAAkC;AAClC,iEAAuC;AACvC,0DAAgC;AAChC,2DAAiC;AAEjC,wDAA8B;AAC9B,4DAAkC;AAClC,0DAAgC;AAChC,0DAAgC","sourcesContent":["export * from './scope.record';\nexport * from './flow.record';\nexport * from './app.record';\nexport * from './provider.record';\nexport * from './auth-provider.record';\nexport * from './plugin.record';\nexport * from './adapter.record';\n\nexport * from './tool.record';\nexport * from './resource.record';\nexport * from './prompt.record';\nexport * from './logger.record';"]}

package/src/records/logger.record.d.ts

@@ -0,0 +1,11 @@
+import { LogTransportInterface, Type } from '../interfaces';
+import { LogTransportMetadata } from '@frontmcp/sdk';
+export declare enum LoggerKind {
+    CLASS_TOKEN = "CLASS_TOKEN"
+}
+export type LoggerClassToken = {
+    kind: LoggerKind.CLASS_TOKEN;
+    provide: Type<LogTransportInterface>;
+    metadata: LogTransportMetadata;
+};
+export type LoggerRecord = LoggerClassToken;

package/src/records/logger.record.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerKind = void 0;
+var LoggerKind;
+(function (LoggerKind) {
+    LoggerKind["CLASS_TOKEN"] = "CLASS_TOKEN";
+})(LoggerKind || (exports.LoggerKind = LoggerKind = {}));
+//# sourceMappingURL=logger.record.js.map

package/src/records/logger.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.record.js","sourceRoot":"","sources":["../../../src/records/logger.record.ts"],"names":[],"mappings":";;;AAGA,IAAY,UAEX;AAFD,WAAY,UAAU;IACpB,yCAA2B,CAAA;AAC7B,CAAC,EAFW,UAAU,0BAAV,UAAU,QAErB","sourcesContent":["import { LogTransportInterface, Type } from '../interfaces';\nimport { LogTransportMetadata } from '@frontmcp/sdk';\n\nexport enum LoggerKind {\n  CLASS_TOKEN = 'CLASS_TOKEN',\n}\n\nexport type LoggerClassToken = {\n  kind: LoggerKind.CLASS_TOKEN;\n  provide: Type<LogTransportInterface>;\n  metadata: LogTransportMetadata\n};\n\nexport type LoggerRecord =\n  | LoggerClassToken\n"]}

package/src/records/plugin.record.d.ts

@@ -0,0 +1,21 @@
+import { ClassType, FactoryType, Type } from '../interfaces';
+import { PluginMetadata } from '../metadata';
+export declare enum PluginKind {
+    CLASS_TOKEN = "CLASS_TOKEN",
+    CLASS = "CLASS",
+    FACTORY = "FACTORY"
+}
+export interface PluginClassTokenRecord {
+    kind: PluginKind.CLASS_TOKEN;
+    provide: Type;
+    metadata: PluginMetadata;
+}
+export interface PluginClassRecord extends ClassType<any> {
+    kind: PluginKind.CLASS;
+    metadata: PluginMetadata;
+}
+export interface PluginFactoryRecord extends FactoryType<any, any[]> {
+    kind: PluginKind.FACTORY;
+    metadata: PluginMetadata;
+}
+export type PluginRecord = PluginClassTokenRecord | PluginClassRecord | PluginFactoryRecord;

package/src/records/plugin.record.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginKind = void 0;
+var PluginKind;
+(function (PluginKind) {
+    PluginKind["CLASS_TOKEN"] = "CLASS_TOKEN";
+    PluginKind["CLASS"] = "CLASS";
+    PluginKind["FACTORY"] = "FACTORY";
+})(PluginKind || (exports.PluginKind = PluginKind = {}));
+;
+//# sourceMappingURL=plugin.record.js.map

package/src/records/plugin.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.record.js","sourceRoot":"","sources":["../../../src/records/plugin.record.ts"],"names":[],"mappings":";;;AAGA,IAAY,UAIX;AAJD,WAAY,UAAU;IACpB,yCAA2B,CAAA;IAC3B,6BAAe,CAAA;IACf,iCAAmB,CAAA;AACrB,CAAC,EAJW,UAAU,0BAAV,UAAU,QAIrB;AAgBA,CAAC","sourcesContent":["import { ClassType, FactoryType, Type } from '../interfaces';\nimport { PluginMetadata } from '../metadata';\n\nexport enum PluginKind {\n  CLASS_TOKEN = 'CLASS_TOKEN',\n  CLASS = 'CLASS',\n  FACTORY = 'FACTORY',\n}\n\nexport interface PluginClassTokenRecord {\n  kind: PluginKind.CLASS_TOKEN;\n  provide: Type,\n  metadata: PluginMetadata;\n}\n\nexport interface PluginClassRecord extends ClassType<any> {\n  kind: PluginKind.CLASS;\n  metadata: PluginMetadata;\n}\n\nexport interface PluginFactoryRecord extends FactoryType<any, any[]> {\n  kind: PluginKind.FACTORY;\n  metadata: PluginMetadata;\n};\n\nexport type PluginRecord =\n  | PluginClassTokenRecord\n  | PluginClassRecord\n  | PluginFactoryRecord\n\n\n"]}

package/src/records/prompt.record.d.ts

@@ -0,0 +1,18 @@
+import { Type } from '../interfaces';
+import { PromptMetadata } from '../metadata';
+import { PromptEntry } from '../entries';
+export declare enum PromptKind {
+    CLASS_TOKEN = "CLASS_TOKEN",
+    FUNCTION = "FUNCTION"
+}
+export type PromptClassTokenRecord = {
+    kind: PromptKind.CLASS_TOKEN;
+    provide: Type<PromptEntry>;
+    metadata: PromptMetadata;
+};
+export type PromptFunctionTokenRecord = {
+    kind: PromptKind.FUNCTION;
+    provide: (...args: any[]) => any | Promise<any>;
+    metadata: PromptMetadata;
+};
+export type PromptRecord = PromptClassTokenRecord | PromptFunctionTokenRecord;

package/src/records/prompt.record.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptKind = void 0;
+var PromptKind;
+(function (PromptKind) {
+    PromptKind["CLASS_TOKEN"] = "CLASS_TOKEN";
+    PromptKind["FUNCTION"] = "FUNCTION";
+})(PromptKind || (exports.PromptKind = PromptKind = {}));
+//# sourceMappingURL=prompt.record.js.map

package/src/records/prompt.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.record.js","sourceRoot":"","sources":["../../../src/records/prompt.record.ts"],"names":[],"mappings":";;;AAIA,IAAY,UAGX;AAHD,WAAY,UAAU;IACpB,yCAA2B,CAAA;IAC3B,mCAAqB,CAAA;AACvB,CAAC,EAHW,UAAU,0BAAV,UAAU,QAGrB","sourcesContent":["import { Type } from '../interfaces';\nimport { PromptMetadata } from '../metadata';\nimport { PromptEntry } from '../entries';\n\nexport enum PromptKind {\n  CLASS_TOKEN = 'CLASS_TOKEN',\n  FUNCTION = 'FUNCTION',\n}\n\nexport type PromptClassTokenRecord = {\n  kind: PromptKind.CLASS_TOKEN;\n  provide: Type<PromptEntry>;\n  metadata: PromptMetadata\n};\n\nexport type PromptFunctionTokenRecord = {\n  kind: PromptKind.FUNCTION;\n  provide: (...args: any[]) => any | Promise<any>;\n  metadata: PromptMetadata\n};\n\nexport type PromptRecord =\n  | PromptClassTokenRecord\n  | PromptFunctionTokenRecord;\n"]}

package/src/records/provider.record.d.ts

@@ -0,0 +1,36 @@
+import { ClassType, Token, Type, ValueType } from '../interfaces';
+import { ProviderMetadata } from '../metadata';
+export declare enum ProviderKind {
+    CLASS_TOKEN = "CLASS_TOKEN",
+    CLASS = "CLASS",
+    VALUE = "VALUE",
+    FACTORY = "FACTORY",
+    INJECTED = "INJECTED"
+}
+export interface ProviderClassTokenRecord {
+    kind: ProviderKind.CLASS_TOKEN;
+    provide: Type;
+    metadata: ProviderMetadata;
+}
+export interface ProviderClassRecord extends ClassType<any> {
+    kind: ProviderKind.CLASS;
+    metadata: ProviderMetadata;
+}
+export interface ProviderValueRecord extends ValueType<any> {
+    kind: ProviderKind.VALUE;
+    metadata: ProviderMetadata;
+}
+export interface ProviderFactoryRecord {
+    kind: ProviderKind.FACTORY;
+    provide: Token;
+    inject: () => readonly Token[];
+    useFactory: (...args: any[]) => any | Promise<any>;
+    metadata: ProviderMetadata;
+}
+export interface ProviderInjectedRecord {
+    kind: ProviderKind.INJECTED;
+    provide: Token;
+    value: any;
+    metadata: ProviderMetadata;
+}
+export type ProviderRecord = ProviderClassTokenRecord | ProviderClassRecord | ProviderValueRecord | ProviderFactoryRecord | ProviderInjectedRecord;

package/src/records/provider.record.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderKind = void 0;
+var ProviderKind;
+(function (ProviderKind) {
+    ProviderKind["CLASS_TOKEN"] = "CLASS_TOKEN";
+    ProviderKind["CLASS"] = "CLASS";
+    ProviderKind["VALUE"] = "VALUE";
+    ProviderKind["FACTORY"] = "FACTORY";
+    ProviderKind["INJECTED"] = "INJECTED";
+})(ProviderKind || (exports.ProviderKind = ProviderKind = {}));
+;
+;
+//# sourceMappingURL=provider.record.js.map

package/src/records/provider.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.record.js","sourceRoot":"","sources":["../../../src/records/provider.record.ts"],"names":[],"mappings":";;;AAGA,IAAY,YAMX;AAND,WAAY,YAAY;IACtB,2CAA2B,CAAA;IAC3B,+BAAe,CAAA;IACf,+BAAe,CAAA;IACf,mCAAmB,CAAA;IACnB,qCAAqB,CAAA;AACvB,CAAC,EANW,YAAY,4BAAZ,YAAY,QAMvB;AAwBA,CAAC;AAOD,CAAC","sourcesContent":["import { ClassType, Token, Type, ValueType } from '../interfaces';\nimport { ProviderMetadata } from '../metadata';\n\nexport enum ProviderKind {\n  CLASS_TOKEN = 'CLASS_TOKEN',\n  CLASS = 'CLASS',\n  VALUE = 'VALUE',\n  FACTORY = 'FACTORY',\n  INJECTED = 'INJECTED',\n}\n\nexport interface ProviderClassTokenRecord {\n  kind: ProviderKind.CLASS_TOKEN;\n  provide: Type,\n  metadata: ProviderMetadata;\n}\n\nexport interface ProviderClassRecord extends ClassType<any> {\n  kind: ProviderKind.CLASS;\n  metadata: ProviderMetadata;\n}\n\nexport interface ProviderValueRecord extends ValueType<any> {\n  kind: ProviderKind.VALUE;\n  metadata: ProviderMetadata;\n}\n\nexport interface ProviderFactoryRecord {\n  kind: ProviderKind.FACTORY;\n  provide: Token;\n  inject: () => readonly Token[];\n  useFactory: (...args: any[]) => any | Promise<any>;\n  metadata: ProviderMetadata;\n};\n\nexport interface ProviderInjectedRecord {\n  kind: ProviderKind.INJECTED;\n  provide: Token;\n  value: any;\n  metadata: ProviderMetadata;\n};\n\nexport type ProviderRecord =\n  | ProviderClassTokenRecord\n  | ProviderClassRecord\n  | ProviderValueRecord\n  | ProviderFactoryRecord\n  | ProviderInjectedRecord;\n\n\n"]}

package/src/records/resource.record.d.ts

@@ -0,0 +1,18 @@
+import { Type } from '../interfaces';
+import { ResourceMetadata } from '../metadata';
+import { ResourceEntry } from '../entries';
+export declare enum ResourceKind {
+    CLASS_TOKEN = "CLASS_TOKEN",
+    FUNCTION = "FUNCTION"
+}
+export type ResourceClassTokenRecord = {
+    kind: ResourceKind.CLASS_TOKEN;
+    provide: Type<ResourceEntry>;
+    metadata: ResourceMetadata;
+};
+export type ResourceFunctionRecord = {
+    kind: ResourceKind.FUNCTION;
+    provide: (...args: any[]) => any | Promise<any>;
+    metadata: ResourceMetadata;
+};
+export type ResourceRecord = ResourceClassTokenRecord | ResourceFunctionRecord;

package/src/records/resource.record.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceKind = void 0;
+var ResourceKind;
+(function (ResourceKind) {
+    ResourceKind["CLASS_TOKEN"] = "CLASS_TOKEN";
+    ResourceKind["FUNCTION"] = "FUNCTION";
+})(ResourceKind || (exports.ResourceKind = ResourceKind = {}));
+// TODO: support resource templates
+// ResourceTemplateKind,
+// ResourceTemplateClassToken,
+// ResourceTemplateFunction,
+// ResourceTemplateRecord,
+//# sourceMappingURL=resource.record.js.map

package/src/records/resource.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.record.js","sourceRoot":"","sources":["../../../src/records/resource.record.ts"],"names":[],"mappings":";;;AAIA,IAAY,YAGX;AAHD,WAAY,YAAY;IACtB,2CAA2B,CAAA;IAC3B,qCAAqB,CAAA;AACvB,CAAC,EAHW,YAAY,4BAAZ,YAAY,QAGvB;AAmBD,mCAAmC;AACnC,wBAAwB;AACxB,8BAA8B;AAC9B,4BAA4B;AAC5B,0BAA0B","sourcesContent":["import { Type } from '../interfaces';\nimport { ResourceMetadata } from '../metadata';\nimport { ResourceEntry } from '../entries';\n\nexport enum ResourceKind {\n  CLASS_TOKEN = 'CLASS_TOKEN',\n  FUNCTION = 'FUNCTION',\n}\n\nexport type ResourceClassTokenRecord = {\n  kind: ResourceKind.CLASS_TOKEN;\n  provide: Type<ResourceEntry>;\n  metadata: ResourceMetadata\n};\n\nexport type ResourceFunctionRecord = {\n  kind: ResourceKind.FUNCTION;\n  provide: (...args: any[]) => any | Promise<any>;\n  metadata: ResourceMetadata\n};\n\nexport type ResourceRecord =\n  | ResourceClassTokenRecord\n  | ResourceFunctionRecord;\n\n\n// TODO: support resource templates\n// ResourceTemplateKind,\n// ResourceTemplateClassToken,\n// ResourceTemplateFunction,\n// ResourceTemplateRecord,"]}

package/src/records/scope.record.d.ts

@@ -0,0 +1,18 @@
+import { Type } from '../interfaces';
+import { AppScopeMetadata, MultiAppScopeMetadata } from '../metadata';
+import { ScopeEntry } from '../entries';
+export declare enum ScopeKind {
+    SPLIT_BY_APP = "SPLIT_BY_APP",
+    MULTI_APP = "MULTI_APP"
+}
+export type SplitByAppScope = {
+    kind: ScopeKind.SPLIT_BY_APP;
+    provide: Type<ScopeEntry>;
+    metadata: AppScopeMetadata;
+};
+export type MultiAppScope = {
+    kind: ScopeKind.MULTI_APP;
+    provide: Type<ScopeEntry>;
+    metadata: MultiAppScopeMetadata;
+};
+export type ScopeRecord = SplitByAppScope | MultiAppScope;

package/src/records/scope.record.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeKind = void 0;
+var ScopeKind;
+(function (ScopeKind) {
+    ScopeKind["SPLIT_BY_APP"] = "SPLIT_BY_APP";
+    ScopeKind["MULTI_APP"] = "MULTI_APP";
+})(ScopeKind || (exports.ScopeKind = ScopeKind = {}));
+//# sourceMappingURL=scope.record.js.map

package/src/records/scope.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.record.js","sourceRoot":"","sources":["../../../src/records/scope.record.ts"],"names":[],"mappings":";;;AAIA,IAAY,SAGX;AAHD,WAAY,SAAS;IACnB,0CAA6B,CAAA;IAC7B,oCAAuB,CAAA;AACzB,CAAC,EAHW,SAAS,yBAAT,SAAS,QAGpB","sourcesContent":["import { Type } from '../interfaces';\nimport { AppScopeMetadata, MultiAppScopeMetadata } from '../metadata';\nimport { ScopeEntry } from '../entries';\n\nexport enum ScopeKind {\n  SPLIT_BY_APP = 'SPLIT_BY_APP',\n  MULTI_APP = 'MULTI_APP',\n}\n\nexport type SplitByAppScope = {\n  kind: ScopeKind.SPLIT_BY_APP;\n  provide: Type<ScopeEntry>;\n  metadata: AppScopeMetadata;\n};\n\nexport type MultiAppScope = {\n  kind: ScopeKind.MULTI_APP;\n  provide: Type<ScopeEntry>;\n  metadata: MultiAppScopeMetadata;\n};\n\n\nexport type ScopeRecord =\n  | SplitByAppScope\n  | MultiAppScope\n"]}

package/src/records/tool.record.d.ts

@@ -0,0 +1,17 @@
+import { ToolContext, Type } from '../interfaces';
+import { ToolMetadata } from '../metadata';
+export declare enum ToolKind {
+    CLASS_TOKEN = "CLASS_TOKEN",
+    FUNCTION = "FUNCTION"
+}
+export type ToolClassTokenRecord = {
+    kind: ToolKind.CLASS_TOKEN;
+    provide: Type<ToolContext<any, any>>;
+    metadata: ToolMetadata;
+};
+export type ToolFunctionTokenRecord = {
+    kind: ToolKind.FUNCTION;
+    provide: (...args: any[]) => any | Promise<any>;
+    metadata: ToolMetadata;
+};
+export type ToolRecord = ToolClassTokenRecord | ToolFunctionTokenRecord;

package/src/records/tool.record.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolKind = void 0;
+var ToolKind;
+(function (ToolKind) {
+    ToolKind["CLASS_TOKEN"] = "CLASS_TOKEN";
+    ToolKind["FUNCTION"] = "FUNCTION";
+})(ToolKind || (exports.ToolKind = ToolKind = {}));
+//# sourceMappingURL=tool.record.js.map

package/src/records/tool.record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.record.js","sourceRoot":"","sources":["../../../src/records/tool.record.ts"],"names":[],"mappings":";;;AAIA,IAAY,QAGX;AAHD,WAAY,QAAQ;IAClB,uCAA2B,CAAA;IAC3B,iCAAqB,CAAA;AACvB,CAAC,EAHW,QAAQ,wBAAR,QAAQ,QAGnB","sourcesContent":["import {ToolContext, Type} from '../interfaces';\nimport {ToolMetadata} from '../metadata';\n\n\nexport enum ToolKind {\n  CLASS_TOKEN = 'CLASS_TOKEN',\n  FUNCTION = 'FUNCTION',\n}\n\nexport type ToolClassTokenRecord = {\n  kind: ToolKind.CLASS_TOKEN;\n  provide: Type<ToolContext<any, any>>;\n  metadata: ToolMetadata\n};\n\nexport type ToolFunctionTokenRecord = {\n  kind: ToolKind.FUNCTION;\n  provide: (...args: any[]) => any | Promise<any>;\n  metadata: ToolMetadata\n};\n\nexport type ToolRecord =\n  | ToolClassTokenRecord\n  | ToolFunctionTokenRecord;\n"]}

package/src/schemas/annotated-class.schema.d.ts

@@ -0,0 +1,11 @@
+import { Type } from '../interfaces';
+import { z } from 'zod';
+export declare const annotatedFrontMcpAppSchema: z.ZodType<Type<unknown>, z.ZodTypeDef, Type<unknown>>;
+export declare const annotatedFrontMcpProvidersSchema: z.ZodType<Type<unknown>, z.ZodTypeDef, Type<unknown>>;
+export declare const annotatedFrontMcpAuthProvidersSchema: z.ZodType<Type<unknown>, z.ZodTypeDef, Type<unknown>>;
+export declare const annotatedFrontMcpPluginsSchema: z.ZodType<Type<unknown>, z.ZodTypeDef, Type<unknown>>;
+export declare const annotatedFrontMcpAdaptersSchema: z.ZodType<Type<unknown>, z.ZodTypeDef, Type<unknown>>;
+export declare const annotatedFrontMcpToolsSchema: z.ZodType<Type<unknown>, z.ZodTypeDef, Type<unknown>>;
+export declare const annotatedFrontMcpResourcesSchema: z.ZodType<Type<unknown>, z.ZodTypeDef, Type<unknown>>;
+export declare const annotatedFrontMcpPromptsSchema: z.ZodType<Type<unknown>, z.ZodTypeDef, Type<unknown>>;
+export declare const annotatedFrontMcpLoggerSchema: z.ZodType<Type<unknown>, z.ZodTypeDef, Type<unknown>>;

package/src/schemas/annotated-class.schema.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.annotatedFrontMcpLoggerSchema = exports.annotatedFrontMcpPromptsSchema = exports.annotatedFrontMcpResourcesSchema = exports.annotatedFrontMcpToolsSchema = exports.annotatedFrontMcpAdaptersSchema = exports.annotatedFrontMcpPluginsSchema = exports.annotatedFrontMcpAuthProvidersSchema = exports.annotatedFrontMcpProvidersSchema = exports.annotatedFrontMcpAppSchema = void 0;
+const zod_1 = require("zod");
+const tokens_1 = require("../tokens");
+const metadata_1 = require("../metadata");
+exports.annotatedFrontMcpAppSchema = zod_1.z.custom((v) => typeof v === 'function' && Reflect.hasMetadata(tokens_1.FrontMcpLocalAppTokens.type, v), { message: 'apps items must be annotated with @App() | @FrontMcpApp().' });
+exports.annotatedFrontMcpProvidersSchema = zod_1.z.custom((v) => {
+    return typeof v === 'function' && Reflect.hasMetadata(tokens_1.FrontMcpProviderTokens.type, v)
+        ||
+            (v['useValue'] && Reflect.hasMetadata(tokens_1.FrontMcpProviderTokens.type, v.useValue.constructor))
+        ||
+            (v['useFactory'] && metadata_1.frontMcpProviderMetadataSchema.passthrough().safeParse(v).success);
+}, { message: 'plugins items must be annotated with @Provider() | @FrontMcpProvider().' });
+exports.annotatedFrontMcpAuthProvidersSchema = zod_1.z.custom((v) => {
+    return typeof v === 'function' && Reflect.hasMetadata(tokens_1.FrontMcpAuthProviderTokens.type, v)
+        ||
+            (v['useValue'] && Reflect.hasMetadata(tokens_1.FrontMcpAuthProviderTokens.type, v.useValue.constructor))
+        ||
+            (v['useFactory'] && metadata_1.frontMcpAuthProviderMetadataSchema.passthrough().safeParse(v).success);
+}, { message: 'plugins items must be annotated with @AuthProvider() | @FrontMcpAuthProvider().' });
+exports.annotatedFrontMcpPluginsSchema = zod_1.z.custom((v) => {
+    return (typeof v === 'function' && Reflect.hasMetadata(tokens_1.FrontMcpPluginTokens.type, v));
+}, { message: 'plugins items must be annotated with @Plugin() | @FrontMcpPlugin().' });
+exports.annotatedFrontMcpAdaptersSchema = zod_1.z.custom((v) => {
+    return typeof v === 'function' && Reflect.hasMetadata(tokens_1.FrontMcpAdapterTokens.type, v)
+        ||
+            (v['useValue'] && Reflect.hasMetadata(tokens_1.FrontMcpAdapterTokens.type, v.useValue.constructor))
+        ||
+            (v['useFactory'] && metadata_1.frontMcpAdapterMetadataSchema.passthrough().safeParse(v).success);
+}, { message: 'adapters items must be annotated with @Adapter() | @FrontMcpAdapter().' });
+exports.annotatedFrontMcpToolsSchema = zod_1.z.custom((v) => {
+    return typeof v === 'function' && (Reflect.hasMetadata(tokens_1.FrontMcpToolTokens.type, v)
+        ||
+            v[tokens_1.FrontMcpToolTokens.type] !== undefined);
+}, { message: 'tools items must be annotated with @Tool() | @FrontMcpTool().' });
+exports.annotatedFrontMcpResourcesSchema = zod_1.z.custom((v) => typeof v === 'function' && Reflect.hasMetadata(tokens_1.FrontMcpResourceTokens.type, v), { message: 'resources items must be annotated with @Resource() | @FrontMcpResource().' });
+exports.annotatedFrontMcpPromptsSchema = zod_1.z.custom((v) => typeof v === 'function' && Reflect.hasMetadata(tokens_1.FrontMcpPromptTokens.type, v), { message: 'prompts items must be annotated with @Prompt() | @FrontMcpPrompt().' });
+exports.annotatedFrontMcpLoggerSchema = zod_1.z.custom((v) => typeof v === 'function' && Reflect.hasMetadata(tokens_1.FrontMcpLogTransportTokens.type, v), { message: 'logger items must be annotated with @Logger() | @FrontMcpLogger().' });
+//# sourceMappingURL=annotated-class.schema.js.map

package/src/schemas/annotated-class.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotated-class.schema.js","sourceRoot":"","sources":["../../../src/schemas/annotated-class.schema.ts"],"names":[],"mappings":"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","sourcesContent":["import { Type } from '../interfaces';\nimport { z } from 'zod';\nimport {\n  FrontMcpAdapterTokens, FrontMcpAuthProviderTokens,\n  FrontMcpLocalAppTokens, FrontMcpLogTransportTokens,\n  FrontMcpPluginTokens, FrontMcpPromptTokens,\n  FrontMcpProviderTokens, FrontMcpResourceTokens,\n  FrontMcpToolTokens,\n} from '../tokens';\nimport {\n  frontMcpAdapterMetadataSchema,\n  frontMcpAuthProviderMetadataSchema,\n  frontMcpProviderMetadataSchema,\n} from '../metadata';\n\nexport const annotatedFrontMcpAppSchema = z.custom<Type>(\n  (v): v is Type => typeof v === 'function' && Reflect.hasMetadata(FrontMcpLocalAppTokens.type, v),\n  { message: 'apps items must be annotated with @App() | @FrontMcpApp().' },\n);\n\nexport const annotatedFrontMcpProvidersSchema = z.custom<Type>(\n  (v): v is Type => {\n    return typeof v === 'function' && Reflect.hasMetadata(FrontMcpProviderTokens.type, v)\n      ||\n      (v['useValue'] && Reflect.hasMetadata(FrontMcpProviderTokens.type, v.useValue.constructor))\n      ||\n      (v['useFactory'] && frontMcpProviderMetadataSchema.passthrough().safeParse(v).success);\n  },\n  { message: 'plugins items must be annotated with @Provider() | @FrontMcpProvider().' },\n);\n\nexport const annotatedFrontMcpAuthProvidersSchema = z.custom<Type>(\n  (v): v is Type => {\n    return typeof v === 'function' && Reflect.hasMetadata(FrontMcpAuthProviderTokens.type, v)\n      ||\n      (v['useValue'] && Reflect.hasMetadata(FrontMcpAuthProviderTokens.type, v.useValue.constructor))\n      ||\n      (v['useFactory'] && frontMcpAuthProviderMetadataSchema.passthrough().safeParse(v).success);\n  },\n  { message: 'plugins items must be annotated with @AuthProvider() | @FrontMcpAuthProvider().' },\n);\n\nexport const annotatedFrontMcpPluginsSchema = z.custom<Type>(\n  (v): v is Type => {\n    return (typeof v === 'function' && Reflect.hasMetadata(FrontMcpPluginTokens.type, v));\n  },\n  { message: 'plugins items must be annotated with @Plugin() | @FrontMcpPlugin().' },\n);\n\nexport const annotatedFrontMcpAdaptersSchema = z.custom<Type>(\n  (v): v is Type => {\n    return typeof v === 'function' && Reflect.hasMetadata(FrontMcpAdapterTokens.type, v)\n      ||\n      (v['useValue'] && Reflect.hasMetadata(FrontMcpAdapterTokens.type, v.useValue.constructor))\n      ||\n      (v['useFactory'] && frontMcpAdapterMetadataSchema.passthrough().safeParse(v).success);\n  },\n  { message: 'adapters items must be annotated with @Adapter() | @FrontMcpAdapter().' },\n);\n\nexport const annotatedFrontMcpToolsSchema = z.custom<Type>(\n  (v): v is Type => {\n    return typeof v === 'function' && (\n      Reflect.hasMetadata(FrontMcpToolTokens.type, v)\n      ||\n      v[FrontMcpToolTokens.type] !== undefined\n    );\n  },\n  { message: 'tools items must be annotated with @Tool() | @FrontMcpTool().' },\n);\n\nexport const annotatedFrontMcpResourcesSchema = z.custom<Type>(\n  (v): v is Type => typeof v === 'function' && Reflect.hasMetadata(FrontMcpResourceTokens.type, v),\n  { message: 'resources items must be annotated with @Resource() | @FrontMcpResource().' },\n);\n\nexport const annotatedFrontMcpPromptsSchema = z.custom<Type>(\n  (v): v is Type => typeof v === 'function' && Reflect.hasMetadata(FrontMcpPromptTokens.type, v),\n  { message: 'prompts items must be annotated with @Prompt() | @FrontMcpPrompt().' },\n);\n\nexport const annotatedFrontMcpLoggerSchema = z.custom<Type>(\n  (v): v is Type => typeof v === 'function' && Reflect.hasMetadata(FrontMcpLogTransportTokens.type, v),\n  { message: 'logger items must be annotated with @Logger() | @FrontMcpLogger().' },\n);"]}

package/src/schemas/http-input.schema.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const httpInputSchema: z.ZodObject<{
+    request: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+    response: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+    next: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    request: {} & {
+        [k: string]: unknown;
+    };
+    response: {} & {
+        [k: string]: unknown;
+    };
+    next?: ((...args: unknown[]) => unknown) | undefined;
+}, {
+    request: {} & {
+        [k: string]: unknown;
+    };
+    response: {} & {
+        [k: string]: unknown;
+    };
+    next?: ((...args: unknown[]) => unknown) | undefined;
+}>;
+export declare const httpRequestInputSchema: z.ZodObject<{
+    request: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    request: {} & {
+        [k: string]: unknown;
+    };
+}, {
+    request: {} & {
+        [k: string]: unknown;
+    };
+}>;

package/src/schemas/http-input.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpRequestInputSchema = exports.httpInputSchema = void 0;
+const zod_1 = require("zod");
+exports.httpInputSchema = zod_1.z.object({
+    request: zod_1.z.object({}).passthrough(), // TODO: must be validated
+    response: zod_1.z.object({}).passthrough(),
+    next: zod_1.z.function().optional(),
+});
+exports.httpRequestInputSchema = zod_1.z.object({
+    request: zod_1.z.object({}).passthrough(), // TODO: must be validated
+});
+//# sourceMappingURL=http-input.schema.js.map

package/src/schemas/http-input.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-input.schema.js","sourceRoot":"","sources":["../../../src/schemas/http-input.schema.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAGX,QAAA,eAAe,GAAG,OAAC,CAAC,MAAM,CAAC;IACtC,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,EAAE,0BAA0B;IAC/D,QAAQ,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE;IACpC,IAAI,EAAE,OAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CAC9B,CAAC,CAAC;AAEU,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC7C,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,EAAE,0BAA0B;CAChE,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\n\n\nexport const httpInputSchema = z.object({\n  request: z.object({}).passthrough(), // TODO: must be validated\n  response: z.object({}).passthrough(),\n  next: z.function().optional(),\n});\n\nexport const httpRequestInputSchema = z.object({\n  request: z.object({}).passthrough(), // TODO: must be validated\n});"]}