@agen-ai/agent-orchestration 0.0.0-stage → 0.4.0

package/dist/mcp/bridge.js

@@ -0,0 +1,222 @@
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { validateAgentSessionHostBinding } from "@agen-ai/agent-runtime";
+import { DelegationOperationError } from "../shared/operational-errors.js";
+import { authorizeRequest, McpHttpError, readRequestBody, webRequest, writeError, writeResponse } from "./http.js";
+import { MCP_HEADER_BYTES, MCP_MAX_CONNECTIONS, MCP_MAX_HTTP_REQUESTS, MCP_RECEIPT_TIMEOUT_MS, requestTimeout, shutdownTimeout } from "./limits.js";
+import { createMcpProtocol, mcpTools } from "./protocol.js";
+const activeBindings = /* @__PURE__ */ new WeakSet();
+function aborted() {
+  return new DOMException("The MCP transport operation was canceled.", "AbortError");
+}
+async function untilAborted(pending, signal) {
+  signal.throwIfAborted();
+  let cancel;
+  try {
+    return await Promise.race([pending, new Promise((_, reject) => {
+      cancel = () => reject(aborted());
+      signal.addEventListener("abort", cancel, { once: true });
+    })]);
+  } finally {
+    if (cancel) signal.removeEventListener("abort", cancel);
+  }
+}
+async function withinDeadline(pending, deadline) {
+  let timer;
+  try {
+    return await Promise.race([pending, new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new DelegationOperationError(
+        "recovery_required",
+        "MCP producers have not quiesced; transport cleanup responsibility is retained."
+      )), Math.max(1, deadline - Date.now()));
+    })]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function requestKey(value) {
+  if (typeof value === "string" && Buffer.byteLength(value) <= 128) return `string:${value}`;
+  if (typeof value === "number" && Number.isSafeInteger(value)) return `number:${value}`;
+  return void 0;
+}
+async function startDelegationMcpBridge(options) {
+  const originalBinding = options.binding;
+  const startupSignal = options.signal;
+  startupSignal?.throwIfAborted();
+  const timeoutMs = shutdownTimeout(options.shutdownTimeoutMs);
+  const responseTimeoutMs = requestTimeout(options.requestTimeoutMs);
+  const binding = validateAgentSessionHostBinding({ binding: originalBinding, support: {
+    kind: "supported",
+    toolTransport: "mcp",
+    instructionPlacements: ["tool_context"]
+  } });
+  const tools = mcpTools(binding);
+  const authorization = Buffer.from(`Bearer ${randomBytes(32).toString("base64url")}`);
+  const lifetime = new AbortController();
+  const requests = /* @__PURE__ */ new Set();
+  const calls = /* @__PURE__ */ new Set();
+  const sockets = /* @__PURE__ */ new Set();
+  const controllers = /* @__PURE__ */ new Map();
+  const protocols = /* @__PURE__ */ new Set();
+  let accepting = true;
+  let released = false;
+  let releasing;
+  let listenerClose;
+  let host = "";
+  let url = "";
+  const assertAccepting = () => {
+    if (!accepting) throw new McpHttpError(503);
+  };
+  const cancelRequest = (requestId) => {
+    const key = requestKey(requestId);
+    if (key !== void 0) controllers.get(key)?.abort(aborted());
+  };
+  const stopAdmission = () => {
+    accepting = false;
+    lifetime.abort(aborted());
+    for (const socket of sockets) socket.destroy();
+  };
+  const closeProtocol = async (entry) => {
+    try {
+      await entry.protocol.close();
+      protocols.delete(entry);
+    } catch {
+      stopAdmission();
+      throw new DelegationOperationError("recovery_required", "MCP protocol cleanup is incomplete; cleanup responsibility is retained.");
+    }
+  };
+  const serve = async (request, response) => {
+    const controller = new AbortController();
+    const signal = AbortSignal.any([lifetime.signal, controller.signal]);
+    const stop = () => controller.abort(aborted());
+    const disconnect = () => {
+      if (!response.writableEnded) stop();
+    };
+    const destroy = () => {
+      request.destroy();
+      response.destroy();
+    };
+    request.once("aborted", stop);
+    response.once("close", disconnect);
+    signal.addEventListener("abort", destroy, { once: true });
+    let timer = setTimeout(stop, MCP_RECEIPT_TIMEOUT_MS);
+    let entry;
+    let key;
+    try {
+      assertAccepting();
+      authorizeRequest(request, host, authorization);
+      const body = await readRequestBody(request);
+      clearTimeout(timer);
+      timer = setTimeout(stop, responseTimeoutMs);
+      request.socket.setTimeout(responseTimeoutMs);
+      signal.throwIfAborted();
+      if (Object.hasOwn(body, "id")) {
+        key = requestKey(body.id);
+        if (key === void 0) throw new McpHttpError(400);
+        if (controllers.has(key)) throw new McpHttpError(409);
+        controllers.set(key, controller);
+      }
+      entry = createMcpProtocol({ binding, signal, calls, assertAccepting, cancelRequest }, tools);
+      protocols.add(entry);
+      await entry.protocol.connect(entry.transport);
+      const result = await untilAborted(entry.transport.handleRequest(webRequest(request, url), { parsedBody: body }), signal);
+      await writeResponse(response, result);
+    } catch (error) {
+      writeError(response, error instanceof McpHttpError ? error.status : signal.aborted ? 408 : 400);
+    } finally {
+      clearTimeout(timer);
+      request.removeListener("aborted", stop);
+      response.removeListener("close", disconnect);
+      signal.removeEventListener("abort", destroy);
+      if (key !== void 0 && controllers.get(key) === controller) controllers.delete(key);
+      if (entry) await closeProtocol(entry);
+    }
+  };
+  const listener = createServer({
+    maxHeaderSize: MCP_HEADER_BYTES,
+    requestTimeout: MCP_RECEIPT_TIMEOUT_MS,
+    headersTimeout: MCP_RECEIPT_TIMEOUT_MS,
+    connectionsCheckingInterval: 1e3,
+    keepAliveTimeout: 1e3
+  }, (request, response) => {
+    if (!accepting || requests.size >= MCP_MAX_HTTP_REQUESTS) {
+      writeError(response, accepting ? 429 : 503);
+      return;
+    }
+    const pending = serve(request, response).catch(() => {
+      writeError(response, 500);
+    }).finally(() => {
+      requests.delete(pending);
+    });
+    requests.add(pending);
+  });
+  listener.maxConnections = MCP_MAX_CONNECTIONS;
+  listener.on("error", stopAdmission);
+  listener.on("connection", (socket) => {
+    sockets.add(socket);
+    socket.once("close", () => {
+      sockets.delete(socket);
+    });
+    socket.setTimeout(MCP_RECEIPT_TIMEOUT_MS, () => {
+      socket.destroy();
+    });
+  });
+  const release = () => {
+    if (released) return Promise.resolve();
+    if (releasing) return releasing;
+    stopAdmission();
+    if (!listenerClose) listenerClose = new Promise((resolve, reject) => {
+      listener.close((error) => {
+        if (error && (!("code" in error) || error.code !== "ERR_SERVER_NOT_RUNNING")) reject(error);
+        else resolve();
+      });
+    });
+    const deadline = Date.now() + timeoutMs;
+    releasing = Promise.resolve().then(async () => {
+      await withinDeadline(Promise.allSettled([...requests, ...calls]), deadline);
+      const closed = await withinDeadline(Promise.allSettled([listenerClose, ...[...protocols].map(closeProtocol)]), deadline);
+      if (calls.size !== 0 || requests.size !== 0 || protocols.size !== 0 || closed.some((result) => result.status === "rejected")) {
+        throw new DelegationOperationError("recovery_required", "MCP transport cleanup is incomplete; the binding owner must retain its lease.");
+      }
+      released = true;
+      activeBindings.delete(originalBinding);
+    }).finally(() => {
+      releasing = void 0;
+    });
+    return releasing;
+  };
+  startupSignal?.throwIfAborted();
+  if (activeBindings.has(originalBinding)) throw new TypeError("This host binding already has an active MCP transport.");
+  activeBindings.add(originalBinding);
+  try {
+    await new Promise((resolve, reject) => {
+      const failed = () => {
+        listener.removeListener("listening", opened);
+        reject(new TypeError("The loopback MCP listener could not start."));
+      };
+      const opened = () => {
+        listener.removeListener("error", failed);
+        resolve();
+      };
+      listener.once("error", failed);
+      listener.once("listening", opened);
+      listener.listen(0, "127.0.0.1");
+    });
+    startupSignal?.throwIfAborted();
+    const address = listener.address();
+    if (!address || typeof address === "string") throw new TypeError("The loopback MCP listener has no address.");
+    host = `127.0.0.1:${address.port}`;
+    url = `http://${host}/mcp`;
+  } catch (error) {
+    await release();
+    throw error;
+  }
+  return Object.freeze({ server: Object.freeze({
+    name: "agenai_delegation",
+    url,
+    headers: Object.freeze({ Authorization: authorization.toString() })
+  }), release });
+}
+export {
+  startDelegationMcpBridge
+};

