@alneas/eaos-server 0.0.0-stage → 0.1.0

package/dist/chunk-THYUY5ZZ.js

@@ -0,0 +1,204 @@
+import {
+  createCommandAgentExecutor,
+  validateAgentRuntimePolicy
+} from "./chunk-32746UQZ.js";
+import {
+  ServerAgentExecutionError
+} from "./chunk-YABTQZDJ.js";
+
+// src/agentic/autonomous-worker.ts
+import { defaultRuntimePlacementPolicy, McpGatekeeper } from "@alneas/eaos-core";
+import { randomUUID } from "node:crypto";
+function inferRuntimeRole() {
+  const configured = process.env.EAOS_RUNTIME_ROLE;
+  if (configured === "edge" || configured === "application-worker" || configured === "ai") return configured;
+  return process.arch === "arm64" ? "ai" : "application-worker";
+}
+var ServerAutonomousWorker = class {
+  gatekeeper;
+  goosePath;
+  hermesAgentPath;
+  litellmUrl;
+  litellmModel;
+  maxOutputChars;
+  runtimePolicy;
+  runtimeRole;
+  activeTasks = 0;
+  fetchImpl;
+  executors;
+  /**
+   * Captures runtime settings and validates resource policy, role, and output ceiling.
+   * @param options - Trusted host configuration; omitted gatekeeper uses a new McpGatekeeper and runtime role uses EAOS_RUNTIME_ROLE, then ai on arm64 or application-worker otherwise.
+   * @throws Invalid resource policy, role, or output limit.
+   */
+  constructor(options) {
+    this.gatekeeper = options?.gatekeeper || new McpGatekeeper();
+    this.goosePath = options?.gooseBinaryPath || process.env.GOOSE_BIN_PATH || "goose";
+    this.hermesAgentPath = options?.hermesAgentBinaryPath || process.env.HERMES_AGENT_BIN_PATH || "hermes";
+    this.litellmUrl = options?.litellmEndpoint || process.env.LITELLM_ENDPOINT || "http://localhost:4000/v1";
+    this.litellmModel = options?.litellmModel || process.env.LITELLM_MODEL;
+    this.maxOutputChars = options?.maxOutputChars ?? 1e6;
+    this.runtimePolicy = validateAgentRuntimePolicy(options?.runtimePolicy || defaultRuntimePlacementPolicy().ai.agentRuntime);
+    this.runtimeRole = options?.runtimeRole || inferRuntimeRole();
+    if (!["edge", "application-worker", "ai"].includes(this.runtimeRole)) throw new Error("Invalid agent runtime role");
+    this.fetchImpl = options?.fetch || fetch;
+    this.executors = options?.executors || {};
+    if (!Number.isSafeInteger(this.maxOutputChars) || this.maxOutputChars < 1 || this.maxOutputChars > 1e7) throw new Error("Invalid worker output limit");
+  }
+  /**
+   * Checks task limits and gatekeeper policy before dispatching one runtime attempt.
+   * @param request - Verified task identity and instructions; required strings must be nonblank, title at most 500 characters, instructions at most 1000000, and timeout a safe integer 1–3600000 milliseconds when provided.
+   * @returns COMPLETED text output, PENDING_APPROVAL ticket data without execution, or FAILED data with error and optional classification/retry advice. Duration is measured in wall-clock milliseconds.
+   * @throws Can reject a throwing gatekeeper or malformed gatekeeper interaction before dispatch; runtime execution errors are normally returned as FAILED data.
+   * @remarks Gatekeeper receives fixed agent/server_bot roles rather than request user roles. Approval tickets are generated but not persisted here. The configured framework policy overrides request.runtimePolicy before execution. Injected executors and built-in LiteLLM outputs are bounded by maxOutputChars; LiteLLM response bodies are parsed before text length is checked.
+   * @example
+   * ```typescript
+   * import { ServerAutonomousWorker, type ServerWorkerOptions } from "@alneas/eaos-server/agentic/autonomous-worker";
+   * import type { ServerAgentTaskRequest } from "@alneas/eaos-server/agentic/types";
+   * export async function execute(options: ServerWorkerOptions, request: ServerAgentTaskRequest) {
+   *   return new ServerAutonomousWorker(options).runTask(request);
+   * }
+   * ```
+   */
+  async runTask(request) {
+    const startTime = Date.now();
+    if (!request || [request.id, request.tenantId, request.userId, request.title, request.instructions].some((value) => typeof value !== "string" || !value.trim())) {
+      return { taskId: typeof request?.id === "string" ? request.id : "unknown", status: "FAILED", error: "Invalid agent task request", durationMs: Date.now() - startTime };
+    }
+    if (request.instructions.length > 1e6 || request.title.length > 500 || request.timeoutMs !== void 0 && (!Number.isSafeInteger(request.timeoutMs) || request.timeoutMs < 1 || request.timeoutMs > 36e5)) {
+      return { taskId: request.id, status: "FAILED", error: "Agent task exceeds configured limits", durationMs: Date.now() - startTime };
+    }
+    const policy = this.gatekeeper.validateCall({
+      toolName: `server_agent_${request.workerType}`,
+      userRoles: ["agent", "server_bot"],
+      tenantId: request.tenantId
+    });
+    if (!policy.allowed) {
+      return {
+        taskId: request.id,
+        status: "FAILED",
+        error: `Task execution blocked by security policy: ${policy.reason}`,
+        riskLevel: policy.riskLevel,
+        durationMs: Date.now() - startTime
+      };
+    }
+    if (policy.requireHumanApproval) {
+      return {
+        taskId: request.id,
+        status: "PENDING_APPROVAL",
+        approvalTicketId: randomUUID(),
+        approvalLevel: policy.approvalLevel,
+        riskLevel: policy.riskLevel,
+        durationMs: Date.now() - startTime
+      };
+    }
+    const frameworkManaged = !this.executors[request.workerType];
+    if (frameworkManaged && (request.workerType === "goose" || request.workerType === "hermes_agent") && this.runtimeRole !== "ai") {
+      return {
+        taskId: request.id,
+        status: "FAILED",
+        error: `Built-in ${request.workerType} execution is restricted to the AI runtime placement`,
+        failureCode: "AGENT_UNAVAILABLE",
+        retryable: true,
+        durationMs: Date.now() - startTime
+      };
+    }
+    if (frameworkManaged && this.activeTasks >= this.runtimePolicy.maxConcurrent) {
+      return {
+        taskId: request.id,
+        status: "FAILED",
+        error: "Agent runtime concurrency limit reached",
+        failureCode: "AGENT_UNAVAILABLE",
+        retryable: true,
+        durationMs: Date.now() - startTime
+      };
+    }
+    if (frameworkManaged) this.activeTasks += 1;
+    try {
+      const output = await this.execute({ ...structuredClone(request), runtimePolicy: structuredClone(this.runtimePolicy) });
+      return {
+        taskId: request.id,
+        status: "COMPLETED",
+        output,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        taskId: request.id,
+        status: "FAILED",
+        error: err.message,
+        ...err instanceof ServerAgentExecutionError ? { failureCode: err.failureCode, retryable: err.retryable } : {},
+        durationMs: Date.now() - startTime
+      };
+    } finally {
+      if (frameworkManaged) this.activeTasks -= 1;
+    }
+  }
+  async execute(request) {
+    const injected = this.executors[request.workerType];
+    if (injected) return this.boundOutput(await injected(structuredClone(request)));
+    if (request.workerType === "goose") return this.executeHeadlessGoose(request);
+    if (request.workerType === "hermes_agent") return this.executeHeadlessHermesAgent(request);
+    if (request.workerType === "litellm") return this.executeLiteLlm(request);
+    throw new Error(`No executor configured for worker type '${request.workerType}'`);
+  }
+  /**
+   * Execute Goose in headless batch mode
+   */
+  async executeHeadlessGoose(request) {
+    return createCommandAgentExecutor({
+      command: this.goosePath,
+      buildArgs: (task) => ["run", "--text", task.instructions],
+      includeProcessEnv: true,
+      maxOutputChars: this.maxOutputChars,
+      sandbox: { mode: "auto", policy: this.runtimePolicy }
+    })(request);
+  }
+  /**
+   * Execute NousResearch Hermes Agent in headless mode (-z / non-interactive)
+   * Hermes Agent provides persistent cross-session memory and self-improving skill extraction.
+   */
+  async executeHeadlessHermesAgent(request) {
+    return createCommandAgentExecutor({
+      command: this.hermesAgentPath,
+      buildArgs: (task) => ["run", "-z", task.instructions],
+      includeProcessEnv: true,
+      maxOutputChars: this.maxOutputChars,
+      sandbox: { mode: "auto", policy: this.runtimePolicy }
+    })(request);
+  }
+  /**
+   * Execute a host-selected model through LiteLLM.
+   */
+  async executeLiteLlm(request) {
+    if (!this.litellmModel) throw new Error("LiteLLM model is not configured");
+    const endpoint = new URL(this.litellmUrl);
+    if (!["http:", "https:"].includes(endpoint.protocol)) throw new Error("Invalid LiteLLM endpoint");
+    endpoint.pathname = `${endpoint.pathname.replace(/\/$/, "")}/chat/completions`;
+    const response = await this.fetchImpl(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: this.litellmModel,
+        messages: [{ role: "user", content: request.instructions }],
+        metadata: { tenantId: request.tenantId, taskId: request.id }
+      }),
+      signal: AbortSignal.timeout(request.timeoutMs ?? 6e4),
+      redirect: "error"
+    });
+    if (!response.ok) throw new Error(`LiteLLM request failed (${response.status})`);
+    const body = await response.json();
+    const output = body.choices?.[0]?.message?.content;
+    if (typeof output !== "string") throw new Error("LiteLLM returned no assistant content");
+    return this.boundOutput(output);
+  }
+  boundOutput(output) {
+    if (output.length > this.maxOutputChars) throw new Error("Agent output exceeds configured limit");
+    return output;
+  }
+};
+
+export {
+  ServerAutonomousWorker
+};
+//# sourceMappingURL=chunk-THYUY5ZZ.js.map

