@eagi/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,452 @@
+// src/hooks/engine.ts
+var HookEngine = class {
+  actions = /* @__PURE__ */ new Map();
+  filters = /* @__PURE__ */ new Map();
+  addAction(hookName, handler, priority = 10) {
+    if (!this.actions.has(hookName)) {
+      this.actions.set(hookName, []);
+    }
+    this.actions.get(hookName).push({ handler, priority });
+    this.actions.get(hookName).sort((a, b) => a.priority - b.priority);
+  }
+  addFilter(hookName, handler, priority = 10) {
+    if (!this.filters.has(hookName)) {
+      this.filters.set(hookName, []);
+    }
+    this.filters.get(hookName).push({ handler, priority });
+    this.filters.get(hookName).sort((a, b) => a.priority - b.priority);
+  }
+  async doAction(hookName, context) {
+    const handlers = this.actions.get(hookName) || [];
+    for (const { handler } of handlers) {
+      await handler(context);
+    }
+  }
+  async applyFilters(hookName, data, context) {
+    let result = data;
+    const handlers = this.filters.get(hookName) || [];
+    for (const { handler } of handlers) {
+      result = await handler(result, context);
+    }
+    return result;
+  }
+};
+
+// src/domain/loader.ts
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import yaml from "js-yaml";
+var DomainLoader = class {
+  async load(domainDir) {
+    const manifestPath = join(domainDir, "domain.yaml");
+    if (!existsSync(manifestPath)) {
+      throw new Error(`Domain manifest not found at ${manifestPath}`);
+    }
+    const manifestContent = readFileSync(manifestPath, "utf8");
+    const manifest = yaml.load(manifestContent);
+    const services = await this.loadDirectory(domainDir, "services");
+    const tools = await this.loadDirectory(domainDir, "tools");
+    const resources = await this.loadDirectory(domainDir, "resources");
+    const prompts = await this.loadDirectory(domainDir, "prompts");
+    let hooksModule;
+    const hooksPath = join(domainDir, "hooks", "index.ts");
+    const hooksPathJs = join(domainDir, "hooks", "index.js");
+    if (existsSync(hooksPath) || existsSync(hooksPathJs)) {
+      hooksModule = await import(join(domainDir, "hooks", "index"));
+    }
+    return {
+      manifest,
+      services,
+      tools,
+      resources,
+      prompts,
+      hooksModule,
+      dir: domainDir
+    };
+  }
+  async loadDirectory(domainDir, subDir) {
+    const dirPath = join(domainDir, subDir);
+    if (!existsSync(dirPath)) return [];
+    const files = readdirSync(dirPath).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    const loaded = [];
+    for (const file of files) {
+      const module = await import(join(dirPath, file));
+      if (module.default) {
+        loaded.push(module.default);
+      }
+    }
+    return loaded;
+  }
+};
+function sortServices(services) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const serviceMap = new Map(services.map((s) => [s.name, s]));
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      throw new Error(`Circular dependency detected involving service: ${name}`);
+    }
+    visiting.add(name);
+    const service = serviceMap.get(name);
+    if (service && service.deps) {
+      for (const dep of service.deps) {
+        if (!serviceMap.has(dep)) {
+          throw new Error(`Service ${name} depends on unknown service ${dep}`);
+        }
+        visit(dep);
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    if (service) sorted.push(service);
+  }
+  for (const service of services) {
+    visit(service.name);
+  }
+  return sorted;
+}
+
+// src/domain/registry.ts
+var DomainRegistry = class {
+  domains = /* @__PURE__ */ new Map();
+  register(domain) {
+    this.domains.set(domain.manifest.name, domain);
+  }
+  get(name) {
+    return this.domains.get(name);
+  }
+  getAll() {
+    return Array.from(this.domains.values());
+  }
+  getAllTools() {
+    return this.getAll().flatMap((d) => d.tools);
+  }
+  getAllResources() {
+    return this.getAll().flatMap((d) => d.resources);
+  }
+  getAllPrompts() {
+    return this.getAll().flatMap((d) => d.prompts);
+  }
+};
+
+// src/define/tool.ts
+function defineTool(definition) {
+  return definition;
+}
+
+// src/define/resource.ts
+function defineResource(definition) {
+  return definition;
+}
+
+// src/define/prompt.ts
+function definePrompt(definition) {
+  return definition;
+}
+
+// src/define/service.ts
+function defineService(definition) {
+  return definition;
+}
+
+// src/define/hooks.ts
+function defineHooks(hooks) {
+  return hooks;
+}
+
+// src/define/config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/server/builder.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/middleware/auth.ts
+var AuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+async function authMiddleware(tool, ctx) {
+  if (!tool.auth || !tool.auth.roles) return;
+  const userRole = ctx.identity.role;
+  const domainRoles = ctx.domain.roles || {};
+  const allowedRoles = new Set(tool.auth.roles);
+  if (allowedRoles.has(userRole)) return;
+  const userRoleDef = domainRoles[userRole];
+  if (userRoleDef && userRoleDef.includes) {
+    for (const included of userRoleDef.includes) {
+      if (allowedRoles.has(included)) return;
+    }
+  }
+  throw new AuthError(`User role '${userRole}' is not authorized to execute tool '${tool.name}'`);
+}
+
+// src/middleware/audit.ts
+async function auditMiddleware(tool, input, output, ctx) {
+  if (!tool.audit) return;
+  let auditedInput = { ...input };
+  if (typeof tool.audit === "object" && tool.audit.redactFields) {
+    for (const field of tool.audit.redactFields) {
+      if (field in auditedInput) {
+        auditedInput[field] = "[REDACTED]";
+      }
+    }
+  }
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool: tool.name,
+    identity: ctx.identity.userId,
+    role: ctx.identity.role,
+    input: auditedInput,
+    success: !output.isError
+  };
+  const finalEntry = await ctx.hooks.applyFilters("filter:audit:entry", entry, ctx);
+  if (ctx.logger) {
+    ctx.logger.info("AUDIT", finalEntry);
+  }
+}
+
+// src/middleware/approval.ts
+var ApprovalRequiredError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ApprovalRequiredError";
+  }
+};
+async function approvalMiddleware(tool, input, ctx) {
+  if (!tool.approval || !tool.approval.required) return;
+  const hasApprovalToken = false;
+  if (!hasApprovalToken) {
+    const message = typeof tool.approval.message === "function" ? tool.approval.message(input) : tool.approval.message;
+    throw new ApprovalRequiredError(message);
+  }
+}
+
+// src/server/builder.ts
+var EagiServerBuilder = class {
+  constructor(config, registry, hooks, servicesMap) {
+    this.config = config;
+    this.registry = registry;
+    this.hooks = hooks;
+    this.servicesMap = servicesMap;
+  }
+  config;
+  registry;
+  hooks;
+  servicesMap;
+  build() {
+    const server = new Server(
+      { name: this.config.name, version: this.config.version },
+      { capabilities: { tools: {}, resources: {}, prompts: {} } }
+    );
+    this.registerTools(server);
+    this.registerResources(server);
+    this.registerPrompts(server);
+    return server;
+  }
+  registerTools(server) {
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      const tools = this.registry.getAllTools().map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: zodToJsonSchema(t.input)
+      }));
+      return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      const tool = this.registry.getAllTools().find((t) => t.name === name);
+      if (!tool) {
+        throw new Error(`Tool not found: ${name}`);
+      }
+      const identity = { userId: "system", role: "admin", claims: {} };
+      const domain = this.registry.getAll().find((d) => d.tools.includes(tool)).manifest;
+      const ctx = {
+        identity,
+        domain,
+        hooks: this.hooks,
+        logger: console,
+        // Temporary logger
+        services: this.servicesMap,
+        tools: {
+          call: async (toolName, input2) => {
+            return null;
+          }
+        },
+        resources: {
+          get: async (uri) => {
+            return null;
+          }
+        }
+      };
+      let input = await this.hooks.applyFilters("filter:tool:input", args, ctx);
+      const parsedInput = tool.input.parse(input);
+      await this.hooks.doAction("before:tool:call", { toolName: name, input: parsedInput, identity, domain });
+      if (tool.auth) await authMiddleware(tool, ctx);
+      if (tool.approval) await approvalMiddleware(tool, parsedInput, ctx);
+      const startTime = Date.now();
+      let output = await tool.handler(parsedInput, ctx);
+      const duration = Date.now() - startTime;
+      output = await this.hooks.applyFilters("filter:tool:output", output, ctx);
+      await this.hooks.doAction("after:tool:call", { toolName: name, input: parsedInput, output, identity, duration });
+      if (tool.audit) await auditMiddleware(tool, parsedInput, output, ctx);
+      return output;
+    });
+  }
+  registerResources(server) {
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      const resources = this.registry.getAllResources().map((r) => ({
+        uri: r.uri,
+        name: r.name,
+        description: r.description,
+        mimeType: r.mimeType
+      }));
+      return { resources };
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const { uri } = request.params;
+      const resource = this.registry.getAllResources().find((r) => r.uri === uri);
+      if (!resource) {
+        throw new Error(`Resource not found: ${uri}`);
+      }
+      const identity = { userId: "system", role: "admin", claims: {} };
+      const domain = this.registry.getAll().find((d) => d.resources.includes(resource)).manifest;
+      const ctx = {
+        identity,
+        domain,
+        hooks: this.hooks,
+        logger: console,
+        services: this.servicesMap
+      };
+      await this.hooks.doAction("before:resource:read", { uri, identity });
+      let data = await resource.handler({}, ctx);
+      data = await this.hooks.applyFilters("filter:resource:data", data, ctx);
+      await this.hooks.doAction("after:resource:read", { uri, data, identity });
+      return {
+        contents: [{ uri, mimeType: resource.mimeType, text: data }]
+      };
+    });
+  }
+  registerPrompts(server) {
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+      const prompts = this.registry.getAllPrompts().map((p) => ({
+        name: p.name,
+        description: p.description,
+        arguments: []
+        // Should extract from Zod schema
+      }));
+      return { prompts };
+    });
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      const prompt = this.registry.getAllPrompts().find((p) => p.name === name);
+      if (!prompt) {
+        throw new Error(`Prompt not found: ${name}`);
+      }
+      const identity = { userId: "system", role: "admin", claims: {} };
+      const domain = this.registry.getAll().find((d) => d.prompts.includes(prompt)).manifest;
+      const ctx = {
+        identity,
+        domain,
+        hooks: this.hooks,
+        logger: console,
+        services: this.servicesMap
+      };
+      const parsedArgs = prompt.arguments.parse(args);
+      const result = await prompt.handler(parsedArgs, ctx);
+      return {
+        description: prompt.description,
+        messages: result.messages
+      };
+    });
+  }
+};
+
+// src/server/lifecycle.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+var EagiRunner = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  registry = new DomainRegistry();
+  hooks = new HookEngine();
+  servicesMap = {};
+  async start(domainDirs) {
+    if (this.config.hooks) {
+      for (const [hookName, handler] of Object.entries(this.config.hooks)) {
+        if (hookName.startsWith("filter:")) {
+          this.hooks.addFilter(hookName, handler);
+        } else {
+          this.hooks.addAction(hookName, handler);
+        }
+      }
+    }
+    const loader = new DomainLoader();
+    for (const dir of domainDirs) {
+      const domain = await loader.load(dir);
+      this.registry.register(domain);
+      if (domain.hooksModule && domain.hooksModule.default) {
+        const domainHooks = domain.hooksModule.default;
+        for (const [hookName, handler] of Object.entries(domainHooks)) {
+          if (hookName.startsWith("filter:")) {
+            this.hooks.addFilter(hookName, handler);
+          } else {
+            this.hooks.addAction(hookName, handler);
+          }
+        }
+      }
+      await this.hooks.doAction("on:domain:load", { domain: domain.manifest });
+    }
+    const allServices = this.registry.getAll().flatMap((d) => d.services);
+    const sortedServices = sortServices(allServices);
+    for (const service of sortedServices) {
+      const deps = {};
+      if (service.deps) {
+        for (const dep of service.deps) {
+          deps[dep] = this.servicesMap[dep];
+        }
+      }
+      const instance = await service.factory({ env: process.env }, deps);
+      this.servicesMap[service.name] = instance;
+    }
+    const builder = new EagiServerBuilder(this.config, this.registry, this.hooks, this.servicesMap);
+    const server = builder.build();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    await this.hooks.doAction("on:server:start", { config: this.config, domains: this.registry.getAll().map((d) => d.manifest) });
+  }
+};
+export {
+  ApprovalRequiredError,
+  AuthError,
+  DomainLoader,
+  DomainRegistry,
+  EagiRunner,
+  EagiServerBuilder,
+  HookEngine,
+  approvalMiddleware,
+  auditMiddleware,
+  authMiddleware,
+  defineConfig,
+  defineHooks,
+  definePrompt,
+  defineResource,
+  defineService,
+  defineTool,
+  sortServices
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@eagi/sdk",
+  "version": "0.1.0",
+  "description": "Enterprise AGI - Core Framework SDK",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.1",
+    "js-yaml": "^4.1.1",
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.0",
+    "vitest": "^1.5.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run --passWithNoTests"
+  }
+}

