@eagi/sdk 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,18 @@
+
+> @eagi/sdk@0.1.0 build /home/runner/work/eagi-mcp-framework/eagi-mcp-framework/packages/sdk
+> tsup src/index.ts --format cjs,esm --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2022
+CJS Build start
+ESM Build start
+CJS dist/index.js 16.41 KB
+CJS ⚡️ Build success in 49ms
+ESM dist/index.mjs 13.96 KB
+ESM ⚡️ Build success in 50ms
+DTS Build start
+DTS ⚡️ Build success in 2156ms
+DTS dist/index.d.ts  8.52 KB
+DTS dist/index.d.mts 8.52 KB

package/LICENSE

@@ -0,0 +1,28 @@
+EAGI Sustainable Use License
+
+Version 1.0, June 2026
+
+Copyright (c) 2026 EAGI Authors
+
+This License governs the use of the EAGI MCP Framework (including its SDK, CLI, and Gateway). By using, copying, modifying, or distributing this software, you agree to comply with the terms of this License.
+
+1. Grant of License
+Subject to the restrictions in Section 2, the authors hereby grant you a free, worldwide, non-exclusive, non-transferable, revocable license to:
+  a) Use, copy, and run the software for personal, educational, research, and internal business operations.
+  b) Modify the software's source code for your personal or internal business operations.
+  c) Distribute modifications of the software, provided that any recipient is bound by the terms of this License.
+
+2. Restrictions on Commercial and Competitive Use
+You may NOT do any of the following without obtaining prior, written, explicit commercial licensing permission from the copyright holders:
+  a) Offer the software or any modified version thereof as a hosted service, Software-as-a-Service (SaaS), Platform-as-a-Service (PaaS), or managed cloud product where the core value or primary functionality derived by users comes from this software.
+  b) Sell, rent, lease, or sub-license the software, or any modified version thereof, for a fee.
+  c) Embed, bundle, or white-label the software (or any modified version thereof) inside a commercial application, platform, or hardware product that is distributed or sold to third parties.
+
+3. Professional Services Exception
+You ARE permitted to charge for professional services related to this software (such as custom domain consulting, building workflows, training, deployment help, or infrastructure management) provided that your clients host and manage their own instances under their own names and comply with Section 1 and 2 of this License.
+
+4. Intellectual Property
+All rights, title, and interest in and to the software, including copyright and other intellectual property rights, remain the exclusive property of the authors.
+
+5. Disclaimer of Warranty
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,272 @@
+import { ZodType, z } from 'zod';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+interface Identity {
+    userId: string;
+    role: string;
+    email?: string;
+    claims: Record<string, unknown>;
+}
+interface DomainManifest {
+    name: string;
+    version: string;
+    description?: string;
+    dependencies?: string[];
+    roles?: Record<string, {
+        description?: string;
+        includes?: string[];
+    }>;
+    triggers?: any[];
+}
+interface ToolResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        data: string;
+        mimeType: string;
+    }>;
+    isError?: boolean;
+}
+interface HookContextMap {
+    'before:tool:call': {
+        toolName: string;
+        input: unknown;
+        identity: Identity;
+        domain: DomainManifest;
+    };
+    'after:tool:call': {
+        toolName: string;
+        input: unknown;
+        output: ToolResult;
+        identity: Identity;
+        duration: number;
+    };
+    'on:tool:error': {
+        toolName: string;
+        input: unknown;
+        error: Error;
+        identity: Identity;
+    };
+    'before:resource:read': {
+        uri: string;
+        identity: Identity;
+    };
+    'after:resource:read': {
+        uri: string;
+        data: string;
+        identity: Identity;
+    };
+    'on:server:start': {
+        config: any;
+        domains: DomainManifest[];
+    };
+    'on:server:stop': {
+        uptime: number;
+        requestCount: number;
+    };
+    'on:domain:load': {
+        domain: DomainManifest;
+    };
+}
+interface FilterDataMap {
+    'filter:tool:input': unknown;
+    'filter:tool:output': ToolResult;
+    'filter:resource:data': string;
+    'filter:tools:list': any[];
+    'filter:audit:entry': any;
+}
+type ActionHandler<K extends keyof HookContextMap> = (ctx: HookContextMap[K]) => Promise<void> | void;
+type FilterHandler<K extends keyof FilterDataMap> = (data: FilterDataMap[K], ctx?: any) => Promise<FilterDataMap[K]> | FilterDataMap[K];
+
+declare class HookEngine {
+    private actions;
+    private filters;
+    addAction<K extends keyof HookContextMap>(hookName: K, handler: ActionHandler<K>, priority?: number): void;
+    addFilter<K extends keyof FilterDataMap>(hookName: K, handler: FilterHandler<K>, priority?: number): void;
+    doAction<K extends keyof HookContextMap>(hookName: K, context: HookContextMap[K]): Promise<void>;
+    applyFilters<K extends keyof FilterDataMap>(hookName: K, data: FilterDataMap[K], context?: any): Promise<FilterDataMap[K]>;
+}
+
+interface ToolContext {
+    identity: Identity;
+    domain: DomainManifest;
+    hooks: HookEngine;
+    logger: any;
+    services: Record<string, any>;
+    tools: {
+        call: <T = unknown>(toolName: string, input: Record<string, unknown>) => Promise<T>;
+    };
+    resources: {
+        get: <T = unknown>(uri: string) => Promise<T>;
+    };
+}
+interface ResourceContext {
+    identity: Identity;
+    domain: DomainManifest;
+    hooks: HookEngine;
+    logger: any;
+    services: Record<string, any>;
+}
+interface ToolDefinition<TInput extends ZodType = ZodType> {
+    name: string;
+    description: string;
+    input: TInput;
+    auth?: {
+        roles: string[];
+    };
+    audit?: boolean | {
+        redactFields?: string[];
+    };
+    approval?: {
+        required: boolean;
+        message: string | ((input: z.infer<TInput>) => string);
+        timeout?: string;
+    };
+    handler: (input: z.infer<TInput>, ctx: ToolContext) => Promise<ToolResult>;
+}
+type ExtractParams<T extends string> = T extends `${string}{${infer Param}}${infer Rest}` ? Param | ExtractParams<Rest> : never;
+interface ResourceDefinition<TUri extends string = string> {
+    uri: TUri;
+    name: string;
+    description: string;
+    mimeType: string;
+    auth?: {
+        roles: string[];
+    };
+    handler: (params: Record<ExtractParams<TUri>, string>, ctx: ResourceContext) => Promise<string>;
+}
+interface PromptMessage {
+    role: 'user' | 'assistant';
+    content: {
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        data: string;
+        mimeType: string;
+    };
+}
+interface PromptDefinition<TArgs extends ZodType = ZodType> {
+    name: string;
+    description: string;
+    arguments: TArgs;
+    handler: (args: z.infer<TArgs>, ctx: ResourceContext) => Promise<{
+        messages: PromptMessage[];
+    }>;
+}
+interface DomainConfig {
+    env: Record<string, string | undefined>;
+}
+type ResolvedDeps<TDeps extends readonly string[], TServiceMap> = {
+    [K in TDeps[number]]: K extends keyof TServiceMap ? TServiceMap[K] : never;
+};
+interface ServiceDefinition<TName extends string = string, TDeps extends readonly string[] = readonly string[], TInstance = any> {
+    name: TName;
+    deps?: TDeps;
+    factory: (config: DomainConfig, deps: ResolvedDeps<TDeps, any>) => Promise<TInstance>;
+    dispose?: (instance: TInstance) => Promise<void>;
+}
+interface EagiConfig {
+    name: string;
+    version: string;
+    gateway?: {
+        port: number;
+        auth?: {
+            provider: string;
+            issuer: string;
+            audience: string;
+        };
+    };
+    audit?: {
+        hashChain?: boolean;
+        output?: 'file' | 'stdout';
+        redactInputs?: boolean;
+    };
+    hooks?: {
+        [K in keyof HookContextMap]?: (ctx: HookContextMap[K]) => Promise<void> | void;
+    } & {
+        [K in keyof FilterDataMap]?: (data: FilterDataMap[K], ctx?: any) => Promise<FilterDataMap[K]> | FilterDataMap[K];
+    };
+    domains?: Record<string, {
+        enabled: boolean;
+    }>;
+}
+
+interface LoadedDomain {
+    manifest: DomainManifest;
+    services: ServiceDefinition[];
+    tools: ToolDefinition[];
+    resources: ResourceDefinition[];
+    prompts: PromptDefinition[];
+    hooksModule?: any;
+    dir: string;
+}
+declare class DomainLoader {
+    load(domainDir: string): Promise<LoadedDomain>;
+    private loadDirectory;
+}
+declare function sortServices(services: ServiceDefinition[]): ServiceDefinition[];
+
+declare class DomainRegistry {
+    private domains;
+    register(domain: LoadedDomain): void;
+    get(name: string): LoadedDomain | undefined;
+    getAll(): LoadedDomain[];
+    getAllTools(): ToolDefinition[];
+    getAllResources(): ResourceDefinition[];
+    getAllPrompts(): PromptDefinition[];
+}
+
+declare function defineTool<TInput extends ZodType>(definition: ToolDefinition<TInput>): ToolDefinition<TInput>;
+
+declare function defineResource<TUri extends string>(definition: ResourceDefinition<TUri>): ResourceDefinition<TUri>;
+
+declare function definePrompt<TArgs extends ZodType>(definition: PromptDefinition<TArgs>): PromptDefinition<TArgs>;
+
+declare function defineService<TName extends string, TDeps extends readonly string[], TInstance>(definition: ServiceDefinition<TName, TDeps, TInstance>): ServiceDefinition<TName, TDeps, TInstance>;
+
+type HookRegistration = {
+    [K in keyof HookContextMap]?: ActionHandler<K>;
+} & {
+    [K in keyof FilterDataMap]?: FilterHandler<K>;
+};
+declare function defineHooks(hooks: HookRegistration): HookRegistration;
+
+declare function defineConfig(config: EagiConfig): EagiConfig;
+
+declare class EagiServerBuilder {
+    private config;
+    private registry;
+    private hooks;
+    private servicesMap;
+    constructor(config: EagiConfig, registry: DomainRegistry, hooks: HookEngine, servicesMap: Record<string, any>);
+    build(): Server;
+    private registerTools;
+    private registerResources;
+    private registerPrompts;
+}
+
+declare class EagiRunner {
+    private config;
+    private registry;
+    private hooks;
+    private servicesMap;
+    constructor(config: EagiConfig);
+    start(domainDirs: string[]): Promise<void>;
+}
+
+declare class AuthError extends Error {
+    constructor(message: string);
+}
+declare function authMiddleware(tool: ToolDefinition, ctx: ToolContext): Promise<void>;
+
+declare function auditMiddleware(tool: ToolDefinition, input: any, output: ToolResult, ctx: ToolContext): Promise<void>;
+
+declare class ApprovalRequiredError extends Error {
+    constructor(message: string);
+}
+declare function approvalMiddleware(tool: ToolDefinition, input: any, ctx: ToolContext): Promise<void>;
+
+export { type ActionHandler, ApprovalRequiredError, AuthError, type DomainConfig, DomainLoader, type DomainManifest, DomainRegistry, type EagiConfig, EagiRunner, EagiServerBuilder, type FilterDataMap, type FilterHandler, type HookContextMap, HookEngine, type Identity, type LoadedDomain, type PromptDefinition, type PromptMessage, type ResourceContext, type ResourceDefinition, type ServiceDefinition, type ToolContext, type ToolDefinition, type ToolResult, approvalMiddleware, auditMiddleware, authMiddleware, defineConfig, defineHooks, definePrompt, defineResource, defineService, defineTool, sortServices };