package/dist/mcp/http.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare class McpHttpError extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+export declare function authorizeRequest(request: IncomingMessage, expectedHost: string, authorization: Buffer): void;
+export declare function readRequestBody(request: IncomingMessage): Promise<unknown>;
+export declare function webRequest(request: IncomingMessage, url: string): Request;
+export declare function writeResponse(response: ServerResponse, result: Response): Promise<void>;
+export declare function writeError(response: ServerResponse, status: number): void;
+//# sourceMappingURL=http.d.ts.map

package/dist/mcp/http.js

@@ -0,0 +1,74 @@
+import { timingSafeEqual } from "node:crypto";
+import { MCP_REQUEST_BYTES, MCP_RESPONSE_BYTES } from "./limits.js";
+class McpHttpError extends Error {
+  constructor(status) {
+    super("The MCP HTTP request is unavailable.");
+    this.status = status;
+  }
+  status;
+}
+function authorizeRequest(request, expectedHost, authorization) {
+  if (request.headers.host !== expectedHost || request.headers.origin !== void 0) throw new McpHttpError(403);
+  const supplied = request.headers.authorization;
+  if (typeof supplied !== "string") throw new McpHttpError(401);
+  const encoded = Buffer.from(supplied);
+  if (encoded.length !== authorization.length || !timingSafeEqual(encoded, authorization)) throw new McpHttpError(401);
+  if (request.url !== "/mcp") throw new McpHttpError(404);
+  if (request.method !== "POST") throw new McpHttpError(405);
+  if (request.headers["content-encoding"] !== void 0) throw new McpHttpError(415);
+  const length = request.headers["content-length"];
+  if (length !== void 0 && (!/^\d+$/u.test(length) || Number(length) > MCP_REQUEST_BYTES)) throw new McpHttpError(413);
+}
+async function readRequestBody(request) {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.length;
+    if (bytes > MCP_REQUEST_BYTES) throw new McpHttpError(413);
+    chunks.push(buffer);
+  }
+  let body;
+  try {
+    body = JSON.parse(Buffer.concat(chunks, bytes).toString("utf8"));
+  } catch {
+    throw new McpHttpError(400);
+  }
+  if (body === null || typeof body !== "object" || Array.isArray(body)) throw new McpHttpError(400);
+  return body;
+}
+function webRequest(request, url) {
+  const headers = new Headers();
+  for (const name of ["accept", "content-type", "mcp-protocol-version"]) {
+    const value = request.headers[name];
+    if (typeof value === "string") headers.set(name, value);
+  }
+  return new Request(url, { method: "POST", headers });
+}
+async function writeResponse(response, result) {
+  const body = Buffer.from(await result.arrayBuffer());
+  if (body.length > MCP_RESPONSE_BYTES) throw new McpHttpError(500);
+  if (response.destroyed) return;
+  response.statusCode = result.status;
+  response.setHeader("cache-control", "no-store");
+  response.setHeader("content-type", "application/json");
+  response.setHeader("content-length", body.length);
+  response.end(body);
+}
+function writeError(response, status) {
+  if (response.destroyed || response.writableEnded) return;
+  response.statusCode = status;
+  response.setHeader("connection", "close");
+  response.setHeader("cache-control", "no-store");
+  response.setHeader("content-type", "application/json");
+  if (status === 405) response.setHeader("allow", "POST");
+  response.end('{"error":"The MCP request is unavailable."}');
+}
+export {
+  McpHttpError,
+  authorizeRequest,
+  readRequestBody,
+  webRequest,
+  writeError,
+  writeResponse
+};