package/src/define/config.ts

@@ -0,0 +1,5 @@
+import type { EagiConfig } from '../domain/types';
+
+export function defineConfig(config: EagiConfig): EagiConfig {
+  return config;
+}

package/src/define/hooks.ts

@@ -0,0 +1,11 @@
+import type { HookContextMap, FilterDataMap, ActionHandler, FilterHandler } from '../hooks/types';
+
+type HookRegistration = {
+  [K in keyof HookContextMap]?: ActionHandler<K>;
+} & {
+  [K in keyof FilterDataMap]?: FilterHandler<K>;
+};
+
+export function defineHooks(hooks: HookRegistration): HookRegistration {
+  return hooks;
+}

package/src/define/index.ts

@@ -0,0 +1,6 @@
+export * from './tool';
+export * from './resource';
+export * from './prompt';
+export * from './service';
+export * from './hooks';
+export * from './config';

package/src/define/prompt.ts

@@ -0,0 +1,8 @@
+import type { ZodType } from 'zod';
+import type { PromptDefinition } from '../domain/types';
+
+export function definePrompt<TArgs extends ZodType>(
+  definition: PromptDefinition<TArgs>
+): PromptDefinition<TArgs> {
+  return definition;
+}

package/src/define/resource.ts

@@ -0,0 +1,7 @@
+import type { ResourceDefinition } from '../domain/types';
+
+export function defineResource<TUri extends string>(
+  definition: ResourceDefinition<TUri>
+): ResourceDefinition<TUri> {
+  return definition;
+}