package/dist/index.d.ts

@@ -0,0 +1,272 @@
+import { ZodType, z } from 'zod';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+interface Identity {
+    userId: string;
+    role: string;
+    email?: string;
+    claims: Record<string, unknown>;
+}
+interface DomainManifest {
+    name: string;
+    version: string;
+    description?: string;
+    dependencies?: string[];
+    roles?: Record<string, {
+        description?: string;
+        includes?: string[];
+    }>;
+    triggers?: any[];
+}
+interface ToolResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        data: string;
+        mimeType: string;
+    }>;
+    isError?: boolean;
+}
+interface HookContextMap {
+    'before:tool:call': {
+        toolName: string;
+        input: unknown;
+        identity: Identity;
+        domain: DomainManifest;
+    };
+    'after:tool:call': {
+        toolName: string;
+        input: unknown;
+        output: ToolResult;
+        identity: Identity;
+        duration: number;
+    };
+    'on:tool:error': {
+        toolName: string;
+        input: unknown;
+        error: Error;
+        identity: Identity;
+    };
+    'before:resource:read': {
+        uri: string;
+        identity: Identity;
+    };
+    'after:resource:read': {
+        uri: string;
+        data: string;
+        identity: Identity;
+    };
+    'on:server:start': {
+        config: any;
+        domains: DomainManifest[];
+    };
+    'on:server:stop': {
+        uptime: number;
+        requestCount: number;
+    };
+    'on:domain:load': {
+        domain: DomainManifest;
+    };
+}
+interface FilterDataMap {
+    'filter:tool:input': unknown;
+    'filter:tool:output': ToolResult;
+    'filter:resource:data': string;
+    'filter:tools:list': any[];
+    'filter:audit:entry': any;
+}
+type ActionHandler<K extends keyof HookContextMap> = (ctx: HookContextMap[K]) => Promise<void> | void;
+type FilterHandler<K extends keyof FilterDataMap> = (data: FilterDataMap[K], ctx?: any) => Promise<FilterDataMap[K]> | FilterDataMap[K];
+
+declare class HookEngine {
+    private actions;
+    private filters;
+    addAction<K extends keyof HookContextMap>(hookName: K, handler: ActionHandler<K>, priority?: number): void;
+    addFilter<K extends keyof FilterDataMap>(hookName: K, handler: FilterHandler<K>, priority?: number): void;
+    doAction<K extends keyof HookContextMap>(hookName: K, context: HookContextMap[K]): Promise<void>;
+    applyFilters<K extends keyof FilterDataMap>(hookName: K, data: FilterDataMap[K], context?: any): Promise<FilterDataMap[K]>;
+}
+
+interface ToolContext {
+    identity: Identity;
+    domain: DomainManifest;
+    hooks: HookEngine;
+    logger: any;
+    services: Record<string, any>;
+    tools: {
+        call: <T = unknown>(toolName: string, input: Record<string, unknown>) => Promise<T>;
+    };
+    resources: {
+        get: <T = unknown>(uri: string) => Promise<T>;
+    };
+}
+interface ResourceContext {
+    identity: Identity;
+    domain: DomainManifest;
+    hooks: HookEngine;
+    logger: any;
+    services: Record<string, any>;
+}
+interface ToolDefinition<TInput extends ZodType = ZodType> {
+    name: string;
+    description: string;
+    input: TInput;
+    auth?: {
+        roles: string[];
+    };
+    audit?: boolean | {
+        redactFields?: string[];
+    };
+    approval?: {
+        required: boolean;
+        message: string | ((input: z.infer<TInput>) => string);
+        timeout?: string;
+    };
+    handler: (input: z.infer<TInput>, ctx: ToolContext) => Promise<ToolResult>;
+}
+type ExtractParams<T extends string> = T extends `${string}{${infer Param}}${infer Rest}` ? Param | ExtractParams<Rest> : never;
+interface ResourceDefinition<TUri extends string = string> {
+    uri: TUri;
+    name: string;
+    description: string;
+    mimeType: string;
+    auth?: {
+        roles: string[];
+    };
+    handler: (params: Record<ExtractParams<TUri>, string>, ctx: ResourceContext) => Promise<string>;
+}
+interface PromptMessage {
+    role: 'user' | 'assistant';
+    content: {
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        data: string;
+        mimeType: string;
+    };
+}
+interface PromptDefinition<TArgs extends ZodType = ZodType> {
+    name: string;
+    description: string;
+    arguments: TArgs;
+    handler: (args: z.infer<TArgs>, ctx: ResourceContext) => Promise<{
+        messages: PromptMessage[];
+    }>;
+}
+interface DomainConfig {
+    env: Record<string, string | undefined>;
+}
+type ResolvedDeps<TDeps extends readonly string[], TServiceMap> = {
+    [K in TDeps[number]]: K extends keyof TServiceMap ? TServiceMap[K] : never;
+};
+interface ServiceDefinition<TName extends string = string, TDeps extends readonly string[] = readonly string[], TInstance = any> {
+    name: TName;
+    deps?: TDeps;
+    factory: (config: DomainConfig, deps: ResolvedDeps<TDeps, any>) => Promise<TInstance>;
+    dispose?: (instance: TInstance) => Promise<void>;
+}
+interface EagiConfig {
+    name: string;
+    version: string;
+    gateway?: {
+        port: number;
+        auth?: {
+            provider: string;
+            issuer: string;
+            audience: string;
+        };
+    };
+    audit?: {
+        hashChain?: boolean;
+        output?: 'file' | 'stdout';
+        redactInputs?: boolean;
+    };
+    hooks?: {
+        [K in keyof HookContextMap]?: (ctx: HookContextMap[K]) => Promise<void> | void;
+    } & {
+        [K in keyof FilterDataMap]?: (data: FilterDataMap[K], ctx?: any) => Promise<FilterDataMap[K]> | FilterDataMap[K];
+    };
+    domains?: Record<string, {
+        enabled: boolean;
+    }>;
+}
+
+interface LoadedDomain {
+    manifest: DomainManifest;
+    services: ServiceDefinition[];
+    tools: ToolDefinition[];
+    resources: ResourceDefinition[];
+    prompts: PromptDefinition[];
+    hooksModule?: any;
+    dir: string;
+}
+declare class DomainLoader {
+    load(domainDir: string): Promise<LoadedDomain>;
+    private loadDirectory;
+}
+declare function sortServices(services: ServiceDefinition[]): ServiceDefinition[];
+
+declare class DomainRegistry {
+    private domains;
+    register(domain: LoadedDomain): void;
+    get(name: string): LoadedDomain | undefined;
+    getAll(): LoadedDomain[];
+    getAllTools(): ToolDefinition[];
+    getAllResources(): ResourceDefinition[];
+    getAllPrompts(): PromptDefinition[];
+}
+
+declare function defineTool<TInput extends ZodType>(definition: ToolDefinition<TInput>): ToolDefinition<TInput>;
+
+declare function defineResource<TUri extends string>(definition: ResourceDefinition<TUri>): ResourceDefinition<TUri>;
+
+declare function definePrompt<TArgs extends ZodType>(definition: PromptDefinition<TArgs>): PromptDefinition<TArgs>;
+
+declare function defineService<TName extends string, TDeps extends readonly string[], TInstance>(definition: ServiceDefinition<TName, TDeps, TInstance>): ServiceDefinition<TName, TDeps, TInstance>;
+
+type HookRegistration = {
+    [K in keyof HookContextMap]?: ActionHandler<K>;
+} & {
+    [K in keyof FilterDataMap]?: FilterHandler<K>;
+};
+declare function defineHooks(hooks: HookRegistration): HookRegistration;
+
+declare function defineConfig(config: EagiConfig): EagiConfig;
+
+declare class EagiServerBuilder {
+    private config;
+    private registry;
+    private hooks;
+    private servicesMap;
+    constructor(config: EagiConfig, registry: DomainRegistry, hooks: HookEngine, servicesMap: Record<string, any>);
+    build(): Server;
+    private registerTools;
+    private registerResources;
+    private registerPrompts;
+}
+
+declare class EagiRunner {
+    private config;
+    private registry;
+    private hooks;
+    private servicesMap;
+    constructor(config: EagiConfig);
+    start(domainDirs: string[]): Promise<void>;
+}
+
+declare class AuthError extends Error {
+    constructor(message: string);
+}
+declare function authMiddleware(tool: ToolDefinition, ctx: ToolContext): Promise<void>;
+
+declare function auditMiddleware(tool: ToolDefinition, input: any, output: ToolResult, ctx: ToolContext): Promise<void>;
+
+declare class ApprovalRequiredError extends Error {
+    constructor(message: string);
+}
+declare function approvalMiddleware(tool: ToolDefinition, input: any, ctx: ToolContext): Promise<void>;
+
+export { type ActionHandler, ApprovalRequiredError, AuthError, type DomainConfig, DomainLoader, type DomainManifest, DomainRegistry, type EagiConfig, EagiRunner, EagiServerBuilder, type FilterDataMap, type FilterHandler, type HookContextMap, HookEngine, type Identity, type LoadedDomain, type PromptDefinition, type PromptMessage, type ResourceContext, type ResourceDefinition, type ServiceDefinition, type ToolContext, type ToolDefinition, type ToolResult, approvalMiddleware, auditMiddleware, authMiddleware, defineConfig, defineHooks, definePrompt, defineResource, defineService, defineTool, sortServices };