package/dist/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export { startDelegationMcpBridge } from "./bridge.js";
+export type { DelegationMcpBridge, DelegationMcpServerDefinition, StartDelegationMcpBridgeOptions } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -0,0 +1,4 @@
+import { startDelegationMcpBridge } from "./bridge.js";
+export {
+  startDelegationMcpBridge
+};

package/dist/mcp/limits.d.ts

@@ -0,0 +1,10 @@
+export declare const MCP_REQUEST_BYTES = 65536;
+export declare const MCP_RESPONSE_BYTES = 131072;
+export declare const MCP_HEADER_BYTES = 8192;
+export declare const MCP_RECEIPT_TIMEOUT_MS = 10000;
+export declare const MCP_MAX_HTTP_REQUESTS = 32;
+export declare const MCP_MAX_INVOCATIONS = 16;
+export declare const MCP_MAX_CONNECTIONS = 32;
+export declare function shutdownTimeout(value?: number): number;
+export declare function requestTimeout(value?: number): number;
+//# sourceMappingURL=limits.d.ts.map

package/dist/mcp/limits.js

@@ -0,0 +1,30 @@
+const MCP_REQUEST_BYTES = 65536;
+const MCP_RESPONSE_BYTES = 131072;
+const MCP_HEADER_BYTES = 8192;
+const MCP_RECEIPT_TIMEOUT_MS = 1e4;
+const MCP_MAX_HTTP_REQUESTS = 32;
+const MCP_MAX_INVOCATIONS = 16;
+const MCP_MAX_CONNECTIONS = 32;
+function finiteTimeout(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > 2147483647) {
+    throw new TypeError("MCP operations require a finite positive timeout.");
+  }
+  return value;
+}
+function shutdownTimeout(value = 1e4) {
+  return finiteTimeout(value);
+}
+function requestTimeout(value = 6e4) {
+  return finiteTimeout(value);
+}
+export {
+  MCP_HEADER_BYTES,
+  MCP_MAX_CONNECTIONS,
+  MCP_MAX_HTTP_REQUESTS,
+  MCP_MAX_INVOCATIONS,
+  MCP_RECEIPT_TIMEOUT_MS,
+  MCP_REQUEST_BYTES,
+  MCP_RESPONSE_BYTES,
+  requestTimeout,
+  shutdownTimeout
+};