package/src/define/service.ts

@@ -0,0 +1,11 @@
+import type { ServiceDefinition } from '../domain/types';
+
+export function defineService<
+  TName extends string,
+  TDeps extends readonly string[],
+  TInstance
+>(
+  definition: ServiceDefinition<TName, TDeps, TInstance>
+): ServiceDefinition<TName, TDeps, TInstance> {
+  return definition;
+}

package/src/define/tool.ts

@@ -0,0 +1,8 @@
+import type { ZodType } from 'zod';
+import type { ToolDefinition } from '../domain/types';
+
+export function defineTool<TInput extends ZodType>(
+  definition: ToolDefinition<TInput>
+): ToolDefinition<TInput> {
+  return definition;
+}

package/src/domain/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './loader';
+export * from './registry';

package/src/domain/loader.ts

@@ -0,0 +1,103 @@
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import yaml from 'js-yaml';
+import type { DomainManifest, ServiceDefinition, ToolDefinition, ResourceDefinition, PromptDefinition } from './types';
+
+export interface LoadedDomain {
+  manifest: DomainManifest;
+  services: ServiceDefinition[];
+  tools: ToolDefinition[];
+  resources: ResourceDefinition[];
+  prompts: PromptDefinition[];
+  hooksModule?: any;
+  dir: string;
+}
+
+export class DomainLoader {
+  async load(domainDir: string): Promise<LoadedDomain> {
+    const manifestPath = join(domainDir, 'domain.yaml');
+    if (!existsSync(manifestPath)) {
+      throw new Error(`Domain manifest not found at ${manifestPath}`);
+    }
+
+    const manifestContent = readFileSync(manifestPath, 'utf8');
+    const manifest = yaml.load(manifestContent) as DomainManifest;
+
+    const services = await this.loadDirectory<ServiceDefinition>(domainDir, 'services');
+    const tools = await this.loadDirectory<ToolDefinition>(domainDir, 'tools');
+    const resources = await this.loadDirectory<ResourceDefinition>(domainDir, 'resources');
+    const prompts = await this.loadDirectory<PromptDefinition>(domainDir, 'prompts');
+    
+    let hooksModule;
+    const hooksPath = join(domainDir, 'hooks', 'index.ts');
+    const hooksPathJs = join(domainDir, 'hooks', 'index.js');
+    if (existsSync(hooksPath) || existsSync(hooksPathJs)) {
+      hooksModule = await import(join(domainDir, 'hooks', 'index'));
+    }
+
+    return {
+      manifest,
+      services,
+      tools,
+      resources,
+      prompts,
+      hooksModule,
+      dir: domainDir
+    };
+  }
+
+  private async loadDirectory<T>(domainDir: string, subDir: string): Promise<T[]> {
+    const dirPath = join(domainDir, subDir);
+    if (!existsSync(dirPath)) return [];
+
+    const files = readdirSync(dirPath).filter(f => f.endsWith('.ts') || f.endsWith('.js'));
+    const loaded: T[] = [];
+
+    for (const file of files) {
+      // Dynamic import
+      const module = await import(join(dirPath, file));
+      if (module.default) {
+        loaded.push(module.default);
+      }
+    }
+
+    return loaded;
+  }
+}
+
+export function sortServices(services: ServiceDefinition[]): ServiceDefinition[] {
+  const sorted: ServiceDefinition[] = [];
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+
+  const serviceMap = new Map(services.map(s => [s.name, s]));
+
+  function visit(name: string) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      throw new Error(`Circular dependency detected involving service: ${name}`);
+    }
+
+    visiting.add(name);
+
+    const service = serviceMap.get(name);
+    if (service && service.deps) {
+      for (const dep of service.deps) {
+        if (!serviceMap.has(dep)) {
+          throw new Error(`Service ${name} depends on unknown service ${dep}`);
+        }
+        visit(dep);
+      }
+    }
+
+    visiting.delete(name);
+    visited.add(name);
+    if (service) sorted.push(service);
+  }
+
+  for (const service of services) {
+    visit(service.name);
+  }
+
+  return sorted;
+}

package/src/domain/registry.ts

@@ -0,0 +1,30 @@
+import type { LoadedDomain } from './loader';
+import type { ToolDefinition, ResourceDefinition, PromptDefinition, ServiceDefinition } from './types';
+
+export class DomainRegistry {
+  private domains: Map<string, LoadedDomain> = new Map();
+
+  register(domain: LoadedDomain) {
+    this.domains.set(domain.manifest.name, domain);
+  }
+
+  get(name: string): LoadedDomain | undefined {
+    return this.domains.get(name);
+  }
+
+  getAll(): LoadedDomain[] {
+    return Array.from(this.domains.values());
+  }
+
+  getAllTools(): ToolDefinition[] {
+    return this.getAll().flatMap(d => d.tools);
+  }
+
+  getAllResources(): ResourceDefinition[] {
+    return this.getAll().flatMap(d => d.resources);
+  }
+
+  getAllPrompts(): PromptDefinition[] {
+    return this.getAll().flatMap(d => d.prompts);
+  }
+}