package/dist/chunk-THYUY5ZZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/agentic/autonomous-worker.ts"],"sourcesContent":["import { defaultRuntimePlacementPolicy, McpGatekeeper, type AgentRuntimeResourcePolicy } from '@alneas/eaos-core'\nimport { ServerAgentExecutionError, type ServerAgentExecutor, type ServerAgentTaskRequest, type ServerAgentTaskResult, type ServerAgentWorkerType } from './types'\nimport { randomUUID } from 'node:crypto'\nimport { createCommandAgentExecutor, validateAgentRuntimePolicy } from './executor'\n\n/**\n * Trusted gatekeeper, runtime endpoints/adapters, and execution limits for {@link ServerAutonomousWorker}.\n */\nexport interface ServerWorkerOptions {\n  /** Host security/approval policies; defaults to a new McpGatekeeper. */\n  gatekeeper?: McpGatekeeper\n  /** Trusted executable path; defaults to GOOSE_BIN_PATH or goose. */\n  gooseBinaryPath?: string\n  /** Trusted executable path; defaults to HERMES_AGENT_BIN_PATH or hermes. */\n  hermesAgentBinaryPath?: string\n  /** Host LiteLLM base URL; defaults to LITELLM_ENDPOINT or http://localhost:4000/v1. */\n  litellmEndpoint?: string\n  /** Host model identifier; defaults to LITELLM_MODEL and is required for built-in LiteLLM execution. */\n  litellmModel?: string\n  /** Combined command output/string result ceiling, safe integer 1–10000000; defaults to 1000000. */\n  maxOutputChars?: number\n  /** Framework default is safe for the ARM agent host. Host adapters may tighten it. */\n  runtimePolicy?: AgentRuntimeResourcePolicy\n  /** Built-in Goose/Hermes execution is permitted only on the AI placement. */\n  runtimeRole?: ServerRuntimeRole\n  /** Host fetch implementation for built-in LiteLLM; defaults to global fetch. */\n  fetch?: typeof fetch\n  /** Host/plugin adapters for coding agents and other external runtimes. */\n  executors?: Partial<Record<ServerAgentWorkerType, ServerAgentExecutor>>\n}\n\n/**\n * Host placement role controlling whether built-in Goose/Hermes processes may run locally.\n * @see ServerAutonomousWorker.\n */\nexport type ServerRuntimeRole = 'edge' | 'application-worker' | 'ai'\n\nfunction inferRuntimeRole(): ServerRuntimeRole {\n  const configured = process.env.EAOS_RUNTIME_ROLE\n  if (configured === 'edge' || configured === 'application-worker' || configured === 'ai') return configured\n  // The supported three-host topology places the AI runtime on the ARM host.\n  // Unknown x64 hosts therefore fail closed as application-worker hosts.\n  return process.arch === 'arm64' ? 'ai' : 'application-worker'\n}\n\n/**\n * Admits and executes host agent tasks through a gatekeeper and bounded runtime adapters.\n * @remarks This class runs only when runTask is called; it installs no scheduler. The host authenticates tenant/user claims before admission. Framework-managed tasks share a per-instance concurrency counter; injected executors own scheduling and are exempt from it. Built-in Goose/Hermes require the ai role and Node process/systemd support. Queue persistence, approvals, retries, and side-effect idempotency belong to the host.\n * @example\n * ```typescript\n * import { ServerAutonomousWorker, type ServerWorkerOptions } from \"@alneas/eaos-server/agentic/autonomous-worker\";\n * export function worker(options: ServerWorkerOptions) { return new ServerAutonomousWorker(options); }\n * ```\n */\nexport class ServerAutonomousWorker {\n  private gatekeeper: McpGatekeeper\n  private goosePath: string\n  private hermesAgentPath: string\n  private litellmUrl: string\n  private litellmModel?: string\n  private maxOutputChars: number\n  private runtimePolicy: AgentRuntimeResourcePolicy\n  private runtimeRole: ServerRuntimeRole\n  private activeTasks = 0\n  private fetchImpl: typeof fetch\n  private executors: Partial<Record<ServerAgentWorkerType, ServerAgentExecutor>>\n\n  /**\n   * Captures runtime settings and validates resource policy, role, and output ceiling.\n   * @param options - Trusted host configuration; omitted gatekeeper uses a new McpGatekeeper and runtime role uses EAOS_RUNTIME_ROLE, then ai on arm64 or application-worker otherwise.\n   * @throws Invalid resource policy, role, or output limit.\n   */\n  constructor(options?: ServerWorkerOptions) {\n    this.gatekeeper = options?.gatekeeper || new McpGatekeeper()\n    this.goosePath = options?.gooseBinaryPath || process.env.GOOSE_BIN_PATH || 'goose'\n    this.hermesAgentPath = options?.hermesAgentBinaryPath || process.env.HERMES_AGENT_BIN_PATH || 'hermes'\n    this.litellmUrl = options?.litellmEndpoint || process.env.LITELLM_ENDPOINT || 'http://localhost:4000/v1'\n    this.litellmModel = options?.litellmModel || process.env.LITELLM_MODEL\n    this.maxOutputChars = options?.maxOutputChars ?? 1_000_000\n    this.runtimePolicy = validateAgentRuntimePolicy(options?.runtimePolicy || defaultRuntimePlacementPolicy().ai.agentRuntime)\n    this.runtimeRole = options?.runtimeRole || inferRuntimeRole()\n    if (!['edge', 'application-worker', 'ai'].includes(this.runtimeRole)) throw new Error('Invalid agent runtime role')\n    this.fetchImpl = options?.fetch || fetch\n    this.executors = options?.executors || {}\n    if (!Number.isSafeInteger(this.maxOutputChars) || this.maxOutputChars < 1 || this.maxOutputChars > 10_000_000) throw new Error('Invalid worker output limit')\n  }\n\n  /**\n   * Checks task limits and gatekeeper policy before dispatching one runtime attempt.\n   * @param request - Verified task identity and instructions; required strings must be nonblank, title at most 500 characters, instructions at most 1000000, and timeout a safe integer 1–3600000 milliseconds when provided.\n   * @returns COMPLETED text output, PENDING_APPROVAL ticket data without execution, or FAILED data with error and optional classification/retry advice. Duration is measured in wall-clock milliseconds.\n   * @throws Can reject a throwing gatekeeper or malformed gatekeeper interaction before dispatch; runtime execution errors are normally returned as FAILED data.\n   * @remarks Gatekeeper receives fixed agent/server_bot roles rather than request user roles. Approval tickets are generated but not persisted here. The configured framework policy overrides request.runtimePolicy before execution. Injected executors and built-in LiteLLM outputs are bounded by maxOutputChars; LiteLLM response bodies are parsed before text length is checked.\n   * @example\n   * ```typescript\n   * import { ServerAutonomousWorker, type ServerWorkerOptions } from \"@alneas/eaos-server/agentic/autonomous-worker\";\n   * import type { ServerAgentTaskRequest } from \"@alneas/eaos-server/agentic/types\";\n   * export async function execute(options: ServerWorkerOptions, request: ServerAgentTaskRequest) {\n   *   return new ServerAutonomousWorker(options).runTask(request);\n   * }\n   * ```\n   */\n  async runTask(request: ServerAgentTaskRequest): Promise<ServerAgentTaskResult> {\n    const startTime = Date.now()\n\n    if (!request || [request.id, request.tenantId, request.userId, request.title, request.instructions].some(value => typeof value !== 'string' || !value.trim())) {\n      return { taskId: typeof request?.id === 'string' ? request.id : 'unknown', status: 'FAILED', error: 'Invalid agent task request', durationMs: Date.now() - startTime }\n    }\n    if (request.instructions.length > 1_000_000 || request.title.length > 500 || request.timeoutMs !== undefined && (!Number.isSafeInteger(request.timeoutMs) || request.timeoutMs < 1 || request.timeoutMs > 3_600_000)) {\n      return { taskId: request.id, status: 'FAILED', error: 'Agent task exceeds configured limits', durationMs: Date.now() - startTime }\n    }\n\n    // 1. Evaluate security and gatekeeper policies\n    const policy = this.gatekeeper.validateCall({\n      toolName: `server_agent_${request.workerType}`,\n      userRoles: ['agent', 'server_bot'],\n      tenantId: request.tenantId,\n    })\n\n    if (!policy.allowed) {\n      return {\n        taskId: request.id,\n        status: 'FAILED',\n        error: `Task execution blocked by security policy: ${policy.reason}`,\n        riskLevel: policy.riskLevel,\n        durationMs: Date.now() - startTime,\n      }\n    }\n\n    if (policy.requireHumanApproval) {\n      return {\n        taskId: request.id,\n        status: 'PENDING_APPROVAL',\n        approvalTicketId: randomUUID(),\n        approvalLevel: policy.approvalLevel,\n        riskLevel: policy.riskLevel,\n        durationMs: Date.now() - startTime,\n      }\n    }\n\n    // Explicitly injected executors are host-owned adapters and may implement\n    // their own queue/scheduler. The framework-managed Goose/Hermes path is\n    // bounded by the default policy so a forgotten host setting cannot create\n    // unbounded local agent concurrency.\n    const frameworkManaged = !this.executors[request.workerType]\n    if (frameworkManaged && (request.workerType === 'goose' || request.workerType === 'hermes_agent') && this.runtimeRole !== 'ai') {\n      return {\n        taskId: request.id,\n        status: 'FAILED',\n        error: `Built-in ${request.workerType} execution is restricted to the AI runtime placement`,\n        failureCode: 'AGENT_UNAVAILABLE',\n        retryable: true,\n        durationMs: Date.now() - startTime,\n      }\n    }\n    if (frameworkManaged && this.activeTasks >= this.runtimePolicy.maxConcurrent) {\n      return {\n        taskId: request.id,\n        status: 'FAILED',\n        error: 'Agent runtime concurrency limit reached',\n        failureCode: 'AGENT_UNAVAILABLE',\n        retryable: true,\n        durationMs: Date.now() - startTime,\n      }\n    }\n\n    // 2. Dispatch according to worker type\n    if (frameworkManaged) this.activeTasks += 1\n    try {\n      const output = await this.execute({ ...structuredClone(request), runtimePolicy: structuredClone(this.runtimePolicy) })\n      return {\n        taskId: request.id,\n        status: 'COMPLETED',\n        output,\n        durationMs: Date.now() - startTime,\n      }\n    } catch (err) {\n      return {\n        taskId: request.id,\n        status: 'FAILED',\n        error: (err as Error).message,\n        ...(err instanceof ServerAgentExecutionError ? { failureCode: err.failureCode, retryable: err.retryable } : {}),\n        durationMs: Date.now() - startTime,\n      }\n    } finally {\n      if (frameworkManaged) this.activeTasks -= 1\n    }\n  }\n\n  private async execute(request: ServerAgentTaskRequest): Promise<string> {\n    const injected = this.executors[request.workerType]\n    if (injected) return this.boundOutput(await injected(structuredClone(request)))\n    if (request.workerType === 'goose') return this.executeHeadlessGoose(request)\n    if (request.workerType === 'hermes_agent') return this.executeHeadlessHermesAgent(request)\n    if (request.workerType === 'litellm') return this.executeLiteLlm(request)\n    throw new Error(`No executor configured for worker type '${request.workerType}'`)\n  }\n\n  /**\n   * Execute Goose in headless batch mode\n   */\n  private async executeHeadlessGoose(request: ServerAgentTaskRequest): Promise<string> {\n    return createCommandAgentExecutor({\n      command: this.goosePath,\n      buildArgs: task => ['run', '--text', task.instructions],\n      includeProcessEnv: true,\n      maxOutputChars: this.maxOutputChars,\n      sandbox: { mode: 'auto', policy: this.runtimePolicy },\n    })(request)\n  }\n\n  /**\n   * Execute NousResearch Hermes Agent in headless mode (-z / non-interactive)\n   * Hermes Agent provides persistent cross-session memory and self-improving skill extraction.\n   */\n  private async executeHeadlessHermesAgent(request: ServerAgentTaskRequest): Promise<string> {\n    return createCommandAgentExecutor({\n      command: this.hermesAgentPath,\n      buildArgs: task => ['run', '-z', task.instructions],\n      includeProcessEnv: true,\n      maxOutputChars: this.maxOutputChars,\n      sandbox: { mode: 'auto', policy: this.runtimePolicy },\n    })(request)\n  }\n\n  /**\n   * Execute a host-selected model through LiteLLM.\n   */\n  private async executeLiteLlm(request: ServerAgentTaskRequest): Promise<string> {\n    if (!this.litellmModel) throw new Error('LiteLLM model is not configured')\n    const endpoint = new URL(this.litellmUrl)\n    if (!['http:', 'https:'].includes(endpoint.protocol)) throw new Error('Invalid LiteLLM endpoint')\n    endpoint.pathname = `${endpoint.pathname.replace(/\\/$/, '')}/chat/completions`\n    const response = await this.fetchImpl(endpoint, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify({\n        model: this.litellmModel,\n        messages: [{ role: 'user', content: request.instructions }],\n        metadata: { tenantId: request.tenantId, taskId: request.id },\n      }),\n      signal: AbortSignal.timeout(request.timeoutMs ?? 60_000),\n      redirect: 'error',\n    })\n    if (!response.ok) throw new Error(`LiteLLM request failed (${response.status})`)\n    const body = await response.json() as { choices?: Array<{ message?: { content?: unknown } }> }\n    const output = body.choices?.[0]?.message?.content\n    if (typeof output !== 'string') throw new Error('LiteLLM returned no assistant content')\n    return this.boundOutput(output)\n  }\n\n  private boundOutput(output: string): string {\n    if (output.length > this.maxOutputChars) throw new Error('Agent output exceeds configured limit')\n    return output\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-UGNTCOVR.js

@@ -0,0 +1,28 @@
+// src/agentic/agent-node.ts
+function createWorkflowAgentNode(options) {
+  if (!options?.runner || typeof options.runner.run !== "function" || typeof options.createRequest !== "function") throw new Error("Workflow agent node requires a runner and request builder");
+  return async (state) => {
+    const request = await options.createRequest(structuredClone(state));
+    if (request.tenantId !== state.tenantId || request.userId !== state.userId) throw new Error("Workflow agent request principal does not match graph state");
+    if (request.workflowId !== state.sessionId) throw new Error("Workflow agent request workflowId does not match graph session");
+    const result = await options.runner.run(request);
+    if (result.status !== "COMPLETED" || !result.proposal) throw new Error(result.error || `Workflow agent runtime ${result.status.toLowerCase()}`);
+    const output = options.validateOutput ? await options.validateOutput(result.proposal.output, result.proposal, state) : result.proposal.output;
+    const contextKey = options.contextKey ?? "agentProposal";
+    return {
+      context: {
+        ...state.context ?? {},
+        [contextKey]: structuredClone({ proposal: result.proposal, output })
+      },
+      history: [
+        ...state.history,
+        { role: "agent", content: result.proposal.summary, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+      ]
+    };
+  };
+}
+
+export {
+  createWorkflowAgentNode
+};
+//# sourceMappingURL=chunk-UGNTCOVR.js.map

package/dist/chunk-UGNTCOVR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/agentic/agent-node.ts"],"sourcesContent":["import type { WorkflowAgentProposal, WorkflowAgentRequest, WorkflowAgentRunner } from '@alneas/eaos-core'\nimport type { AgentGraphState, GraphNodeHandler } from './graph'\n\n/**\n * Host runner, request construction, and output validation for {@link createWorkflowAgentNode}.\n * @typeParam TOutput - Domain output expected from the proposal; defaults to unknown and runtime validation remains plugin-owned.\n */\nexport interface WorkflowAgentNodeOptions<TOutput = unknown> {\n  /** Host-owned runner that returns proposals; this node performs no proposed action. */\n  runner: WorkflowAgentRunner\n  /** Called per node invocation with a structured clone of state; must resolve a request matching tenantId, userId, and sessionId/workflowId. */\n  createRequest: (state: AgentGraphState) => WorkflowAgentRequest | Promise<WorkflowAgentRequest>\n  /** Called after a completed proposal with output, full proposal, and original current state; resolves the domain-validated output stored beside the proposal. Errors reject node execution. */\n  validateOutput?: (output: TOutput, proposal: WorkflowAgentProposal<TOutput>, state: AgentGraphState) => TOutput | Promise<TOutput>\n  /** Context property receiving cloned proposal and validated output; existing data at this key is overwritten. @defaultValue \"agentProposal\" */\n  contextKey?: string\n}\n\n/**\n * Creates a LangGraph node that records an agent proposal in workflow state.\n * It deliberately does not execute proposed actions or create approvals.\n * @typeParam TOutput - Domain-specific proposal output passed to optional plugin validation; defaults to unknown.\n * @param options - Runner, request builder, output validator, and context key.\n * @returns An async graph handler resolving merged context and history with an agent summary entry.\n * @throws Synchronously if runner or request builder is missing. Node execution rejects principal/workflow mismatch, noncompleted runner results, and callback or structuredClone failures.\n * @remarks validateOutput receives proposal output, proposal, and the current state after a completed run; its result is stored alongside the proposal. Unlike createRequest, this callback receives the original state. Host admission, durable checkpointing, and action approval remain outside this node.\n * @example\n * ```typescript\n * import { createWorkflowAgentNode } from \"@alneas/eaos-server/agentic/agent-node\";\n * import type { WorkflowAgentNodeOptions } from \"@alneas/eaos-server/agentic/agent-node\";\n * export function proposalNode(options: WorkflowAgentNodeOptions) {\n *   // Host callbacks build authorized requests and validate domain output.\n *   return createWorkflowAgentNode(options);\n * }\n * ```\n */\nexport function createWorkflowAgentNode<TOutput = unknown>(options: WorkflowAgentNodeOptions<TOutput>): GraphNodeHandler {\n  if (!options?.runner || typeof options.runner.run !== 'function' || typeof options.createRequest !== 'function') throw new Error('Workflow agent node requires a runner and request builder')\n\n  return async state => {\n    const request = await options.createRequest(structuredClone(state))\n    if (request.tenantId !== state.tenantId || request.userId !== state.userId) throw new Error('Workflow agent request principal does not match graph state')\n    if (request.workflowId !== state.sessionId) throw new Error('Workflow agent request workflowId does not match graph session')\n\n    const result = await options.runner.run<TOutput>(request)\n    if (result.status !== 'COMPLETED' || !result.proposal) throw new Error(result.error || `Workflow agent runtime ${result.status.toLowerCase()}`)\n    const output = options.validateOutput ? await options.validateOutput(result.proposal.output, result.proposal, state) : result.proposal.output\n    const contextKey = options.contextKey ?? 'agentProposal'\n    return {\n      context: {\n        ...(state.context ?? {}),\n        [contextKey]: structuredClone({ proposal: result.proposal, output }),\n      },\n      history: [\n        ...state.history,\n        { role: 'agent', content: result.proposal.summary, timestamp: new Date().toISOString() },\n      ],\n    }\n  }\n}\n"],"mappings":";AAoCO,SAAS,wBAA2C,SAA8D;AACvH,MAAI,CAAC,SAAS,UAAU,OAAO,QAAQ,OAAO,QAAQ,cAAc,OAAO,QAAQ,kBAAkB,WAAY,OAAM,IAAI,MAAM,2DAA2D;AAE5L,SAAO,OAAM,UAAS;AACpB,UAAM,UAAU,MAAM,QAAQ,cAAc,gBAAgB,KAAK,CAAC;AAClE,QAAI,QAAQ,aAAa,MAAM,YAAY,QAAQ,WAAW,MAAM,OAAQ,OAAM,IAAI,MAAM,6DAA6D;AACzJ,QAAI,QAAQ,eAAe,MAAM,UAAW,OAAM,IAAI,MAAM,gEAAgE;AAE5H,UAAM,SAAS,MAAM,QAAQ,OAAO,IAAa,OAAO;AACxD,QAAI,OAAO,WAAW,eAAe,CAAC,OAAO,SAAU,OAAM,IAAI,MAAM,OAAO,SAAS,0BAA0B,OAAO,OAAO,YAAY,CAAC,EAAE;AAC9I,UAAM,SAAS,QAAQ,iBAAiB,MAAM,QAAQ,eAAe,OAAO,SAAS,QAAQ,OAAO,UAAU,KAAK,IAAI,OAAO,SAAS;AACvI,UAAM,aAAa,QAAQ,cAAc;AACzC,WAAO;AAAA,MACL,SAAS;AAAA,QACP,GAAI,MAAM,WAAW,CAAC;AAAA,QACtB,CAAC,UAAU,GAAG,gBAAgB,EAAE,UAAU,OAAO,UAAU,OAAO,CAAC;AAAA,MACrE;AAAA,MACA,SAAS;AAAA,QACP,GAAG,MAAM;AAAA,QACT,EAAE,MAAM,SAAS,SAAS,OAAO,SAAS,SAAS,YAAW,oBAAI,KAAK,GAAE,YAAY,EAAE;AAAA,MACzF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-VC2PCK2S.js

@@ -0,0 +1,31 @@
+// src/middleware/module-guard.ts
+import { createMiddleware } from "hono/factory";
+function createModuleGuard(moduleKey, options) {
+  return createMiddleware(async (c, next) => {
+    const isDev = options?.isDev ?? process.env.NODE_ENV === "development";
+    if (isDev) {
+      return await next();
+    }
+    const enabledModules = c.get("enabledModules");
+    if (!Array.isArray(enabledModules) || enabledModules.some((module) => typeof module !== "string")) {
+      console.warn(`[ModuleGuard] Entitlements unavailable for module '${moduleKey}' tenant=${c.get("tenantId")}`);
+      return c.json({
+        error: "Module Entitlements Unavailable",
+        message: "Module entitlements must be verified before accessing this module."
+      }, 403);
+    }
+    if (!enabledModules.includes(moduleKey) && !enabledModules.includes("all")) {
+      console.warn(`[ModuleGuard] Blocked request to module '${moduleKey}' for tenant=${c.get("tenantId")}`);
+      return c.json({
+        error: "Module Not Licensed",
+        message: `The module '${moduleKey}' is not enabled for your tenant.`
+      }, 403);
+    }
+    await next();
+  });
+}
+
+export {
+  createModuleGuard
+};
+//# sourceMappingURL=chunk-VC2PCK2S.js.map

package/dist/chunk-VC2PCK2S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/middleware/module-guard.ts"],"sourcesContent":["import { createMiddleware } from 'hono/factory'\nimport type { EaosEnv } from '@alneas/eaos-core'\n\n/**\n * Controls the explicit development bypass for {@link createModuleGuard}.\n */\nexport interface ModuleGuardOptions {\n  /** Skip entitlement checks when true; defaults to NODE_ENV === \"development\". */\n  isDev?: boolean\n}\n\n/**\n * Rejects requests unless verified enabledModules contains the requested module or \"all\".\n * @param moduleKey - Exact, case-sensitive entitlement key required by this route.\n * @param options - Development bypass; see {@link ModuleGuardOptions}.\n * @returns Hono middleware that responds with 403 for missing, malformed, or insufficient entitlements, or completes downstream handling without returning a value.\n * @throws Request execution propagates downstream middleware rejections.\n * @remarks Install authentication and trusted entitlement resolution first. This guard reads context only and does not query a contract store. The development bypass defaults from NODE_ENV.\n * @example\n * ```typescript\n * import { Hono } from \"hono\";\n * import type { EaosEnv } from \"@alneas/eaos-core\";\n * import { createModuleGuard } from \"@alneas/eaos-server/middleware/module-guard\";\n * const app = new Hono<EaosEnv>();\n * app.use(\"/reports/*\", createModuleGuard(\"reports\", { isDev: false }));\n * // Populate verified enabledModules in earlier host middleware to allow access.\n * app.get(\"/reports/summary\", c => c.json({ available: true }));\n * console.log((await app.request(\"/reports/summary\")).status); // 403\n * ```\n */\nexport function createModuleGuard(moduleKey: string, options?: ModuleGuardOptions) {\n  return createMiddleware<EaosEnv>(async (c, next) => {\n    const isDev = options?.isDev ?? process.env.NODE_ENV === 'development'\n    if (isDev) {\n      return await next()\n    }\n\n    const enabledModules = c.get('enabledModules')\n\n    if (!Array.isArray(enabledModules) || enabledModules.some(module => typeof module !== 'string')) {\n      console.warn(`[ModuleGuard] Entitlements unavailable for module '${moduleKey}' tenant=${c.get('tenantId')}`)\n      return c.json({\n        error: 'Module Entitlements Unavailable',\n        message: 'Module entitlements must be verified before accessing this module.'\n      }, 403)\n    }\n\n    if (!enabledModules.includes(moduleKey) && !enabledModules.includes('all')) {\n      console.warn(`[ModuleGuard] Blocked request to module '${moduleKey}' for tenant=${c.get('tenantId')}`)\n      return c.json({\n        error: 'Module Not Licensed',\n        message: `The module '${moduleKey}' is not enabled for your tenant.`\n      }, 403)\n    }\n\n    await next()\n  })\n}\n"],"mappings":";AAAA,SAAS,wBAAwB;AA8B1B,SAAS,kBAAkB,WAAmB,SAA8B;AACjF,SAAO,iBAA0B,OAAO,GAAG,SAAS;AAClD,UAAM,QAAQ,SAAS,SAAS,QAAQ,IAAI,aAAa;AACzD,QAAI,OAAO;AACT,aAAO,MAAM,KAAK;AAAA,IACpB;AAEA,UAAM,iBAAiB,EAAE,IAAI,gBAAgB;AAE7C,QAAI,CAAC,MAAM,QAAQ,cAAc,KAAK,eAAe,KAAK,YAAU,OAAO,WAAW,QAAQ,GAAG;AAC/F,cAAQ,KAAK,sDAAsD,SAAS,YAAY,EAAE,IAAI,UAAU,CAAC,EAAE;AAC3G,aAAO,EAAE,KAAK;AAAA,QACZ,OAAO;AAAA,QACP,SAAS;AAAA,MACX,GAAG,GAAG;AAAA,IACR;AAEA,QAAI,CAAC,eAAe,SAAS,SAAS,KAAK,CAAC,eAAe,SAAS,KAAK,GAAG;AAC1E,cAAQ,KAAK,4CAA4C,SAAS,gBAAgB,EAAE,IAAI,UAAU,CAAC,EAAE;AACrG,aAAO,EAAE,KAAK;AAAA,QACZ,OAAO;AAAA,QACP,SAAS,eAAe,SAAS;AAAA,MACnC,GAAG,GAAG;AAAA,IACR;AAEA,UAAM,KAAK;AAAA,EACb,CAAC;AACH;","names":[]}

package/dist/chunk-VF5YDZJC.js

@@ -0,0 +1,305 @@
+import {
+  EntitlementError,
+  requiresEntitlementRuntime
+} from "./chunk-46UWPEW2.js";
+
+// src/mcp.ts
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import Ajv from "ajv";
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+function createMcpRouter(runtime, options) {
+  const router = new Hono();
+  const ajv = new Ajv({ strict: false, allErrors: true });
+  const ajv2020 = new Ajv2020({ strict: false, allErrors: true });
+  addFormats(ajv);
+  addFormats(ajv2020);
+  const entitled = async (p, id) => {
+    const rule = runtime.registry.get(id)?.entitlement;
+    return !rule || !requiresEntitlementRuntime(rule) || !!options.entitlements && (await options.entitlements.check(p, id, rule)).allowed;
+  };
+  const admit = async (p, plugin, operation) => {
+    if (!plugin.entitlement || !requiresEntitlementRuntime(plugin.entitlement)) return;
+    if (!options.entitlements) throw Error("Entitlement service unavailable");
+    await options.entitlements.admit(p, plugin.id, plugin.entitlement, operation);
+  };
+  const preview = async (p, plugin) => {
+    if (!plugin.entitlement || !requiresEntitlementRuntime(plugin.entitlement)) return null;
+    if (!options.entitlements) return { status: 503, error: "Entitlement service unavailable" };
+    const decision = await options.entitlements.check(p, plugin.id, plugin.entitlement);
+    return decision.allowed ? null : { status: decision.status, error: decision.reason };
+  };
+  router.use("*", bodyLimit({ maxSize: 1024 * 1024 }));
+  router.onError((error, c) => {
+    options.onError?.(error);
+    return c.json({ error: "MCP request failed" }, 500);
+  });
+  function tools() {
+    const names = /* @__PURE__ */ new Set();
+    return runtime.registry.getAll().flatMap((plugin) => (plugin.mcp?.tools ?? []).map((tool) => {
+      if (names.has(tool.name)) throw new Error(`Duplicate MCP tool name: ${tool.name}`);
+      names.add(tool.name);
+      return { plugin, tool };
+    }));
+  }
+  async function resolveAIAdapters(principal2, pluginId, toolName, traceId) {
+    if (!options.resolveAIHostAdapters) return void 0;
+    return options.resolveAIHostAdapters({
+      principal: principal2,
+      pluginId,
+      toolName,
+      context: { tenantId: principal2.tenantId, userId: principal2.userId, operation: `mcp:${toolName}`, traceId }
+    });
+  }
+  async function principal(c) {
+    const p = await options.resolvePrincipal(c);
+    if (!p || typeof p.userId !== "string" || !p.userId.trim() || typeof p.tenantId !== "string" || !p.tenantId.trim() || !Array.isArray(p.roles) || !p.roles.every((v) => typeof v === "string") || !Array.isArray(p.enabledPluginIds) || !p.enabledPluginIds.every((v) => typeof v === "string")) return null;
+    if (options.tenantId && p.tenantId !== options.tenantId) return null;
+    return { userId: p.userId, tenantId: p.tenantId, roles: [...p.roles], enabledPluginIds: [...p.enabledPluginIds] };
+  }
+  router.get("/tools", async (c) => {
+    const p = await principal(c);
+    if (!p) return c.json({ error: "Unauthorized" }, 401);
+    const active = /* @__PURE__ */ new Set();
+    for (const id of p.enabledPluginIds) if ((!options.isPluginEnabled || await options.isPluginEnabled(p, id)) && await entitled(p, id)) active.add(id);
+    return c.json({ tools: tools().filter(
+      ({ plugin, tool }) => active.has(plugin.id) && runtime.gatekeeper.validateCall({ toolName: tool.name, userRoles: p.roles, tenantId: p.tenantId }).allowed
+    ).map(({ plugin, tool }) => ({ name: tool.name, description: tool.description, inputSchema: tool.parameters, pluginId: plugin.id })) });
+  });
+  router.post("/execute", async (c) => {
+    const p = await principal(c);
+    if (!p) return c.json({ error: "Unauthorized" }, 401);
+    if (!/^application\/json(?:;|$)/i.test(c.req.header("Content-Type") ?? "")) return c.json({ error: "JSON content type required" }, 415);
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body !== "object" || Array.isArray(body) || typeof body.name !== "string" || !body.args || typeof body.args !== "object" || Array.isArray(body.args) || Object.keys(body).some((k) => k !== "name" && k !== "args")) return c.json({ error: "Expected { name, args }" }, 400);
+    const entry = tools().find(({ tool }) => tool.name === body.name);
+    if (!entry || !p.enabledPluginIds.includes(entry.plugin.id) || options.isPluginEnabled && !await options.isPluginEnabled(p, entry.plugin.id)) return c.json({ error: "Tool unavailable" }, 404);
+    const admission = await preview(p, entry.plugin);
+    if (admission) return c.json({ error: admission.error }, admission.status);
+    const traceId = crypto.randomUUID();
+    const verdict = runtime.gatekeeper.validateCall({ toolName: entry.tool.name, userRoles: p.roles, tenantId: p.tenantId, traceId });
+    const audit = {
+      toolName: entry.tool.name,
+      userId: p.userId,
+      tenantId: p.tenantId,
+      traceId,
+      riskLevel: verdict.riskLevel,
+      approvalLevel: verdict.approvalLevel
+    };
+    if (!verdict.allowed) {
+      runtime.gatekeeper.logCall({ ...audit, status: "BLOCKED", reason: verdict.reason });
+      return c.json({ error: "Forbidden", traceId }, 403);
+    }
+    const schema = entry.tool.parameters;
+    const validator = (String(schema.$schema ?? "").includes("2020-12") ? ajv2020 : ajv).compile(schema);
+    if (!validator(body.args)) return c.json({ error: "Invalid tool arguments", traceId }, 400);
+    if (verdict.requireHumanApproval) {
+      runtime.gatekeeper.logCall({ ...audit, status: "PENDING_APPROVAL" });
+      return c.json({ requireHumanApproval: true, approvalLevel: verdict.approvalLevel, traceId }, 202);
+    }
+    if (options.isPluginEnabled && !await options.isPluginEnabled(p, entry.plugin.id)) return c.json({ error: "Tool unavailable" }, 404);
+    const dependencies = await options.createToolContext?.(p, entry.plugin.id) ?? {};
+    const aiHostAdapters = await resolveAIAdapters(p, entry.plugin.id, entry.tool.name, traceId);
+    if (options.isPluginEnabled && !await options.isPluginEnabled(p, entry.plugin.id)) return c.json({ error: "Tool unavailable" }, 404);
+    const context = Object.freeze({
+      ...dependencies,
+      ...aiHostAdapters ? { aiHostAdapters: Object.freeze(aiHostAdapters) } : {},
+      tenantId: p.tenantId,
+      userId: p.userId,
+      roles: Object.freeze([...p.roles]),
+      pluginId: entry.plugin.id,
+      traceId
+    });
+    try {
+      await admit(p, entry.plugin, `mcp:${entry.tool.name}`);
+    } catch (error) {
+      if (error instanceof EntitlementError) {
+        runtime.gatekeeper.logCall({ ...audit, status: "BLOCKED", reason: error.message });
+        return c.json({ error: error.message }, error.decision.status);
+      }
+      throw error;
+    }
+    runtime.gatekeeper.logCall({ ...audit, status: "ALLOWED" });
+    const result = await entry.tool.handler(body.args, context);
+    return c.json({ result, traceId });
+  });
+  const sseSessions = /* @__PURE__ */ new Map();
+  const boundedNumber = (value, fallback, minimum) => typeof value === "number" && Number.isFinite(value) ? Math.max(minimum, Math.floor(value)) : fallback;
+  const sseSessionTtlMs = boundedNumber(options.sseSessionTtlMs, 30 * 60 * 1e3, 1e3);
+  const maxSseSessions = boundedNumber(options.maxSseSessions, 1e3, 1);
+  function purgeExpiredSseSessions(now = Date.now()) {
+    for (const [id, session] of sseSessions) {
+      if (now - session.createdAt >= sseSessionTtlMs || now - session.lastActivityAt >= sseSessionTtlMs) sseSessions.delete(id);
+    }
+  }
+  router.get("/sse", async (c) => {
+    const p = await principal(c);
+    if (!p) return c.json({ error: "Unauthorized" }, 401);
+    const now = Date.now();
+    purgeExpiredSseSessions(now);
+    if (sseSessions.size >= maxSseSessions) return c.json({ error: "MCP SSE capacity exhausted" }, 503);
+    const sessionId = crypto.randomUUID();
+    const endpointUrl = `${new URL(c.req.url).pathname.replace(/\/sse$/, "")}/message?sessionId=${sessionId}`;
+    let cleanup;
+    const stream = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder();
+        const send = (data) => {
+          try {
+            const session = sseSessions.get(sessionId);
+            if (session) session.lastActivityAt = Date.now();
+            controller.enqueue(encoder.encode(data));
+          } catch {
+            cleanup?.();
+          }
+        };
+        sseSessions.set(sessionId, { userId: p.userId, tenantId: p.tenantId, createdAt: now, lastActivityAt: now, send });
+        cleanup = () => sseSessions.delete(sessionId);
+        send(`event: endpoint
+data: ${endpointUrl}
+
+`);
+      },
+      cancel() {
+        cleanup?.();
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  });
+  router.post("/message", async (c) => {
+    const p = await principal(c);
+    if (!p) return c.json({ jsonrpc: "2.0", error: { code: -32e3, message: "Unauthorized" }, id: null }, 401);
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body !== "object" || body.jsonrpc !== "2.0" || typeof body.method !== "string") {
+      return c.json({ jsonrpc: "2.0", error: { code: -32600, message: "Invalid Request" }, id: body?.id ?? null }, 400);
+    }
+    const id = body.id ?? null;
+    const sessionId = c.req.query("sessionId");
+    purgeExpiredSseSessions();
+    const session = sessionId ? sseSessions.get(sessionId) : void 0;
+    if (sessionId && !session) return c.json({ jsonrpc: "2.0", error: { code: -32e3, message: "MCP session unavailable" }, id }, 404);
+    if (session && (session.userId !== p.userId || session.tenantId !== p.tenantId)) {
+      return c.json({ jsonrpc: "2.0", error: { code: -32003, message: "MCP session owner mismatch" }, id }, 403);
+    }
+    if (session) session.lastActivityAt = Date.now();
+    const sendRpcResponse = (payload) => {
+      const serialized = JSON.stringify(payload);
+      if (session) {
+        session.send(`event: message
+data: ${serialized}
+
+`);
+      }
+      return c.json(payload);
+    };
+    if (body.method === "tools/list") {
+      const active = /* @__PURE__ */ new Set();
+      for (const pid of p.enabledPluginIds) if ((!options.isPluginEnabled || await options.isPluginEnabled(p, pid)) && await entitled(p, pid)) active.add(pid);
+      const available = tools().filter(
+        ({ plugin, tool }) => active.has(plugin.id) && runtime.gatekeeper.validateCall({ toolName: tool.name, userRoles: p.roles, tenantId: p.tenantId }).allowed
+      ).map(({ plugin, tool }) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.parameters,
+        pluginId: plugin.id
+      }));
+      return sendRpcResponse({ jsonrpc: "2.0", result: { tools: available }, id });
+    }
+    if (body.method === "tools/call") {
+      const toolName = body.params?.name;
+      const toolArgs = body.params?.arguments ?? {};
+      if (typeof toolName !== "string" || typeof toolArgs !== "object" || Array.isArray(toolArgs)) {
+        return sendRpcResponse({ jsonrpc: "2.0", error: { code: -32602, message: "Invalid params" }, id });
+      }
+      const entry = tools().find(({ tool }) => tool.name === toolName);
+      if (!entry || !p.enabledPluginIds.includes(entry.plugin.id) || options.isPluginEnabled && !await options.isPluginEnabled(p, entry.plugin.id)) {
+        return sendRpcResponse({ jsonrpc: "2.0", error: { code: -32601, message: "Tool not found" }, id });
+      }
+      const admission = await preview(p, entry.plugin);
+      if (admission) return sendRpcResponse({ jsonrpc: "2.0", error: { code: -32003, message: admission.error, data: { status: admission.status } }, id });
+      const traceId = crypto.randomUUID();
+      const verdict = runtime.gatekeeper.validateCall({ toolName: entry.tool.name, userRoles: p.roles, tenantId: p.tenantId, traceId });
+      const audit = {
+        toolName: entry.tool.name,
+        userId: p.userId,
+        tenantId: p.tenantId,
+        traceId,
+        riskLevel: verdict.riskLevel,
+        approvalLevel: verdict.approvalLevel
+      };
+      if (!verdict.allowed) {
+        runtime.gatekeeper.logCall({ ...audit, status: "BLOCKED", reason: verdict.reason });
+        return sendRpcResponse({ jsonrpc: "2.0", error: { code: -32003, message: "Forbidden: tool execution denied" }, id });
+      }
+      const schema = entry.tool.parameters;
+      const validator = (String(schema.$schema ?? "").includes("2020-12") ? ajv2020 : ajv).compile(schema);
+      if (!validator(toolArgs)) {
+        return sendRpcResponse({ jsonrpc: "2.0", error: { code: -32602, message: "Invalid tool arguments" }, id });
+      }
+      if (verdict.requireHumanApproval) {
+        runtime.gatekeeper.logCall({ ...audit, status: "PENDING_APPROVAL" });
+        return sendRpcResponse({
+          jsonrpc: "2.0",
+          result: {
+            content: [{ type: "text", text: `Human approval required (${verdict.approvalLevel})` }],
+            isError: true,
+            requireHumanApproval: true,
+            approvalLevel: verdict.approvalLevel,
+            traceId
+          },
+          id
+        });
+      }
+      if (options.isPluginEnabled && !await options.isPluginEnabled(p, entry.plugin.id)) {
+        return sendRpcResponse({ jsonrpc: "2.0", error: { code: -32601, message: "Tool not found" }, id });
+      }
+      const dependencies = await options.createToolContext?.(p, entry.plugin.id) ?? {};
+      const aiHostAdapters = await resolveAIAdapters(p, entry.plugin.id, entry.tool.name, traceId);
+      if (options.isPluginEnabled && !await options.isPluginEnabled(p, entry.plugin.id)) {
+        return sendRpcResponse({ jsonrpc: "2.0", error: { code: -32601, message: "Tool not found" }, id });
+      }
+      const context = Object.freeze({
+        ...dependencies,
+        ...aiHostAdapters ? { aiHostAdapters: Object.freeze(aiHostAdapters) } : {},
+        tenantId: p.tenantId,
+        userId: p.userId,
+        roles: Object.freeze([...p.roles]),
+        pluginId: entry.plugin.id,
+        traceId
+      });
+      try {
+        await admit(p, entry.plugin, `mcp:${entry.tool.name}`);
+      } catch (error) {
+        if (error instanceof EntitlementError) {
+          runtime.gatekeeper.logCall({ ...audit, status: "BLOCKED", reason: error.message });
+          return sendRpcResponse({ jsonrpc: "2.0", error: { code: -32003, message: error.message, data: { status: error.decision.status } }, id });
+        }
+        throw error;
+      }
+      runtime.gatekeeper.logCall({ ...audit, status: "ALLOWED" });
+      const handlerResult = await entry.tool.handler(toolArgs, context);
+      return sendRpcResponse({
+        jsonrpc: "2.0",
+        result: {
+          content: [{ type: "text", text: JSON.stringify(handlerResult) }],
+          traceId
+        },
+        id
+      });
+    }
+    return sendRpcResponse({ jsonrpc: "2.0", error: { code: -32601, message: "Method not found" }, id });
+  });
+  return router;
+}
+
+export {
+  createMcpRouter
+};
+//# sourceMappingURL=chunk-VF5YDZJC.js.map