package/dist/mcp/protocol.d.ts

@@ -0,0 +1,50 @@
+import { type AgentHostToolResult, type AgentSessionHostBinding } from "@agen-ai/agent-runtime";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { type Tool } from "@modelcontextprotocol/sdk/types.js";
+export interface McpProtocolContext {
+    readonly binding: AgentSessionHostBinding;
+    readonly signal: AbortSignal;
+    readonly calls: Set<Promise<AgentHostToolResult>>;
+    assertAccepting(): void;
+    cancelRequest(requestId: string | number): void;
+}
+export declare function mcpTools(binding: AgentSessionHostBinding): Tool[];
+export declare function createMcpProtocol(context: McpProtocolContext, tools: Tool[]): {
+    protocol: Server<{
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    transport: WebStandardStreamableHTTPServerTransport;
+};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/mcp/protocol.js

@@ -0,0 +1,81 @@
+import { randomUUID } from "node:crypto";
+import { parseAgentJsonValue } from "@agen-ai/agent-protocol";
+import {
+  validateAgentHostToolInvocation,
+  validateAgentHostToolResult
+} from "@agen-ai/agent-runtime";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { CallToolRequestSchema, CancelledNotificationSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { MCP_MAX_INVOCATIONS, MCP_RESPONSE_BYTES } from "./limits.js";
+function failure(code, message) {
+  return { kind: "error", error: { code, message, category: "unknown", recovery: { kind: "unknown" } } };
+}
+function encodeResult(result) {
+  return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: { ...result }, isError: result.kind === "error" };
+}
+function mcpTools(binding) {
+  const tools = binding.tools.map((tool) => {
+    const { required, ...schema } = tool.inputSchema;
+    return { name: tool.name, description: tool.description, inputSchema: {
+      ...schema,
+      properties: { ...schema.properties },
+      ...required ? { required: [...required] } : {}
+    } };
+  });
+  const envelope = { jsonrpc: "2.0", id: "preflight", result: { tools } };
+  if (Buffer.byteLength(JSON.stringify(envelope)) > MCP_RESPONSE_BYTES) {
+    throw new TypeError("The complete MCP tool list exceeds its HTTP response bound.");
+  }
+  return tools;
+}
+function createMcpProtocol(context, tools) {
+  const protocol = new Server({ name: "agenai_delegation", version: "0.4.0" }, {
+    capabilities: { tools: {} },
+    ...context.binding.instructions ? { instructions: context.binding.instructions.text } : {}
+  });
+  const transport = new WebStandardStreamableHTTPServerTransport({ enableJsonResponse: true });
+  protocol.setNotificationHandler(CancelledNotificationSchema, (notification) => {
+    if (notification.params.requestId !== void 0) context.cancelRequest(notification.params.requestId);
+  });
+  protocol.setRequestHandler(ListToolsRequestSchema, () => {
+    context.assertAccepting();
+    return { tools };
+  });
+  protocol.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    let call;
+    try {
+      context.assertAccepting();
+      const signal = AbortSignal.any([context.signal, extra.signal]);
+      signal.throwIfAborted();
+      call = validateAgentHostToolInvocation({ binding: context.binding, invocation: {
+        invocationId: randomUUID(),
+        toolName: request.params.name,
+        arguments: parseAgentJsonValue(request.params.arguments ?? {}),
+        signal
+      } });
+    } catch {
+      return encodeResult(failure("invalid_tool_input", "The tool invocation is invalid or unavailable."));
+    }
+    if (context.calls.size >= MCP_MAX_INVOCATIONS) {
+      return encodeResult(failure("host_tool_capacity_exhausted", "The MCP binding has reached its invocation limit."));
+    }
+    const pending = Promise.resolve().then(async () => {
+      try {
+        call.signal?.throwIfAborted();
+        return validateAgentHostToolResult(await context.binding.invoke(call));
+      } catch {
+        return failure("host_tool_failed", "The host tool did not return a valid result.");
+      }
+    }).finally(() => {
+      context.calls.delete(pending);
+    });
+    context.calls.add(pending);
+    return encodeResult(await pending);
+  });
+  return { protocol, transport };
+}
+export {
+  createMcpProtocol,
+  mcpTools
+};

package/dist/mcp/types.d.ts

@@ -0,0 +1,22 @@
+import type { AgentSessionHostBinding } from "@agen-ai/agent-runtime";
+export interface DelegationMcpServerDefinition {
+    readonly name: "agenai_delegation";
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+}
+export interface DelegationMcpBridge {
+    /** Session-local connection data. The authorization header must never be logged or persisted. */
+    readonly server: DelegationMcpServerDefinition;
+    /** Stops and drains transport producers. The runtime owner separately releases the host binding. */
+    release(): Promise<void>;
+}
+export interface StartDelegationMcpBridgeOptions {
+    readonly binding: AgentSessionHostBinding;
+    /** Cancels startup only; successful startup transfers transport cleanup to release(). */
+    readonly signal?: AbortSignal;
+    /** Handler response budget, default 60 seconds. Set above any larger client wait budget. */
+    readonly requestTimeoutMs?: number;
+    /** Finite drain deadline; a nonquiescent callback retains cleanup responsibility for retry. */
+    readonly shutdownTimeoutMs?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/policy/matching.d.ts

@@ -0,0 +1,4 @@
+import type { DelegationTarget } from "../catalog/types.js";
+import type { DelegationExclusion } from "./types.js";
+export declare function matchDelegationExclusion(target: DelegationTarget, exclusion: DelegationExclusion, options: ReadonlyMap<string, string>): "excluded" | "unmatched" | "unverifiable";
+//# sourceMappingURL=matching.d.ts.map

package/dist/policy/matching.js

@@ -0,0 +1,18 @@
+function matchDelegationExclusion(target, exclusion, options) {
+  if (exclusion.providerKey !== void 0 && exclusion.providerKey !== target.providerKey || exclusion.modelId !== void 0 && exclusion.modelId !== target.modelId || exclusion.catalogId !== void 0 && exclusion.catalogId !== target.reference.catalogId || exclusion.targetId !== void 0 && exclusion.targetId !== target.reference.targetId || exclusion.options?.some((option) => options.get(option.key) !== option.optionId)) {
+    return "unmatched";
+  }
+  let unknown = false;
+  if (exclusion.reasoning !== void 0) {
+    if (target.reasoning.kind === "unknown") unknown = true;
+    else if (target.reasoning.value !== exclusion.reasoning) return "unmatched";
+  }
+  if (exclusion.executionMode !== void 0) {
+    if (target.executionMode.kind === "unknown") unknown = true;
+    else if (target.executionMode.value !== exclusion.executionMode) return "unmatched";
+  }
+  return unknown ? "unverifiable" : "excluded";
+}
+export {
+  matchDelegationExclusion
+};

package/dist/policy/parse.d.ts

@@ -0,0 +1,3 @@
+import type { DelegationPolicySnapshot } from "./types.js";
+export declare function parseDelegationPolicySnapshot(input: unknown): DelegationPolicySnapshot;
+//# sourceMappingURL=parse.d.ts.map

package/dist/policy/parse.js

@@ -0,0 +1,13 @@
+import { copyBoundedDelegationData } from "../shared/bounds.js";
+import { delegationSchemaError } from "../shared/errors.js";
+import { freezeDelegationData } from "../shared/immutable.js";
+import { PolicySnapshotSchema } from "./schemas.js";
+function parseDelegationPolicySnapshot(input) {
+  const captured = copyBoundedDelegationData(input);
+  const parsed = PolicySnapshotSchema.safeParse(captured);
+  if (!parsed.success) return delegationSchemaError(parsed.error, captured);
+  return freezeDelegationData(parsed.data);
+}
+export {
+  parseDelegationPolicySnapshot
+};

package/dist/policy/resolve.d.ts

@@ -0,0 +1,7 @@
+import type { DelegationTargetCatalog } from "../catalog/types.js";
+import type { DelegationPolicySnapshot, ResolvedDelegationPolicy } from "./types.js";
+export declare function resolveDelegationPolicy(input: Readonly<{
+    catalog: DelegationTargetCatalog;
+    policy: DelegationPolicySnapshot;
+}>): ResolvedDelegationPolicy;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/policy/resolve.js

@@ -0,0 +1,67 @@
+import { parseDelegationTargetCatalog } from "../catalog/parse.js";
+import { captureDelegationRecord } from "../shared/bounds.js";
+import { invalidDelegationData } from "../shared/errors.js";
+import { freezeDelegationData } from "../shared/immutable.js";
+import { matchDelegationExclusion } from "./matching.js";
+import { parseDelegationPolicySnapshot } from "./parse.js";
+import { targetIdentityKey } from "./schemas.js";
+function selectedTarget(target, selection) {
+  const key = targetIdentityKey(target.reference);
+  if (selection.kind === "explicit") return selection.targets.some((identity) => targetIdentityKey(identity) === key);
+  if (target.executionMode.kind === "unknown") {
+    return selection.unknownModeTargets.some((identity) => targetIdentityKey(identity) === key);
+  }
+  return target.executionMode.value === "standard" || selection.includeFast;
+}
+function resolveDelegationPolicy(input) {
+  const envelope = captureDelegationRecord(input);
+  if (Object.keys(envelope).length !== 2 || !Object.hasOwn(envelope, "catalog") || !Object.hasOwn(envelope, "policy")) {
+    invalidDelegationData("invalid_data", [], "Policy resolution requires exactly catalog and policy data.");
+  }
+  const catalog = parseDelegationTargetCatalog(envelope.catalog);
+  const policy = parseDelegationPolicySnapshot(envelope.policy);
+  const enabled = policy.developer.enabled && policy.user.enabled;
+  const selection = policy.user.enabled ? policy.user.selection : void 0;
+  const allowedTargets = [];
+  const decisions = catalog.targets.map((target) => {
+    const selected = selection !== void 0 && selectedTarget(target, selection);
+    const reasons = [];
+    if (!enabled) reasons.push({ code: "delegation_disabled", message: "Managed delegation is disabled by current policy." });
+    if (target.availability.kind === "unavailable") {
+      reasons.push({ code: "target_unavailable", message: target.availability.reason });
+    }
+    const options = new Map(target.options.map((option) => [option.key, option.optionId]));
+    const excluded = [];
+    const unverifiable = [];
+    for (const exclusion of policy.developer.exclusions) {
+      const match = matchDelegationExclusion(target, exclusion, options);
+      if (match === "excluded" && excluded.length < 10) {
+        excluded.push({ code: "developer_excluded", exclusionId: exclusion.exclusionId, message: "A developer exclusion denies this target." });
+      } else if (match === "unverifiable" && unverifiable.length < 10) {
+        unverifiable.push({ code: "developer_unverifiable", exclusionId: exclusion.exclusionId, message: "Unknown target semantics cannot prove compliance with a developer exclusion." });
+      }
+    }
+    reasons.push(...excluded, ...unverifiable);
+    if (selection !== void 0 && !selected) {
+      reasons.push(selection.kind === "all_available" && target.executionMode.kind === "unknown" ? { code: "unknown_mode_unselected", message: "Unknown execution mode requires selection of this exact target." } : { code: "user_unselected", message: "The end user has not selected this target." });
+    }
+    const firstReason = reasons[0];
+    const outcome = firstReason === void 0 ? "allowed" : firstReason.code === "developer_unverifiable" ? "unverifiable" : "denied";
+    if (outcome === "allowed") allowedTargets.push(target);
+    return { reference: target.reference, selected, outcome, reasons: reasons.slice(0, 10) };
+  });
+  const offered = new Set(catalog.targets.map((target) => targetIdentityKey(target.reference)));
+  const requested = selection === void 0 ? [] : selection.kind === "explicit" ? selection.targets : selection.unknownModeTargets;
+  return freezeDelegationData({
+    enabled,
+    policyRevision: policy.revision,
+    catalogId: catalog.catalogId,
+    catalogRevision: catalog.revision,
+    decisions,
+    allowedTargets,
+    missingSelections: requested.filter((identity) => !offered.has(targetIdentityKey(identity)))
+  });
+}
+export {
+  resolveDelegationPolicy
+};

package/dist/policy/schemas.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod/v4";
+import type { DelegationPolicySnapshot, DelegationTargetIdentity } from "./types.js";
+export declare function targetIdentityKey(identity: DelegationTargetIdentity): string;
+export declare const PolicySnapshotSchema: z.ZodType<DelegationPolicySnapshot>;
+//# sourceMappingURL=schemas.d.ts.map