@aopslab/aops-server 0.1.0

package/build/server/chunks/agent-gateway-runtime-DTZ4SxaC.js

@@ -0,0 +1,2598 @@
+import { dispatchDomainRequest } from '@aopslab/host-core';
+import { buildAgentGatewayOpenApi, buildFederatedToolCatalog, validateManifest } from '@aopslab/manifest';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { promisify } from 'node:util';
+import { createHash } from 'node:crypto';
+import { g as getLogger, h as hasProjectAliasValue } from './project-alias-DqE2v58Q.js';
+import Ajv from 'ajv';
+import { z } from 'zod';
+import { g as getHostConfig, r as resetHostPluginRegistry, c as getHostPluginRegistry } from './registry-5amIZito.js';
+
+function isRecord$3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeBaseUrl(value) {
+  return value.trim().replace(/\/+$/g, "");
+}
+function normalizeApiBasePath(value) {
+  const raw = (value ?? "/api").trim();
+  if (!raw) return "/api";
+  return raw.startsWith("/") ? raw.replace(/\/+$/g, "") || "/api" : `/${raw.replace(/\/+$/g, "")}`;
+}
+function normalizeDomain(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+function normalizeToolId(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+function normalizeSourceId(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function findTagValue(tags, prefix) {
+  if (!Array.isArray(tags)) return void 0;
+  const found = tags.find((tag) => typeof tag === "string" && tag.startsWith(prefix));
+  if (!found) return void 0;
+  const value = found.slice(prefix.length).trim().toLowerCase();
+  return value.length > 0 ? value : void 0;
+}
+function toFriendlyResourceName(tool) {
+  const tagged = findTagValue(tool.tags, "resource:");
+  const raw = tagged ?? tool.operationId.split(".")[0] ?? "resource";
+  return raw.replace(/[-_]+/g, " ").trim();
+}
+function resolveOperationKind(tool) {
+  return findTagValue(tool.tags, "kind:");
+}
+function buildToolSummary(tool) {
+  const resource = toFriendlyResourceName(tool);
+  const kind = resolveOperationKind(tool);
+  if (kind === "list") return `List ${resource} records with optional filter and options.`;
+  if (kind === "get") return `Get a ${resource} record by identifier.`;
+  if (kind === "create") return `Create a ${resource} record from data payload.`;
+  if (kind === "update") return `Update a ${resource} record.`;
+  if (kind === "delete") return `Delete a ${resource} record by identifier.`;
+  return `Run ${tool.operationId} on ${resource}.`;
+}
+function shouldRewriteSummary(summary) {
+  const normalized = summary.trim();
+  if (!normalized) return true;
+  if (normalized.length > 96) return false;
+  if (/[():]/.test(normalized)) return false;
+  if (/\b(alias|wrapper|route|compose|markdown|safe delete)\b/i.test(normalized)) return false;
+  return /^(list|get|create|update|remove|delete|add|set|link|unlink|record|attach|end|start|search)\b/i.test(
+    normalized
+  );
+}
+function toCanonicalInvokeExamplePayload(operationKind, payload) {
+  if (isRecord$3(payload) && hasInputEnvelope(payload)) {
+    return payload;
+  }
+  if (operationKind === "get" && isRecord$3(payload)) {
+    const id = normalizePathParamValue(payload.id);
+    if (id) {
+      const { id: _ignored, ...rest } = payload;
+      return {
+        pathParams: { id },
+        ...Object.keys(rest).length > 0 ? { query: rest } : {}
+      };
+    }
+  }
+  const envelopeKey = operationKind === "list" || operationKind === "get" ? "query" : "body";
+  return { [envelopeKey]: payload };
+}
+function normalizeToolExample(example, operationKind) {
+  if (typeof example !== "string") return null;
+  const raw = example.trim();
+  if (!raw) return null;
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+  }
+  if (payload !== void 0) {
+    return JSON.stringify(toCanonicalInvokeExamplePayload(operationKind, payload));
+  }
+  const inputMatch = raw.match(/--input\\s+'([^']+)'/) ?? raw.match(/--input\\s+\"([^\"]+)\"/) ?? raw.match(/--input\\s+([^\\s]+)/);
+  if (!inputMatch || typeof inputMatch[1] !== "string") return null;
+  const candidate = inputMatch[1].trim();
+  if (!candidate) return null;
+  try {
+    payload = JSON.parse(candidate);
+    return JSON.stringify(toCanonicalInvokeExamplePayload(operationKind, payload));
+  } catch {
+    return null;
+  }
+}
+function normalizeToolExamples(examples, operationKind) {
+  if (!Array.isArray(examples)) return void 0;
+  const normalized = examples.map((entry) => normalizeToolExample(entry, operationKind)).filter((entry) => Boolean(entry));
+  return normalized.length > 0 ? normalized : void 0;
+}
+function normalizeToolIdShape(tool) {
+  const normalizedToolId = normalizeToolId(tool.toolId);
+  const domain = normalizeDomain(tool.domain);
+  if (!domain) return normalizedToolId;
+  const duplicatedDomainPrefix = `${domain}.${domain}.`;
+  if (normalizedToolId.startsWith(duplicatedDomainPrefix)) {
+    return `${domain}.${normalizedToolId.slice(duplicatedDomainPrefix.length)}`;
+  }
+  return normalizedToolId;
+}
+function normalizeCatalogTool(tool) {
+  const operationKind = resolveOperationKind(tool);
+  const fallbackExamplesByToolId = {
+    "jsonexcel.json.to-excel": ['{"jsonFile":"data.json","outputFile":"data.xlsx"}'],
+    "jsonexcel.excel.to-json": ['{"excelFile":"data.xlsx","outputFile":"data.json"}']
+  };
+  const normalizedToolId = normalizeToolIdShape(tool);
+  const examples = normalizeToolExamples(tool.examples, operationKind) ?? normalizeToolExamples(fallbackExamplesByToolId[normalizedToolId], operationKind);
+  const summaryCandidate = typeof tool.summary === "string" ? tool.summary : "";
+  const summary = shouldRewriteSummary(summaryCandidate) ? buildToolSummary(tool) : summaryCandidate;
+  const titleCandidate = typeof tool.title === "string" ? tool.title : "";
+  const title = shouldRewriteSummary(titleCandidate) ? summary : titleCandidate;
+  return {
+    ...tool,
+    toolId: normalizedToolId,
+    ...title ? { title } : {},
+    ...summary ? { summary } : {},
+    ...examples ? { examples } : {}
+  };
+}
+function normalizePathParams(input) {
+  if (!isRecord$3(input)) return {};
+  const out = {};
+  for (const [keyRaw, value] of Object.entries(input)) {
+    const key = keyRaw.trim();
+    if (!key) continue;
+    if (value === void 0 || value === null) continue;
+    out[key] = String(value);
+  }
+  return out;
+}
+function appendQueryParamValue(params, key, value) {
+  if (value === void 0 || value === null) return;
+  if (Array.isArray(value)) {
+    for (const item of value) appendQueryParamValue(params, key, item);
+    return;
+  }
+  if (typeof value === "object") {
+    params.append(key, JSON.stringify(value));
+    return;
+  }
+  params.append(key, String(value));
+}
+function normalizeQueryParams(input) {
+  if (!isRecord$3(input)) return new URLSearchParams();
+  const params = new URLSearchParams();
+  for (const [keyRaw, value] of Object.entries(input)) {
+    const key = keyRaw.trim();
+    if (!key) continue;
+    appendQueryParamValue(params, key, value);
+  }
+  return params;
+}
+function hasInputEnvelope(input) {
+  return Object.prototype.hasOwnProperty.call(input, "pathParams") || Object.prototype.hasOwnProperty.call(input, "params") || Object.prototype.hasOwnProperty.call(input, "query") || Object.prototype.hasOwnProperty.call(input, "body") || Object.prototype.hasOwnProperty.call(input, "context");
+}
+function parseRouteInvokeInput(input) {
+  if (!isRecord$3(input) || !hasInputEnvelope(input)) {
+    return {
+      pathParams: {},
+      query: new URLSearchParams(),
+      body: input,
+      context: {}
+    };
+  }
+  return {
+    pathParams: normalizePathParams(input.pathParams ?? input.params),
+    query: normalizeQueryParams(input.query),
+    body: input.body,
+    context: isRecord$3(input.context) ? input.context : {}
+  };
+}
+function extractPathParamKeys(pattern) {
+  const normalized = pattern.trim().replace(/^\/+|\/+$/g, "");
+  if (!normalized) return [];
+  return normalized.split("/").map((segment) => segment.trim()).filter((segment) => segment.startsWith(":")).map((segment) => segment.slice(1).trim()).filter(Boolean);
+}
+function normalizePathParamValue(value) {
+  if (value === void 0 || value === null) return void 0;
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function findManifestForDomain$1(manifests, domain) {
+  return manifests.find((manifest) => normalizeDomain(manifest.domain.id) === normalizeDomain(domain)) ?? null;
+}
+function normalizeAliasedArgName(value) {
+  const normalized = value.trim();
+  if (!normalized) return normalized;
+  const parts = normalized.split(".").map((part) => part.trim()).filter(Boolean);
+  return parts[parts.length - 1] ?? normalized;
+}
+function extractRouteParamAliases(tool, manifests) {
+  const manifest = findManifestForDomain$1(manifests, tool.domain);
+  const notes = manifest?.docs?.operations?.[tool.operationId]?.notes;
+  if (!Array.isArray(notes) || notes.length === 0) return /* @__PURE__ */ new Map();
+  const aliases = /* @__PURE__ */ new Map();
+  for (const rawNote of notes) {
+    const note = String(rawNote ?? "").trim();
+    if (!note) continue;
+    const match = note.match(/resolves\s+([a-zA-Z0-9_.]+)\s+from\s+:([a-zA-Z0-9_]+)/i);
+    if (!match) continue;
+    const targetArg = normalizeAliasedArgName(match[1] ?? "");
+    const pathKey = String(match[2] ?? "").trim();
+    if (!targetArg || !pathKey) continue;
+    aliases.set(targetArg, pathKey);
+  }
+  return aliases;
+}
+function normalizeInvokeInputForRoute(params) {
+  const pathParamKeys = extractPathParamKeys(params.routePattern);
+  const routeMethod = String(params.routeMethod ?? "").trim().toUpperCase();
+  const shouldMoveBodyToQuery = routeMethod === "GET" || routeMethod === "HEAD";
+  if (pathParamKeys.length === 0) {
+    if (!shouldMoveBodyToQuery || !isRecord$3(params.parsedInput.body)) return params.parsedInput;
+    const query2 = new URLSearchParams(params.parsedInput.query);
+    for (const [keyRaw, value] of Object.entries(params.parsedInput.body)) {
+      const key = keyRaw.trim();
+      if (!key) continue;
+      appendQueryParamValue(query2, key, value);
+    }
+    return {
+      ...params.parsedInput,
+      query: query2,
+      body: void 0
+    };
+  }
+  const pathParams = { ...params.parsedInput.pathParams };
+  const body = isRecord$3(params.parsedInput.body) ? { ...params.parsedInput.body } : params.parsedInput.body;
+  const bodyRecord = isRecord$3(body) ? body : null;
+  for (const pathKey of pathParamKeys) {
+    if (normalizePathParamValue(pathParams[pathKey])) continue;
+    const fallbackValue = bodyRecord ? normalizePathParamValue(bodyRecord[pathKey]) : void 0;
+    if (fallbackValue) {
+      pathParams[pathKey] = fallbackValue;
+    }
+  }
+  const aliases = extractRouteParamAliases(params.tool, params.manifests);
+  if (bodyRecord) {
+    for (const [targetArg, pathKey] of aliases.entries()) {
+      if (!normalizePathParamValue(pathParams[pathKey])) {
+        const targetValue = normalizePathParamValue(bodyRecord[targetArg]);
+        if (targetValue) {
+          pathParams[pathKey] = targetValue;
+        }
+      }
+      const resolvedPathValue = normalizePathParamValue(pathParams[pathKey]);
+      if (!resolvedPathValue) continue;
+      if (!normalizePathParamValue(bodyRecord[targetArg])) {
+        bodyRecord[targetArg] = resolvedPathValue;
+      }
+      if (targetArg !== pathKey && Object.prototype.hasOwnProperty.call(bodyRecord, pathKey)) {
+        delete bodyRecord[pathKey];
+      }
+    }
+  }
+  const normalizedInput = {
+    ...params.parsedInput,
+    pathParams,
+    body
+  };
+  if (!shouldMoveBodyToQuery || !isRecord$3(body)) {
+    return normalizedInput;
+  }
+  const query = new URLSearchParams(normalizedInput.query);
+  for (const [keyRaw, value] of Object.entries(body)) {
+    const key = keyRaw.trim();
+    if (!key || pathParamKeys.includes(key)) continue;
+    appendQueryParamValue(query, key, value);
+  }
+  return {
+    ...normalizedInput,
+    query,
+    body: void 0
+  };
+}
+function patternToPathSegments(pattern, pathParams) {
+  const normalized = pattern.trim().replace(/^\/+|\/+$/g, "");
+  if (!normalized) return [];
+  const parts = [];
+  for (const segment of normalized.split("/").map((raw) => raw.trim()).filter(Boolean)) {
+    if (segment === "*") {
+      const splat = pathParams.splat?.trim();
+      if (!splat) continue;
+      for (const part of splat.split("/").map((raw) => raw.trim()).filter(Boolean)) {
+        parts.push(encodeURIComponent(part));
+      }
+      continue;
+    }
+    if (segment.startsWith(":")) {
+      const key = segment.slice(1).trim();
+      const value = pathParams[key];
+      if (!key || value === void 0 || value.trim().length === 0) {
+        throw new Error(`tool_input_missing_path_param:${key || "<empty>"}`);
+      }
+      parts.push(encodeURIComponent(value.trim()));
+      continue;
+    }
+    parts.push(segment);
+  }
+  return parts;
+}
+function normalizeRouteSummaryEntry(raw) {
+  if (!isRecord$3(raw)) return null;
+  const id = String(raw.id ?? "").trim();
+  const method = String(raw.method ?? "").trim().toUpperCase();
+  const pattern = String(raw.pattern ?? "").trim();
+  const operation = String(raw.operation ?? "").trim();
+  if (!id || !method || !pattern || !operation) return null;
+  const summary = typeof raw.summary === "string" ? raw.summary.trim() : void 0;
+  return {
+    id,
+    method,
+    pattern,
+    operation,
+    summary: summary && summary.length > 0 ? summary : void 0
+  };
+}
+function resolveHeaderBindingValue(binding) {
+  let resolved;
+  if (typeof binding.value === "string") {
+    resolved = binding.value;
+  } else if (typeof binding.fromEnv === "string" && binding.fromEnv.length > 0) {
+    resolved = process.env[binding.fromEnv];
+  }
+  if ((!resolved || resolved.length === 0) && typeof binding.default === "string") {
+    resolved = binding.default;
+  }
+  if ((!resolved || resolved.length === 0) && binding.required) {
+    throw new Error(`agent_gateway_header_missing:${binding.fromEnv || "<binding>"}`);
+  }
+  if (!resolved || resolved.length === 0) return null;
+  return resolved;
+}
+function resolveSourceHeaders(source) {
+  const out = {};
+  for (const [nameRaw, binding] of Object.entries(source.headers ?? {})) {
+    const name = nameRaw.trim();
+    if (!name) continue;
+    const value = resolveHeaderBindingValue(binding);
+    if (!value) continue;
+    out[name] = value;
+  }
+  return out;
+}
+async function parseFetchBody(response) {
+  const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function createTimeoutController(timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  return {
+    controller,
+    cleanup: () => clearTimeout(timer)
+  };
+}
+function pickResponseHeaders(response) {
+  const out = {};
+  for (const [key, value] of response.headers.entries()) {
+    const normalized = key.trim().toLowerCase();
+    if (!normalized || normalized === "set-cookie") continue;
+    out[normalized] = value;
+  }
+  return out;
+}
+function toFederatedSourceFromRemote(source) {
+  return {
+    id: source.id,
+    kind: source.kind,
+    domain: source.domain,
+    enabled: source.enabled,
+    priority: source.priority,
+    baseUrl: source.baseUrl,
+    apiBasePath: source.apiBasePath
+  };
+}
+function findDomainRouteByOperation(routes, operationId) {
+  return routes.find((route) => route.operation === operationId) ?? null;
+}
+function findRemoteRouteByOperation(routes, operationId) {
+  return routes.find((route) => route.operation === operationId) ?? null;
+}
+function chooseSourceForInvocation(tool, sourceId) {
+  if (tool.sources.length === 0) {
+    throw new Error(`tool_source_unavailable:${tool.toolId}`);
+  }
+  if (sourceId) {
+    const explicit = tool.sources.find((source) => source.id === sourceId);
+    if (!explicit) {
+      throw new Error(`tool_source_not_found:${sourceId}`);
+    }
+    return explicit;
+  }
+  if (tool.defaultSourceId) {
+    const preferred = tool.sources.find((source) => source.id === tool.defaultSourceId);
+    if (preferred) return preferred;
+  }
+  return tool.sources[0];
+}
+function shouldFallbackFromLocalError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "unknown_error");
+  return message.startsWith("domain_not_registered:") || message.startsWith("operation_route_not_found:");
+}
+function findFirstRemoteSource(tool) {
+  return tool.sources.find((source) => source.kind !== "local-route") ?? null;
+}
+const runtimeImport = new Function("specifier", "return import(specifier)");
+const nodeRequire = createRequire(import.meta.url);
+promisify(execFile);
+let manifestImportVersion = 0;
+function withImportVersion(specifier) {
+  if (!specifier.startsWith("file://")) return specifier;
+  const url = new URL(specifier);
+  url.searchParams.set("v", String(manifestImportVersion));
+  return url.href;
+}
+function resolveManifestModuleSpecifier(moduleName, configPath) {
+  const trimmed = moduleName.trim();
+  if (!trimmed) return trimmed;
+  if (trimmed.startsWith("file://")) return trimmed;
+  if (trimmed.startsWith(".")) {
+    const baseDir = configPath ? path.dirname(configPath) : process.cwd();
+    return pathToFileURL(path.resolve(baseDir, trimmed)).href;
+  }
+  if (path.isAbsolute(trimmed)) {
+    return pathToFileURL(trimmed).href;
+  }
+  const resolvePaths = [process.cwd(), path.resolve(process.cwd(), "apps/aops-server")];
+  try {
+    const resolved = nodeRequire.resolve(trimmed, { paths: resolvePaths });
+    return pathToFileURL(resolved).href;
+  } catch {
+    return trimmed;
+  }
+}
+function toManifestErrorCode(provider, error) {
+  const message = error instanceof Error ? error.message : String(error ?? "unknown_error");
+  return {
+    sourceId: `manifest:${provider.id}`,
+    error: message
+  };
+}
+async function loadManifestFromProvider(provider, configPath) {
+  const specifier = resolveManifestModuleSpecifier(provider.module, configPath);
+  const manifestRaw = await loadManifestFromCurrentProcess(specifier, provider);
+  const validation = validateManifest(manifestRaw);
+  if (!validation.ok) {
+    const firstSemantic = validation.issues[0]?.message;
+    const firstSchema = validation.zodIssues?.[0]?.message;
+    throw new Error(`manifest_validation_failed:${provider.id}:${firstSemantic ?? firstSchema ?? "invalid_manifest"}`);
+  }
+  if (normalizeDomain(validation.manifest.domain.id) !== normalizeDomain(provider.domain)) {
+    throw new Error(`manifest_domain_mismatch:${provider.id}:${validation.manifest.domain.id}:${provider.domain}`);
+  }
+  return validation.manifest;
+}
+async function loadManifestFromCurrentProcess(specifier, provider) {
+  const mod = await runtimeImport(withImportVersion(specifier));
+  const exportCandidate = mod[provider.exportName] ?? (provider.exportName === "default" ? mod.default : void 0);
+  if (exportCandidate === void 0) {
+    throw new Error(`manifest_export_not_found:${provider.id}:${provider.exportName}`);
+  }
+  return typeof exportCandidate === "function" ? await Promise.resolve(
+    exportCandidate(provider.options)
+  ) : exportCandidate;
+}
+async function fetchRemoteRoutes(source) {
+  const baseUrl = normalizeBaseUrl(source.baseUrl);
+  const apiBasePath = normalizeApiBasePath(source.apiBasePath);
+  const url = `${baseUrl}${apiBasePath}/${source.domain}`;
+  const headers = resolveSourceHeaders(source);
+  const { controller, cleanup } = createTimeoutController(source.timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: controller.signal
+    });
+    const body = await parseFetchBody(response);
+    if (!response.ok) {
+      throw new Error(`remote_route_fetch_failed:${response.status}:${url}`);
+    }
+    if (!isRecord$3(body) || !Array.isArray(body.routes)) {
+      throw new Error(`remote_route_payload_invalid:${url}`);
+    }
+    return body.routes.map((route) => normalizeRouteSummaryEntry(route)).filter((route) => route !== null);
+  } finally {
+    cleanup();
+  }
+}
+async function buildGatewayCatalogSnapshot(params) {
+  const { config } = params;
+  const errors = [];
+  const manifests = [];
+  const domains = /* @__PURE__ */ new Set();
+  if (config.catalog.enabled) {
+    for (const provider of config.catalog.manifestProviders) {
+      if (!provider.enabled) continue;
+      try {
+        const manifest = await loadManifestFromProvider(provider, params.configPath);
+        manifests.push(manifest);
+        domains.add(normalizeDomain(manifest.domain.id));
+      } catch (error) {
+        errors.push(toManifestErrorCode(provider, error));
+      }
+    }
+  }
+  for (const source of config.sources) {
+    if (!source.enabled) continue;
+    domains.add(normalizeDomain(source.domain));
+  }
+  const sources = config.sources.filter((source) => source.enabled).map((source) => toFederatedSourceFromRemote(source));
+  if (config.includeLocal) {
+    for (const domain of domains) {
+      sources.push({
+        id: "local",
+        kind: "local-route",
+        domain,
+        enabled: true,
+        priority: 0
+      });
+    }
+  }
+  const catalog = buildFederatedToolCatalog({
+    manifests,
+    sources
+  });
+  const normalizedCatalog = {
+    ...catalog,
+    tools: catalog.tools.map((tool) => normalizeCatalogTool(tool))
+  };
+  const toolsById = /* @__PURE__ */ new Map();
+  for (const tool of normalizedCatalog.tools) {
+    toolsById.set(normalizeToolId(tool.toolId), tool);
+  }
+  return {
+    catalog: normalizedCatalog,
+    manifests,
+    errors,
+    toolsById,
+    loadedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+const INVOKE_REQUEST_DESCRIPTION = "Send either the raw tool input JSON directly, or use the canonical envelope { sourceId?, input, preview?, apply?, confirm?, idempotencyKey? }. Use preview for preflight, apply for guarded writes, confirm for destructive writes, and idempotencyKey for best-effort guarded-write deduplication.";
+function isRecord$2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isEnvelopeOnlyInvokeSchema(schema) {
+  if (!isRecord$2(schema)) return false;
+  if (Array.isArray(schema.oneOf)) return false;
+  if (schema.type !== "object") return false;
+  const properties = isRecord$2(schema.properties) ? schema.properties : null;
+  if (!properties || !Object.prototype.hasOwnProperty.call(properties, "input")) return false;
+  const required = Array.isArray(schema.required) ? schema.required.filter((value) => typeof value === "string") : [];
+  return required.includes("input");
+}
+function normalizeInvokeSchema(schema) {
+  if (!isEnvelopeOnlyInvokeSchema(schema)) return schema;
+  const properties = isRecord$2(schema.properties) ? schema.properties : {};
+  const rawInputSchema = properties.input ?? { type: "object", additionalProperties: true };
+  const envelopeSchema = {
+    ...schema,
+    properties: {
+      ...properties,
+      ...Object.prototype.hasOwnProperty.call(properties, "preview") ? {} : { preview: { type: "boolean" } },
+      ...Object.prototype.hasOwnProperty.call(properties, "apply") ? {} : { apply: { type: "boolean" } },
+      ...Object.prototype.hasOwnProperty.call(properties, "confirm") ? {} : { confirm: { type: "boolean" } },
+      ...Object.prototype.hasOwnProperty.call(properties, "idempotencyKey") ? {} : { idempotencyKey: { type: "string" } }
+    }
+  };
+  return {
+    description: typeof schema.description === "string" && schema.description.trim().length > 0 ? schema.description : INVOKE_REQUEST_DESCRIPTION,
+    oneOf: [rawInputSchema, envelopeSchema]
+  };
+}
+function normalizeAgentGatewayOpenApiDocument(document) {
+  const paths = isRecord$2(document.paths) ? document.paths : null;
+  if (!paths) return document;
+  let changed = false;
+  const normalizedPaths = {};
+  for (const [pathKey, pathValue] of Object.entries(paths)) {
+    if (!isRecord$2(pathValue) || !isRecord$2(pathValue.post)) {
+      normalizedPaths[pathKey] = pathValue;
+      continue;
+    }
+    const post = pathValue.post;
+    const requestBody = isRecord$2(post.requestBody) ? post.requestBody : null;
+    const content = requestBody && isRecord$2(requestBody.content) ? requestBody.content : null;
+    const jsonContent = content && isRecord$2(content["application/json"]) ? content["application/json"] : null;
+    const schema = jsonContent?.schema;
+    const nextSchema = normalizeInvokeSchema(schema);
+    if (nextSchema === schema) {
+      normalizedPaths[pathKey] = pathValue;
+      continue;
+    }
+    changed = true;
+    normalizedPaths[pathKey] = {
+      ...pathValue,
+      post: {
+        ...post,
+        requestBody: {
+          ...requestBody,
+          content: {
+            ...content,
+            "application/json": {
+              ...jsonContent,
+              schema: nextSchema
+            }
+          }
+        }
+      }
+    };
+  }
+  if (!changed) return document;
+  return {
+    ...document,
+    paths: normalizedPaths
+  };
+}
+const AGENT_INVOKE_AUDIT_POLICY = {
+  enabled: true,
+  sink: "structured-server-log",
+  persistence: "best-effort",
+  events: ["preview", "blocked", "success", "failure", "replayed"],
+  approvalMode: "explicit-confirm-flag"
+};
+const GUARDED_WRITE_IDEMPOTENCY_MODE = "best-effort-host-cache";
+const IDEMPOTENCY_ENTRY_TTL_MS = 10 * 60 * 1e3;
+const idempotencyStore = /* @__PURE__ */ new Map();
+let loggerPromise = null;
+function normalizeText$1(value) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : "";
+}
+function normalizeRoles(value) {
+  if (!Array.isArray(value)) return void 0;
+  const roles = value.map((entry) => normalizeText$1(entry)).filter(Boolean);
+  return roles.length > 0 ? roles : void 0;
+}
+function isRecord$1(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function cloneHeaders(headers) {
+  if (!headers) return void 0;
+  return { ...headers };
+}
+function cloneResult(result) {
+  return {
+    tool: { ...result.tool },
+    status: result.status,
+    data: result.data,
+    headers: cloneHeaders(result.headers)
+  };
+}
+function attachHeaders(result, headers) {
+  return {
+    ...cloneResult(result),
+    headers: {
+      ...result.headers ?? {},
+      ...headers
+    }
+  };
+}
+function toCanonicalValue(value) {
+  if (Array.isArray(value)) return value.map((entry) => toCanonicalValue(entry));
+  if (!isRecord$1(value)) return value;
+  const output = {};
+  for (const key of Object.keys(value).sort((left, right) => left.localeCompare(right))) {
+    const nextValue = toCanonicalValue(value[key]);
+    if (nextValue === void 0) continue;
+    output[key] = nextValue;
+  }
+  return output;
+}
+function stableStringify(value) {
+  return JSON.stringify(toCanonicalValue(value));
+}
+function isGuardedWriteTool(tool) {
+  const policy = isRecord$1(tool.policy) ? tool.policy : null;
+  const safety = policy && isRecord$1(policy.safety) ? policy.safety : null;
+  return safety?.applyRequired === true || safety?.destructive === true || safety?.confirmationRequired === true;
+}
+function buildApprovalMode(tool) {
+  const policy = isRecord$1(tool.policy) ? tool.policy : null;
+  const safety = policy && isRecord$1(policy.safety) ? policy.safety : null;
+  return safety?.confirmationRequired === true ? "explicit-confirm-flag" : "none";
+}
+function buildInvokeFingerprint(selection) {
+  const fingerprintInput = {
+    toolId: selection.tool.toolId,
+    requestedSourceId: selection.source.id,
+    input: selection.args.input ?? null,
+    context: {
+      tenantId: normalizeText$1(selection.args.context?.tenantId) || null,
+      scopeId: normalizeText$1(selection.args.context?.scopeId) || normalizeText$1(selection.args.context?.projectId) || null,
+      locale: normalizeText$1(selection.args.context?.locale) || null,
+      fallbackLocale: normalizeText$1(selection.args.context?.fallbackLocale) || null
+    },
+    apply: selection.args.apply === true,
+    confirm: selection.args.confirm === true
+  };
+  return createHash("sha256").update(stableStringify(fingerprintInput)).digest("hex");
+}
+function buildRecommendedInvokeIdempotencyKey(selection) {
+  const digest = buildInvokeFingerprint(selection).slice(0, 16);
+  return `${selection.tool.toolId}:${digest}`;
+}
+function buildStoreKey(selection, idempotencyKey) {
+  return [
+    selection.tool.toolId,
+    selection.source.id,
+    normalizeText$1(selection.args.context?.tenantId) || "tenant",
+    normalizeText$1(selection.args.context?.scopeId) || normalizeText$1(selection.args.context?.projectId) || "scope",
+    idempotencyKey
+  ].join("::");
+}
+function cleanupExpiredEntries(now = Date.now()) {
+  for (const [key, entry] of idempotencyStore.entries()) {
+    if (entry.expiresAt > now) continue;
+    idempotencyStore.delete(key);
+  }
+}
+function buildIdempotencyPayload(selection, args) {
+  return {
+    tool: {
+      ...selection.tool,
+      sourceId: selection.source.id,
+      sourceKind: selection.source.kind,
+      sourceBaseUrl: selection.source.baseUrl,
+      sourceApiBasePath: selection.source.apiBasePath
+    },
+    status: 409,
+    data: {
+      ok: false,
+      error: args.error,
+      toolId: selection.tool.toolId,
+      domain: selection.tool.domain,
+      operationId: selection.tool.operationId,
+      message: args.message,
+      idempotency: {
+        mode: GUARDED_WRITE_IDEMPOTENCY_MODE,
+        key: args.key,
+        recommendedKey: args.recommendedKey
+      }
+    },
+    headers: {
+      "x-agent-idempotency-status": args.error === "idempotency_in_progress" ? "in-progress" : "conflict",
+      "x-agent-idempotency-key": args.key
+    }
+  };
+}
+function isSuccessfulResult(result) {
+  if (result.status >= 400) return false;
+  if (!isRecord$1(result.data)) return true;
+  return result.data.ok !== false;
+}
+function buildInvokeGovernancePreview(selection, requirements, options = {}) {
+  const providedKey = normalizeText$1(selection.args.idempotencyKey);
+  const guarded = isGuardedWriteTool(selection.tool);
+  const overrideRecommendedKey = normalizeText$1(options.recommendedKey);
+  const recommendedKey = guarded ? overrideRecommendedKey || buildRecommendedInvokeIdempotencyKey(selection) : null;
+  const recommendedKeySource = guarded ? overrideRecommendedKey ? options.recommendedKeySource ?? "domain-natural-key" : "host-derived" : void 0;
+  const nextIdempotencyKey = providedKey || recommendedKey || void 0;
+  return {
+    audit: AGENT_INVOKE_AUDIT_POLICY,
+    approval: {
+      mode: buildApprovalMode(selection.tool),
+      required: requirements.confirmationRequired,
+      satisfied: requirements.confirmationSatisfied,
+      provided: selection.args.confirm === true
+    },
+    idempotency: {
+      supported: isGuardedWriteTool(selection.tool),
+      mode: isGuardedWriteTool(selection.tool) ? GUARDED_WRITE_IDEMPOTENCY_MODE : "not-applicable",
+      provided: Boolean(providedKey),
+      key: providedKey || null,
+      recommendedKey,
+      ...recommendedKeySource ? { recommendedKeySource } : {},
+      enforced: false
+    },
+    ...nextIdempotencyKey ? { nextIdempotencyKey } : {}
+  };
+}
+function reserveInvokeIdempotency(selection, options = {}) {
+  const guarded = isGuardedWriteTool(selection.tool);
+  const overrideRecommendedKey = normalizeText$1(options.recommendedKey);
+  const recommendedKey = guarded ? overrideRecommendedKey || buildRecommendedInvokeIdempotencyKey(selection) : "";
+  const key = normalizeText$1(selection.args.idempotencyKey) || normalizeText$1(options.effectiveKey);
+  if (!guarded || selection.args.preview === true || !key) {
+    return {
+      kind: "skip",
+      ...recommendedKey ? { recommendedKey } : {}
+    };
+  }
+  cleanupExpiredEntries();
+  const storeKey = buildStoreKey(selection, key);
+  const fingerprint = buildInvokeFingerprint(selection);
+  const existing = idempotencyStore.get(storeKey);
+  if (existing) {
+    if (existing.fingerprint !== fingerprint) {
+      return {
+        kind: "resolved",
+        result: buildIdempotencyPayload(selection, {
+          error: "idempotency_key_conflict",
+          key,
+          recommendedKey,
+          message: `idempotency_key_conflict:${selection.tool.toolId}`
+        }),
+        idempotencyStatus: "conflict",
+        recommendedKey
+      };
+    }
+    if (existing.state === "pending") {
+      return {
+        kind: "resolved",
+        result: buildIdempotencyPayload(selection, {
+          error: "idempotency_in_progress",
+          key,
+          recommendedKey,
+          message: `idempotency_in_progress:${selection.tool.toolId}`
+        }),
+        idempotencyStatus: "in-progress",
+        recommendedKey
+      };
+    }
+    if (existing.state === "completed" && existing.result) {
+      return {
+        kind: "resolved",
+        result: attachHeaders(cloneResult(existing.result), {
+          "x-agent-idempotency-status": "replayed",
+          "x-agent-idempotency-key": key
+        }),
+        idempotencyStatus: "replayed",
+        recommendedKey
+      };
+    }
+  }
+  idempotencyStore.set(storeKey, {
+    fingerprint,
+    expiresAt: Date.now() + IDEMPOTENCY_ENTRY_TTL_MS,
+    state: "pending"
+  });
+  return {
+    kind: "active",
+    key,
+    recommendedKey,
+    settle(result) {
+      if (isSuccessfulResult(result)) {
+        idempotencyStore.set(storeKey, {
+          fingerprint,
+          expiresAt: Date.now() + IDEMPOTENCY_ENTRY_TTL_MS,
+          state: "completed",
+          result: attachHeaders(cloneResult(result), {
+            "x-agent-idempotency-status": "fresh",
+            "x-agent-idempotency-key": key
+          })
+        });
+        return;
+      }
+      idempotencyStore.delete(storeKey);
+    },
+    release() {
+      idempotencyStore.delete(storeKey);
+    }
+  };
+}
+async function resolveAuditLogger() {
+  if (!loggerPromise) {
+    loggerPromise = getLogger({ level: "info", file: false, console: true }).catch(() => void 0);
+  }
+  return await loggerPromise;
+}
+function toFailureStatus(message) {
+  if (message === "unauthorized") return 401;
+  if (message === "forbidden") return 403;
+  if (message.startsWith("apply_required:") || message.startsWith("confirmation_required:") || message === "project_context_required" || message === "project_required" || message.startsWith("missing_required_arg:") || message.startsWith("unknown_input_arg:") || message.startsWith("tool_input_schema_invalid:") || message.startsWith("validation_failed:") || message.startsWith("idempotency_in_progress:") || message.startsWith("idempotency_key_conflict:")) {
+    return 409;
+  }
+  if (message.startsWith("tool_not_found:")) return 404;
+  return 500;
+}
+function buildInvokeFailureStatus(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "unknown_error");
+  return toFailureStatus(message);
+}
+async function writeAgentInvokeAuditEvent(event) {
+  const payload = {
+    owner: "agent-gateway",
+    action: event.preview === true ? "preview" : "invoke",
+    toolId: event.tool.toolId,
+    domain: event.tool.domain,
+    operationId: event.tool.operationId,
+    requestedSourceId: normalizeText$1(event.requestedSourceId),
+    effectiveSourceId: normalizeText$1(event.effectiveSourceId),
+    result: event.outcome,
+    status: event.status,
+    durationMs: typeof event.durationMs === "number" && Number.isFinite(event.durationMs) ? event.durationMs : void 0,
+    tenantId: normalizeText$1(event.context?.tenantId),
+    scopeId: normalizeText$1(event.context?.scopeId) || normalizeText$1(event.context?.projectId),
+    actorId: normalizeText$1(event.context?.principal && isRecord$1(event.context.principal) ? event.context.principal.id : void 0) || void 0,
+    roles: normalizeRoles(event.context?.principal && isRecord$1(event.context.principal) ? event.context.principal.roles : void 0),
+    preview: event.preview === true,
+    apply: event.apply === true,
+    confirm: event.confirm === true,
+    approvalMode: buildApprovalMode(event.tool),
+    idempotencyKey: normalizeText$1(event.idempotencyKey) || void 0,
+    idempotencyStatus: event.idempotencyStatus,
+    errorCode: normalizeText$1(event.errorCode) || void 0,
+    audit: AGENT_INVOKE_AUDIT_POLICY
+  };
+  const message = `[agent-invoke:audit] ${payload.toolId} ${payload.result}`;
+  try {
+    const logger = await resolveAuditLogger();
+    if (payload.result === "failure" || payload.result === "blocked") {
+      if (logger?.warn) {
+        await logger.warn(payload, message);
+        return;
+      }
+      console.warn(message, payload);
+      return;
+    }
+    if (logger?.info) {
+      await logger.info(payload, message);
+      return;
+    }
+    console.info(message, payload);
+  } catch {
+    if (payload.result === "failure" || payload.result === "blocked") {
+      console.warn(message, payload);
+      return;
+    }
+    console.info(message, payload);
+  }
+}
+function normalizeText(value) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : "";
+}
+function normalizePositiveInteger(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.trunc(value);
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return void 0;
+    const parsed = Number(trimmed);
+    if (Number.isFinite(parsed) && parsed > 0) return Math.trunc(parsed);
+  }
+  return void 0;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function readCollection(input, collectionKey) {
+  const payload = asRecord(input);
+  if (Array.isArray(payload[collectionKey])) return payload[collectionKey];
+  if (Array.isArray(payload.data)) return payload.data;
+  const data = asRecord(payload.data);
+  if (Array.isArray(data[collectionKey])) return data[collectionKey];
+  return [];
+}
+function buildBulkPushPreview(args) {
+  const payload = asRecord(args.input);
+  const preset = args.presetOptional === false ? "" : normalizeText(payload.preset);
+  const count = readCollection(payload, args.collectionKey).length;
+  if (!preset && count <= 0) return void 0;
+  return {
+    kind: "bulk-push",
+    summary: preset ? `Push ${args.targetLabel} from preset ${preset}.` : `Push ${count} ${args.targetLabel}.`,
+    change: {
+      action: "bulk-push",
+      basis: "payload-counts"
+    },
+    ...preset ? { sourceMode: "preset", preset } : { sourceMode: "inline-data" },
+    ...count > 0 ? { counts: { [args.collectionKey]: count } } : {}
+  };
+}
+function buildUnitPushPreview(input) {
+  const payload = asRecord(input);
+  const preset = normalizeText(payload.preset);
+  const data = asRecord(payload.data);
+  const unitTypes = asArray(payload.unitTypes).length > 0 ? asArray(payload.unitTypes) : asArray(data.unitTypes);
+  const units = asArray(payload.units).length > 0 ? asArray(payload.units) : asArray(data.units);
+  const subUnits = units.reduce(
+    (count, entry) => count + asArray(asRecord(entry).subUnits).length,
+    0
+  );
+  if (!preset && unitTypes.length <= 0 && units.length <= 0) return void 0;
+  return {
+    kind: "bulk-push",
+    summary: preset ? `Push inventory units from preset ${preset}.` : `Push ${units.length} units across ${unitTypes.length} unit types.`,
+    change: {
+      action: "bulk-push",
+      basis: "payload-counts"
+    },
+    ...preset ? { sourceMode: "preset", preset } : { sourceMode: "inline-data" },
+    counts: {
+      unitTypes: unitTypes.length,
+      units: units.length,
+      subUnits
+    }
+  };
+}
+function buildDeletePreview(input, key, label) {
+  const payload = asRecord(input);
+  const targetUid = normalizeText(payload[key]);
+  if (!targetUid) return void 0;
+  return {
+    kind: "delete-target",
+    summary: `Delete ${label} ${targetUid}.`,
+    change: {
+      action: "delete",
+      basis: "target-uid"
+    },
+    target: {
+      [key]: targetUid
+    }
+  };
+}
+function buildReceivingSourceRevisionKey(orderUid, revisionNumber) {
+  return `${orderUid}::r${String(revisionNumber)}`;
+}
+function buildReceivingImportPreview(input) {
+  const payload = asRecord(input);
+  const handoff = asRecord(payload.handoff ?? payload.data ?? payload.input ?? payload);
+  const orderUid = normalizeText(handoff.orderUid);
+  const revisionNumber = normalizePositiveInteger(handoff.revisionNumber);
+  if (!orderUid || !revisionNumber) return void 0;
+  const lineCount = normalizePositiveInteger(handoff.lineCount) ?? asArray(handoff.lines).length;
+  const sourceRevisionKey = buildReceivingSourceRevisionKey(orderUid, revisionNumber);
+  return {
+    kind: "handoff-import",
+    summary: `Import receiving handoff for purchase order ${orderUid} revision ${revisionNumber}.`,
+    change: {
+      action: "import",
+      basis: "source-revision"
+    },
+    target: {
+      orderUid,
+      revisionNumber,
+      ...lineCount > 0 ? { lineCount } : {}
+    },
+    ...lineCount > 0 ? { counts: { lines: lineCount } } : {},
+    idempotency: {
+      owner: "domain-natural-key",
+      recommendedKey: `inventory.receiving.import-purchase-order-handoff:${sourceRevisionKey}`,
+      scope: "orderUid+revisionNumber"
+    }
+  };
+}
+function buildBomSheetPreview(operationId, input) {
+  const payload = asRecord(input);
+  const rows = asArray(payload.rows);
+  const sheetName = normalizeText(payload.sheetName);
+  if (rows.length <= 0 && !sheetName) return void 0;
+  return {
+    kind: "sheet-import",
+    summary: operationId === "bom.import-sheet-preview" ? `Preview BOM sheet import for ${rows.length} rows.` : `Create BOM from sheet import with ${rows.length} rows.`,
+    change: {
+      action: "import",
+      basis: "sheet-rows"
+    },
+    ...sheetName ? { target: { sheetName } } : {},
+    counts: {
+      rows: rows.length
+    }
+  };
+}
+function buildInventorySemanticPreview(operationId, input) {
+  switch (operationId) {
+    case "category.push":
+      return buildBulkPushPreview({
+        collectionKey: "categories",
+        targetLabel: "inventory categories",
+        input
+      });
+    case "attribute-def.push":
+      return buildBulkPushPreview({
+        collectionKey: "attributeDefs",
+        targetLabel: "attribute definitions",
+        input
+      });
+    case "attribute-def.delete":
+      return buildDeletePreview(input, "attributeDefUid", "attribute definition");
+    case "category-attribute.push":
+      return buildBulkPushPreview({
+        collectionKey: "categoryAttributes",
+        targetLabel: "category attribute bindings",
+        input
+      });
+    case "manufacturer.push":
+      return buildBulkPushPreview({
+        collectionKey: "manufacturers",
+        targetLabel: "manufacturers",
+        input,
+        presetOptional: false
+      });
+    case "distributor.push":
+      return buildBulkPushPreview({
+        collectionKey: "distributors",
+        targetLabel: "distributors",
+        input,
+        presetOptional: false
+      });
+    case "supplier.push":
+      return buildBulkPushPreview({
+        collectionKey: "suppliers",
+        targetLabel: "suppliers",
+        input,
+        presetOptional: false
+      });
+    case "unit.push":
+      return buildUnitPushPreview(input);
+    case "unit.delete":
+      return buildDeletePreview(input, "unitUid", "inventory unit");
+    case "subunit.delete":
+      return buildDeletePreview(input, "subUnitUid", "inventory sub-unit");
+    case "receiving.import-purchase-order-handoff":
+      return buildReceivingImportPreview(input);
+    case "bom.import-sheet-preview":
+    case "bom.import-sheet-create":
+      return buildBomSheetPreview(operationId, input);
+    default:
+      return void 0;
+  }
+}
+function buildAgentSemanticPreview(args) {
+  if (normalizeText(args.domain).toLowerCase() !== "inventory") return void 0;
+  return buildInventorySemanticPreview(args.operationId, args.input);
+}
+function resolveAgentSemanticIdempotencyKey(args) {
+  return buildAgentSemanticPreview(args)?.idempotency?.recommendedKey;
+}
+const schemaCacheByDomain = /* @__PURE__ */ new Map();
+const TOOLING_CONTEXT_INPUT_KEYS = /* @__PURE__ */ new Set([
+  "projectId",
+  "scopeId",
+  "tenantId",
+  "locale",
+  "fallbackLocale"
+]);
+function parseMaybeJson(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return value;
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (!Number.isNaN(Number(trimmed)) && trimmed !== "") return Number(trimmed);
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function toQueryObject(query) {
+  const out = {};
+  for (const [key, value] of query.entries()) {
+    out[key] = parseMaybeJson(value);
+  }
+  return out;
+}
+function toValidationPayload(parsedInput, tool, manifests = []) {
+  const queryPayload = toQueryObject(parsedInput.query);
+  const pathPayload = { ...parsedInput.pathParams };
+  if (tool) {
+    const aliases = extractRouteParamAliases(tool, manifests);
+    for (const [targetArg, pathKey] of aliases.entries()) {
+      const pathValue = pathPayload[pathKey];
+      if (pathValue === void 0) continue;
+      if (pathPayload[targetArg] === void 0) {
+        pathPayload[targetArg] = pathValue;
+      }
+      if (targetArg !== pathKey) {
+        delete pathPayload[pathKey];
+      }
+    }
+  }
+  if (isRecord$3(parsedInput.body)) {
+    return {
+      ...queryPayload,
+      ...parsedInput.body,
+      ...pathPayload
+    };
+  }
+  const hasQueryOrPath = Object.keys(queryPayload).length > 0 || Object.keys(pathPayload).length > 0;
+  if (!hasQueryOrPath) {
+    return parsedInput.body === void 0 || parsedInput.body === null ? {} : parsedInput.body;
+  }
+  if (parsedInput.body === void 0 || parsedInput.body === null) {
+    return { ...queryPayload, ...pathPayload };
+  }
+  return {
+    ...queryPayload,
+    ...pathPayload,
+    body: parsedInput.body
+  };
+}
+function normalizeArgName(value) {
+  return String(value ?? "").trim();
+}
+function normalizeContractArgName(value) {
+  return normalizeArgName(value);
+}
+function parseArgsFromOperationNotes(notes, marker) {
+  if (!Array.isArray(notes)) return [];
+  const normalizedMarker = marker.toLowerCase();
+  const out = [];
+  for (const rawNote of notes) {
+    const note = String(rawNote ?? "").trim();
+    if (!note) continue;
+    const lowered = note.toLowerCase();
+    if (!lowered.startsWith(normalizedMarker)) continue;
+    const rawArgs = note.slice(normalizedMarker.length).trim();
+    if (!rawArgs) continue;
+    for (const argRaw of rawArgs.split(",")) {
+      const normalized = normalizeContractArgName(argRaw);
+      if (!normalized) continue;
+      out.push(normalized);
+    }
+  }
+  return [...new Set(out)];
+}
+function toSchemaArgContract(schema) {
+  if (!isRecord$3(schema)) return null;
+  if (schema.type !== "object") return null;
+  const properties = isRecord$3(schema.properties) ? schema.properties : {};
+  const propertyNames = Object.keys(properties).map((name) => normalizeContractArgName(name)).filter(Boolean);
+  const requiredArgs = Array.isArray(schema.required) ? [...new Set(schema.required.map((value) => normalizeContractArgName(value)).filter(Boolean))] : [];
+  const optionalArgs = propertyNames.filter((name) => !requiredArgs.includes(name));
+  const disallowUnknownArgs = schema.additionalProperties === false;
+  if (propertyNames.length === 0 && requiredArgs.length === 0) return null;
+  return {
+    requiredArgs,
+    optionalArgs,
+    disallowUnknownArgs
+  };
+}
+function resolveOperationInputSchema(manifest, tool) {
+  const schemaRef = normalizeArgName(tool.inputSchemaRef);
+  if (!schemaRef) return null;
+  const schemas = isRecord$3(manifest.contracts?.schemas) ? manifest.contracts.schemas : {};
+  if (!isRecord$3(schemas)) return null;
+  return schemas[schemaRef] ?? null;
+}
+function resolveToolArgContract(tool, manifests) {
+  const manifest = findManifestForDomain(manifests, tool.domain);
+  if (!manifest) return null;
+  const notes = manifest.docs?.operations?.[tool.operationId]?.notes;
+  const notesRequiredArgs = parseArgsFromOperationNotes(notes, "required args:");
+  const notesOptionalArgs = parseArgsFromOperationNotes(notes, "optional args:");
+  const schemaContract = toSchemaArgContract(resolveOperationInputSchema(manifest, tool));
+  const requiredArgs = /* @__PURE__ */ new Set([...notesRequiredArgs, ...schemaContract?.requiredArgs ?? []]);
+  const optionalArgs = /* @__PURE__ */ new Set([...notesOptionalArgs, ...schemaContract?.optionalArgs ?? []]);
+  for (const required2 of requiredArgs) optionalArgs.delete(required2);
+  const required = [...requiredArgs];
+  const optional = [...optionalArgs];
+  const disallowUnknownArgs = notesRequiredArgs.length > 0 || notesOptionalArgs.length > 0 || Boolean(schemaContract?.disallowUnknownArgs);
+  if (required.length === 0 && optional.length === 0 && !disallowUnknownArgs) {
+    return null;
+  }
+  return {
+    requiredArgs: required,
+    optionalArgs: optional,
+    disallowUnknownArgs
+  };
+}
+function hasNonEmptyValue(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function hasRequiredArg(payload, context, argName) {
+  if (argName === "scopeId") {
+    return hasNonEmptyValue(payload.scopeId) || hasProjectAliasValue(payload, context?.projectId) || hasNonEmptyValue(context?.scopeId);
+  }
+  if (argName === "projectId") {
+    return hasProjectAliasValue(payload, context?.projectId);
+  }
+  return hasNonEmptyValue(payload[argName]);
+}
+function toContractValidationPayload(parsedInput, tool, manifests, context) {
+  const payload = toValidationPayload(parsedInput, tool, manifests);
+  if (!isRecord$3(payload)) return null;
+  const merged = { ...payload };
+  if (!hasNonEmptyValue(merged.projectId) && hasNonEmptyValue(context?.projectId)) {
+    merged.projectId = String(context?.projectId);
+  }
+  if (!hasNonEmptyValue(merged.scopeId)) {
+    const resolvedScopeId = context?.scopeId ?? context?.projectId;
+    if (hasNonEmptyValue(resolvedScopeId)) {
+      merged.scopeId = String(resolvedScopeId);
+    }
+  }
+  if (!hasNonEmptyValue(merged.tenantId) && hasNonEmptyValue(context?.tenantId)) {
+    merged.tenantId = String(context?.tenantId);
+  }
+  if (!hasNonEmptyValue(merged.locale) && hasNonEmptyValue(context?.locale)) {
+    merged.locale = String(context?.locale);
+  }
+  if (!hasNonEmptyValue(merged.fallbackLocale) && hasNonEmptyValue(context?.fallbackLocale)) {
+    merged.fallbackLocale = String(context?.fallbackLocale);
+  }
+  return merged;
+}
+function toContractValidationSchema(contract, operationId, context) {
+  const shape = {};
+  for (const argName of contract.requiredArgs) shape[argName] = z.unknown().optional();
+  for (const argName of contract.optionalArgs) shape[argName] = z.unknown().optional();
+  for (const contextKey of TOOLING_CONTEXT_INPUT_KEYS) shape[contextKey] = z.unknown().optional();
+  const base = contract.disallowUnknownArgs ? z.object(shape).strict() : z.object(shape).passthrough();
+  return base.superRefine((payload, refineContext) => {
+    for (const requiredArg of contract.requiredArgs) {
+      if (hasRequiredArg(payload, context, requiredArg)) continue;
+      refineContext.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `missing_required_arg:${requiredArg};operation:${operationId}`,
+        path: [requiredArg]
+      });
+    }
+  });
+}
+function formatContractValidationError(tool, error) {
+  const firstIssue = error.issues[0];
+  if (!firstIssue) return `validation_failed:${tool.operationId}`;
+  if (firstIssue.message.startsWith("missing_required_arg:")) return firstIssue.message;
+  if (firstIssue.code === "unrecognized_keys") {
+    const unknownArg = Array.isArray(firstIssue.keys) && firstIssue.keys ? firstIssue.keys?.[0] : void 0;
+    if (unknownArg) {
+      return `unknown_input_arg:${unknownArg};operation:${tool.operationId}`;
+    }
+  }
+  return `validation_failed:${tool.operationId}`;
+}
+function resolveToolPolicyRecord(tool) {
+  return isRecord$3(tool.policy) ? tool.policy : null;
+}
+function resolveToolPolicySafety(tool) {
+  const policy = resolveToolPolicyRecord(tool);
+  return policy && isRecord$3(policy.safety) ? policy.safety : {};
+}
+function resolveToolPolicyContext(tool) {
+  const policy = resolveToolPolicyRecord(tool);
+  return policy && isRecord$3(policy.context) ? policy.context : {};
+}
+function resolveToolPolicyAuth(tool) {
+  const policy = resolveToolPolicyRecord(tool);
+  return policy && isRecord$3(policy.auth) ? policy.auth : {};
+}
+function toNormalizedStringList(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.map((entry) => normalizeArgName(entry).toLowerCase()).filter(Boolean))];
+}
+function resolvePrincipalRecord(context) {
+  return context?.principal && isRecord$3(context.principal) ? context.principal : null;
+}
+function hasAuthenticatedPrincipal(context) {
+  const principal = resolvePrincipalRecord(context);
+  if (!principal) return false;
+  const principalId = normalizeArgName(principal.id ?? principal.userId);
+  return principalId.length > 0;
+}
+function resolvePrincipalRoles(context) {
+  return new Set(toNormalizedStringList(resolvePrincipalRecord(context)?.roles));
+}
+function resolvePrincipalCapabilities(context) {
+  const principal = resolvePrincipalRecord(context);
+  return new Set(toNormalizedStringList(principal?.permissions ?? principal?.capabilities));
+}
+function hasResolvedScopeContext(context) {
+  return typeof context?.scopeId === "string" && context.scopeId.trim().length > 0 || typeof context?.projectId === "string" && context.projectId.trim().length > 0;
+}
+function resolveToolInvokeRequirements(params) {
+  const auth = resolveToolPolicyAuth(params.tool);
+  const safety = resolveToolPolicySafety(params.tool);
+  const contextPolicy = resolveToolPolicyContext(params.tool);
+  const rolesRequired = toNormalizedStringList(auth.roles);
+  const capabilitiesRequired = toNormalizedStringList(auth.capabilities);
+  const principalPresent = hasAuthenticatedPrincipal(params.context);
+  const principalRoles = resolvePrincipalRoles(params.context);
+  const principalCapabilities = resolvePrincipalCapabilities(params.context);
+  const rolesSatisfied = rolesRequired.length === 0 || rolesRequired.some((role) => principalRoles.has(role));
+  const capabilitiesSatisfied = capabilitiesRequired.length === 0 || principalCapabilities.has("*") || capabilitiesRequired.some((capability) => principalCapabilities.has(capability));
+  const authRequired = auth.required === true || rolesRequired.length > 0 || capabilitiesRequired.length > 0;
+  const accessGrantRequired = rolesRequired.length > 0 || capabilitiesRequired.length > 0;
+  const applyRequired = safety.applyRequired === true;
+  const confirmationRequired = safety.confirmationRequired === true;
+  const scopeRequired = contextPolicy.scopeRequired === true || contextPolicy.projectRequired === true;
+  return {
+    authRequired,
+    principalPresent,
+    authSatisfied: (!authRequired || principalPresent) && (!accessGrantRequired || rolesSatisfied || capabilitiesSatisfied),
+    rolesRequired,
+    rolesSatisfied,
+    capabilitiesRequired,
+    capabilitiesSatisfied,
+    applyRequired,
+    applySatisfied: !applyRequired || params.apply === true,
+    confirmationRequired,
+    confirmationSatisfied: !confirmationRequired || params.confirm === true,
+    scopeRequired,
+    scopeSatisfied: !scopeRequired || hasResolvedScopeContext(params.context)
+  };
+}
+function validateToolInvokeSafety(params) {
+  const requirements = resolveToolInvokeRequirements({
+    tool: params.tool,
+    apply: params.apply,
+    confirm: params.confirm
+  });
+  if (!requirements.applySatisfied) {
+    return {
+      ok: false,
+      message: `apply_required:${params.tool.toolId}`
+    };
+  }
+  if (!requirements.confirmationSatisfied) {
+    return {
+      ok: false,
+      message: `confirmation_required:${params.tool.toolId}`
+    };
+  }
+  return { ok: true };
+}
+function validateToolInvokeAuthorization(params) {
+  const requirements = resolveToolInvokeRequirements({
+    tool: params.tool,
+    context: params.context
+  });
+  if (requirements.authRequired && !requirements.principalPresent) {
+    return {
+      ok: false,
+      message: "unauthorized"
+    };
+  }
+  if (!requirements.authSatisfied) {
+    return {
+      ok: false,
+      message: "forbidden"
+    };
+  }
+  return { ok: true };
+}
+function validateToolInvokeScope(params) {
+  const requirements = resolveToolInvokeRequirements({
+    tool: params.tool,
+    context: params.context
+  });
+  if (!requirements.scopeSatisfied) {
+    return {
+      ok: false,
+      message: "project_context_required"
+    };
+  }
+  return { ok: true };
+}
+function validateToolInputByContract(params) {
+  const contract = resolveToolArgContract(params.tool, params.manifests);
+  if (!contract) return { ok: true };
+  const payload = toContractValidationPayload(params.parsedInput, params.tool, params.manifests, params.context);
+  if (!payload) {
+    if (contract.requiredArgs.length === 0) return { ok: true };
+    const firstRequired = contract.requiredArgs[0] ?? "input";
+    if (firstRequired === "scopeId" || firstRequired === "projectId") {
+      return { ok: false, message: "project_required" };
+    }
+    return {
+      ok: false,
+      message: `missing_required_arg:${firstRequired};operation:${params.tool.operationId}`
+    };
+  }
+  if ((contract.requiredArgs.includes("scopeId") || contract.requiredArgs.includes("projectId")) && !contract.requiredArgs.every(
+    (argName) => argName === "scopeId" || argName === "projectId" ? hasRequiredArg(payload, params.context, argName) : true
+  )) {
+    return { ok: false, message: "project_required" };
+  }
+  const parsed = toContractValidationSchema(contract, params.tool.operationId, params.context).safeParse(payload);
+  if (parsed.success) return { ok: true };
+  return {
+    ok: false,
+    message: formatContractValidationError(params.tool, parsed.error)
+  };
+}
+function formatSchemaErrors(errors) {
+  if (!errors || errors.length === 0) return "invalid_input";
+  const first = errors[0];
+  const path2 = first.instancePath && first.instancePath.length > 0 ? first.instancePath : "/";
+  const message = first.message ?? first.keyword;
+  return `${path2} ${message}`.trim();
+}
+function findManifestForDomain(manifests, domain) {
+  return manifests.find((manifest) => normalizeDomain(manifest.domain.id) === normalizeDomain(domain)) ?? null;
+}
+function buildDomainSchemaCache(domain, manifest) {
+  const ajv = new Ajv({
+    allErrors: true,
+    strict: false,
+    coerceTypes: false,
+    allowUnionTypes: true
+  });
+  const schemas = isRecord$3(manifest.contracts?.schemas) ? manifest.contracts?.schemas : {};
+  for (const [schemaRef, schema] of Object.entries(schemas ?? {})) {
+    if (!schemaRef.trim()) continue;
+    if (!isRecord$3(schema)) continue;
+    ajv.addSchema(schema, `${domain}:${schemaRef.trim()}`);
+  }
+  const cache = {
+    ajv,
+    validators: /* @__PURE__ */ new Map()
+  };
+  schemaCacheByDomain.set(domain, cache);
+  return cache;
+}
+function getDomainSchemaCache(domain, manifests) {
+  const normalizedDomain = normalizeDomain(domain);
+  if (!normalizedDomain) return null;
+  const existing = schemaCacheByDomain.get(normalizedDomain);
+  if (existing) return existing;
+  const manifest = findManifestForDomain(manifests, normalizedDomain);
+  if (!manifest) return null;
+  return buildDomainSchemaCache(normalizedDomain, manifest);
+}
+function resetToolSchemaValidationCache(domain) {
+  const normalizedDomain = normalizeDomain("");
+  if (normalizedDomain) {
+    schemaCacheByDomain.delete(normalizedDomain);
+    return;
+  }
+  schemaCacheByDomain.clear();
+}
+function resolveInputValidator(tool, manifests) {
+  const schemaRef = typeof tool.inputSchemaRef === "string" ? tool.inputSchemaRef.trim() : "";
+  if (!schemaRef) return null;
+  const domain = normalizeDomain(tool.domain);
+  const cache = getDomainSchemaCache(domain, manifests);
+  if (!cache) return null;
+  const schemaId = `${domain}:${schemaRef}`;
+  const existing = cache.validators.get(schemaId);
+  if (existing) return { validate: existing, schemaId };
+  const validate = cache.ajv.getSchema(schemaId);
+  if (!validate) return null;
+  cache.validators.set(schemaId, validate);
+  return { validate, schemaId };
+}
+function validateToolInputBySchema(params) {
+  const validator = resolveInputValidator(params.tool, params.manifests);
+  if (!validator) return { ok: true };
+  const payload = toValidationPayload(params.parsedInput, params.tool, params.manifests);
+  const valid = validator.validate(payload);
+  if (valid) return { ok: true };
+  const detail = formatSchemaErrors(validator.validate.errors);
+  return {
+    ok: false,
+    message: `tool_input_schema_invalid:${params.tool.toolId}:${detail}`
+  };
+}
+const CATALOG_REFRESH_ERROR_PREFIXES = [
+  "tool_not_found:",
+  "tool_source_unavailable:",
+  "tool_source_not_found:",
+  "domain_not_registered:",
+  "operation_route_not_found:"
+];
+const LOCAL_RUNTIME_REFRESH_ERROR_PREFIXES = [
+  "domain_not_registered:",
+  "operation_route_not_found:"
+];
+const MUTATING_ACTIVITY_OPERATION_PATTERN = /(^|[.])(create|update|remove|delete|archive|publish|add|save|upsert|write|link|attach|enqueue|start|stop|interrupt|cancel|approve|dispatch|operate|loop|work|restore|copy|rebase|zip|clean)([.-]|$)/;
+function resolveGatewayConfig(config) {
+  return config ?? {
+    enabled: true,
+    includeLocal: true,
+    sources: [],
+    catalog: { enabled: false, manifestProviders: [] }
+  };
+}
+function normalizeNonEmpty(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function sanitizeActivityPayload(value, depth = 0) {
+  if (depth > 3) return "[truncated]";
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    return normalized.length <= 400 ? normalized : `${normalized.slice(0, 397)}...`;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 12).map((entry) => sanitizeActivityPayload(entry, depth + 1));
+  }
+  if (!isRecord(value)) return String(value);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const lower = key.toLowerCase();
+    if (lower.includes("token") || lower.includes("secret") || lower.includes("password") || lower.includes("authorization")) {
+      continue;
+    }
+    next[key] = sanitizeActivityPayload(entry, depth + 1);
+  }
+  return next;
+}
+function maybePushActivityRef(target, type, id, label) {
+  const normalizedId = normalizeNonEmpty(id);
+  if (!normalizedId) return;
+  if (target.some((entry) => entry.type === type && entry.id === normalizedId)) return;
+  target.push({ type, id: normalizedId });
+}
+function collectActivityRefs(value, refs) {
+  if (!isRecord(value)) return;
+  maybePushActivityRef(refs, "scope", value.scopeId);
+  maybePushActivityRef(refs, "project", value.projectId);
+  maybePushActivityRef(refs, "task", value.taskId);
+  maybePushActivityRef(refs, "sprint", value.sprintId);
+  maybePushActivityRef(refs, "microtask", value.microtaskId);
+  maybePushActivityRef(refs, "issue", value.issueId);
+  maybePushActivityRef(refs, "feedback", value.feedbackId);
+  maybePushActivityRef(refs, "prompt", value.promptId);
+  maybePushActivityRef(refs, "prompt-version", value.promptVersionId);
+  maybePushActivityRef(refs, "skill", value.skillId);
+  maybePushActivityRef(refs, "skill-version", value.skillVersionId);
+  maybePushActivityRef(refs, "resource", value.resourceId);
+  maybePushActivityRef(refs, "artifact", value.artifactId);
+  maybePushActivityRef(refs, "run", value.runId ?? value.runRecordId);
+  maybePushActivityRef(refs, "workflow", value.workflowId ?? value.workflowInstanceId);
+  maybePushActivityRef(refs, "workflow-definition", value.workflowDefinitionId);
+  maybePushActivityRef(refs, "document", value.documentId);
+  maybePushActivityRef(refs, "document-version", value.documentVersionId);
+  maybePushActivityRef(refs, "page", value.pageId);
+  maybePushActivityRef(refs, "page-version", value.pageVersionId);
+  maybePushActivityRef(refs, "section", value.sectionId);
+  if (isRecord(value.data)) collectActivityRefs(value.data, refs);
+  if (isRecord(value.input)) collectActivityRefs(value.input, refs);
+  if (isRecord(value.response)) collectActivityRefs(value.response, refs);
+  if (isRecord(value.result)) collectActivityRefs(value.result, refs);
+}
+function resolveGatewayActivityAction(tool) {
+  const segments = String(tool.operationId ?? "").split(".").filter(Boolean);
+  return segments[segments.length - 1] ?? "invoke";
+}
+function summarizeGatewayActivity(tool, status) {
+  const action = resolveGatewayActivityAction(tool);
+  const entity = String(tool.toolId ?? tool.operationId ?? "operation").replace(/^aops\./, "").replace(/^agentspace\./, "").replace(/^tasker\./, "").replace(/^projectman\./, "").replace(/^docman\./, "").replace(/^fileman\./, "").split(".").slice(0, 2).join(" ").replace(/[-_]+/g, " ").trim() || "operation";
+  const verbMap = {
+    create: "created",
+    add: "added",
+    update: "updated",
+    set: "updated",
+    publish: "published",
+    remove: "removed",
+    delete: "deleted",
+    restore: "restored",
+    copy: "copied",
+    rebase: "rebased",
+    zip: "archived",
+    clean: "cleaned",
+    link: "linked",
+    attach: "attached",
+    enqueue: "enqueued",
+    start: "started",
+    stop: "stopped",
+    cancel: "cancelled",
+    interrupt: "interrupted",
+    approve: "approved",
+    save: "saved",
+    write: "written",
+    record: "recorded",
+    store: "stored"
+  };
+  const actionKey = action.split("-")[0] ?? action;
+  const verb = verbMap[actionKey] ?? `${action.replace(/[-_]+/g, " ")} completed`;
+  return status === "success" ? `${entity} ${verb}` : `${entity} ${action.replace(/[-_]+/g, " ")} failed`;
+}
+function shouldAppendDurableGatewayActivity(tool, args) {
+  const normalizedToolId = normalizeToolId(tool.toolId);
+  if (!normalizedToolId) return false;
+  if (args.preview === true) return false;
+  if (normalizedToolId.startsWith("agentspace.activity-item.")) return false;
+  if (args.apply !== true && args.confirm !== true) return false;
+  return MUTATING_ACTIVITY_OPERATION_PATTERN.test(normalizedToolId) || MUTATING_ACTIVITY_OPERATION_PATTERN.test(String(tool.operationId ?? "").toLowerCase());
+}
+function resolveGatewayActivitySourceKind(context) {
+  const candidate = normalizeNonEmpty(context?.activitySourceKind);
+  if (candidate === "aops-cli" || candidate === "desktop" || candidate === "runner" || candidate === "system") {
+    return candidate;
+  }
+  return "system";
+}
+function cloneStringList(values) {
+  if (!Array.isArray(values)) return void 0;
+  const normalized = values.map((value) => String(value ?? "").trim()).filter(Boolean);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function mergeStringLists(...lists) {
+  const values = /* @__PURE__ */ new Set();
+  for (const list of lists) {
+    for (const entry of list ?? []) {
+      const normalized = String(entry ?? "").trim();
+      if (!normalized) continue;
+      values.add(normalized);
+    }
+  }
+  return values.size > 0 ? [...values] : void 0;
+}
+function toOperationDocs(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input = value;
+  const summary = typeof input.summary === "string" && input.summary.trim().length > 0 ? input.summary.trim() : void 0;
+  const notes = cloneStringList(input.notes);
+  const examples = cloneStringList(input.examples);
+  const antiPatterns = cloneStringList(input.antiPatterns);
+  const preconditions = cloneStringList(input.preconditions);
+  const postconditions = cloneStringList(input.postconditions);
+  const docs = {
+    ...summary ? { summary } : {},
+    ...notes ? { notes } : {},
+    ...examples ? { examples } : {},
+    ...antiPatterns ? { antiPatterns } : {},
+    ...preconditions ? { preconditions } : {},
+    ...postconditions ? { postconditions } : {}
+  };
+  return Object.keys(docs).length > 0 ? docs : null;
+}
+function toDomainDocs(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input = value;
+  const summary = typeof input.summary === "string" && input.summary.trim().length > 0 ? input.summary.trim() : void 0;
+  const notes = cloneStringList(input.notes);
+  const docs = {
+    ...summary ? { summary } : {},
+    ...notes ? { notes } : {}
+  };
+  return Object.keys(docs).length > 0 ? docs : null;
+}
+function buildDomainMetadataByDomain(snapshot, domain) {
+  const normalizedDomain = normalizeDomain(domain ?? "");
+  const metadataByDomain = {};
+  for (const manifest of snapshot.manifests) {
+    const manifestDomain = normalizeDomain(manifest.domain.id);
+    if (!manifestDomain) continue;
+    if (normalizedDomain.length > 0 && manifestDomain !== normalizedDomain) continue;
+    const existing = metadataByDomain[manifestDomain];
+    const domainDocs = toDomainDocs(manifest.docs?.domain);
+    const resources = manifest.capabilities.resources ?? [];
+    const resourceDocsMap = manifest.docs?.resources && typeof manifest.docs.resources === "object" && !Array.isArray(manifest.docs.resources) ? manifest.docs.resources : {};
+    const mergedResources = new Map(
+      (existing?.resources ?? []).map((resource) => [normalizeDomain(resource.resourceId), resource])
+    );
+    for (const resource of resources) {
+      const resourceId = String(resource.resourceId ?? "").trim().toLowerCase();
+      if (!resourceId) continue;
+      const docEntryRaw = resourceDocsMap[resource.resourceId] ?? resourceDocsMap[resourceId];
+      const docEntry = toDomainDocs(docEntryRaw);
+      const current = mergedResources.get(resourceId);
+      const title = current?.title ?? (String(resource.title ?? "").trim() || resourceId);
+      const kind = current?.kind ?? (typeof resource.kind === "string" && resource.kind.trim().length > 0 ? resource.kind.trim() : void 0);
+      const schemaRef = current?.schemaRef ?? (typeof resource.schemaRef === "string" && resource.schemaRef.trim().length > 0 ? resource.schemaRef.trim() : void 0);
+      mergedResources.set(resourceId, {
+        resourceId,
+        title,
+        kind,
+        schemaRef,
+        summary: current?.summary ?? docEntry?.summary,
+        notes: mergeStringLists(current?.notes, docEntry?.notes)
+      });
+    }
+    const description = existing?.description ?? (typeof manifest.domain.description === "string" && manifest.domain.description.trim().length > 0 ? manifest.domain.description.trim() : void 0);
+    const summary = existing?.summary ?? domainDocs?.summary ?? description;
+    const notes = mergeStringLists(existing?.notes, domainDocs?.notes);
+    metadataByDomain[manifestDomain] = {
+      domain: manifestDomain,
+      displayName: existing?.displayName ?? (typeof manifest.domain.displayName === "string" && manifest.domain.displayName.trim().length > 0 ? manifest.domain.displayName.trim() : void 0),
+      ...description ? { description } : {},
+      ...summary ? { summary } : {},
+      ...notes ? { notes } : {},
+      ...mergedResources.size > 0 ? {
+        resources: [...mergedResources.values()].sort((left, right) => left.title.localeCompare(right.title))
+      } : {}
+    };
+  }
+  return Object.keys(metadataByDomain).length > 0 ? metadataByDomain : void 0;
+}
+function buildOperationDocsByOperationId(snapshot, domain) {
+  const normalizedDomain = normalizeDomain(domain ?? "");
+  const docsByOperationId = {};
+  for (const manifest of snapshot.manifests) {
+    if (normalizedDomain.length > 0 && normalizeDomain(manifest.domain.id) !== normalizedDomain) continue;
+    const operations = manifest.docs?.operations;
+    if (!operations || typeof operations !== "object" || Array.isArray(operations)) continue;
+    for (const [operationIdRaw, value] of Object.entries(operations)) {
+      const operationId = String(operationIdRaw ?? "").trim().toLowerCase();
+      if (!operationId) continue;
+      const docs = toOperationDocs(value);
+      if (!docs) continue;
+      docsByOperationId[operationId] = docs;
+    }
+  }
+  return Object.keys(docsByOperationId).length > 0 ? docsByOperationId : void 0;
+}
+function buildListResult(snapshot, domain) {
+  const normalizedDomain = normalizeDomain(domain ?? "");
+  const tools = normalizedDomain.length > 0 ? snapshot.catalog.tools.filter((tool) => normalizeDomain(tool.domain) === normalizedDomain) : snapshot.catalog.tools;
+  const operationDocsByOperationId = buildOperationDocsByOperationId(snapshot, domain);
+  const domainMetadataByDomain = buildDomainMetadataByDomain(snapshot, domain);
+  return {
+    catalogVersion: snapshot.catalog.catalogVersion,
+    generatedAt: snapshot.catalog.generatedAt,
+    tools,
+    errors: snapshot.errors,
+    ...operationDocsByOperationId ? { operationDocsByOperationId } : {},
+    ...domainMetadataByDomain ? { domainMetadataByDomain } : {}
+  };
+}
+function findToolInputJsonSchemaInManifests(snapshot, tool) {
+  const inputSchemaRef = typeof tool.inputSchemaRef === "string" ? tool.inputSchemaRef.trim() : "";
+  if (!inputSchemaRef) return null;
+  const toolDomain = normalizeDomain(tool.domain);
+  for (const manifest of snapshot.manifests) {
+    if (normalizeDomain(manifest.domain.id) !== toolDomain) continue;
+    const schema = manifest.contracts?.schemas?.[inputSchemaRef];
+    if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+      return schema;
+    }
+  }
+  return null;
+}
+function buildToolResponse(tool, source, status, data, headers) {
+  return {
+    tool: {
+      ...tool,
+      sourceId: source.id,
+      sourceKind: source.kind,
+      sourceBaseUrl: source.baseUrl,
+      sourceApiBasePath: source.apiBasePath
+    },
+    status,
+    data,
+    headers
+  };
+}
+function isSuccessfulInvokeResult(result) {
+  if (result.status >= 400) return false;
+  if (!result.data || typeof result.data !== "object" || Array.isArray(result.data)) return true;
+  return result.data.ok !== false;
+}
+function appendPreviewQueryValue(target, key, value) {
+  const existing = target[key];
+  if (existing === void 0) {
+    target[key] = value;
+    return;
+  }
+  if (Array.isArray(existing)) {
+    existing.push(value);
+    return;
+  }
+  target[key] = [existing, value];
+}
+function toPreviewQueryObject(query) {
+  const out = {};
+  for (const [key, value] of query.entries()) {
+    appendPreviewQueryValue(out, key, value);
+  }
+  return out;
+}
+function buildPreviewHeaders(context) {
+  const headers = {};
+  if (typeof context?.tenantId === "string" && context.tenantId.trim().length > 0) {
+    headers["x-tenant-id"] = context.tenantId.trim();
+  }
+  if (typeof context?.locale === "string" && context.locale.trim().length > 0) {
+    headers["x-locale"] = context.locale.trim();
+  }
+  if (typeof context?.fallbackLocale === "string" && context.fallbackLocale.trim().length > 0) {
+    headers["x-fallback-locale"] = context.fallbackLocale.trim();
+  }
+  if (typeof context?.projectId === "string" && context.projectId.trim().length > 0) {
+    headers["x-project-id"] = context.projectId.trim();
+  }
+  return headers;
+}
+async function appendDurableGatewayActivityBestEffort(params) {
+  const scopeId = normalizeNonEmpty(params.args.context?.scopeId);
+  const projectId = normalizeNonEmpty(params.args.context?.projectId);
+  if (!scopeId && !projectId) return;
+  const resolvedScopeId = scopeId || projectId;
+  const refs = [];
+  maybePushActivityRef(refs, "scope", resolvedScopeId);
+  maybePushActivityRef(refs, "project", projectId);
+  collectActivityRefs(params.args.input, refs);
+  collectActivityRefs(params.responseData, refs);
+  const requestHeaders = new Headers();
+  const tenantId = normalizeNonEmpty(params.args.context?.tenantId);
+  if (tenantId) requestHeaders.set("x-tenant-id", tenantId);
+  const url = new URL("https://xf-host.local/api/agentspace/operations/activity-item/add-activity-item");
+  const payload = params.status === "error" ? {
+    input: params.args.input,
+    error: params.errorMessage ? { message: params.errorMessage } : void 0
+  } : {
+    input: params.args.input,
+    result: params.responseData
+  };
+  try {
+    await params.registry.ensureSetup("agentspace");
+    await dispatchDomainRequest({
+      registry: params.registry,
+      request: {
+        method: "POST",
+        domain: "agentspace",
+        path: ["operations", "activity-item", "add-activity-item"],
+        query: new URLSearchParams(),
+        body: {
+          data: {
+            scopeId: resolvedScopeId,
+            projectId,
+            sourceKind: resolveGatewayActivitySourceKind(params.args.context),
+            sourceId: params.tool.toolId,
+            action: resolveGatewayActivityAction(params.tool),
+            status: params.status,
+            summary: summarizeGatewayActivity(params.tool, params.status),
+            refs,
+            payload: sanitizeActivityPayload(payload)
+          }
+        },
+        headers: requestHeaders,
+        url,
+        context: {
+          ...params.args.context ?? {},
+          scopeId: resolvedScopeId,
+          ...projectId ? { projectId } : {}
+        }
+      }
+    });
+  } catch {
+  }
+}
+function buildPreflightInvokeBody(args, requirements, nextIdempotencyKey) {
+  return {
+    ...args.sourceId ? { sourceId: args.sourceId } : {},
+    input: args.input ?? {},
+    ...nextIdempotencyKey ? { idempotencyKey: nextIdempotencyKey } : {},
+    ...requirements.applyRequired ? { apply: true } : {},
+    ...requirements.confirmationRequired ? { confirm: true } : {}
+  };
+}
+function buildToolInvokePreviewPayload(params) {
+  const semantic = buildAgentSemanticPreview({
+    domain: params.tool.domain,
+    operationId: params.tool.operationId,
+    input: params.parsedInput.body ?? params.args.input ?? {}
+  });
+  const requirements = resolveToolInvokeRequirements({
+    tool: params.tool,
+    context: params.context,
+    apply: params.args.apply,
+    confirm: params.args.confirm
+  });
+  const governance = buildInvokeGovernancePreview(
+    {
+      tool: params.tool,
+      source: params.source,
+      args: params.args
+    },
+    requirements,
+    {
+      recommendedKey: semantic?.idempotency?.recommendedKey,
+      recommendedKeySource: semantic?.idempotency ? "domain-natural-key" : void 0
+    }
+  );
+  const path2 = `/api/${normalizeDomain(params.tool.domain)}${params.pathSegments.length > 0 ? `/${params.pathSegments.join("/")}` : ""}`;
+  const headers = buildPreviewHeaders(params.context);
+  return {
+    ok: true,
+    preview: true,
+    mode: "preflight",
+    ready: requirements.authSatisfied && requirements.scopeSatisfied && requirements.applySatisfied && requirements.confirmationSatisfied,
+    tool: {
+      toolId: params.tool.toolId,
+      domain: params.tool.domain,
+      operationId: params.tool.operationId,
+      sourceId: params.source.id,
+      sourceKind: params.source.kind
+    },
+    route: {
+      method: params.route.method,
+      pattern: params.route.pattern,
+      path: path2,
+      ...params.requestUrl ? { requestUrl: params.requestUrl } : {}
+    },
+    requirements: {
+      auth: {
+        required: requirements.authRequired,
+        principalPresent: requirements.principalPresent,
+        satisfied: requirements.authSatisfied,
+        ...requirements.rolesRequired.length > 0 ? { roles: requirements.rolesRequired } : {},
+        ...requirements.capabilitiesRequired.length > 0 ? { capabilities: requirements.capabilitiesRequired } : {}
+      },
+      scope: {
+        required: requirements.scopeRequired,
+        satisfied: requirements.scopeSatisfied,
+        ...typeof params.context.scopeId === "string" && params.context.scopeId.trim().length > 0 ? { scopeId: params.context.scopeId.trim() } : typeof params.context.projectId === "string" && params.context.projectId.trim().length > 0 ? { projectId: params.context.projectId.trim() } : {}
+      },
+      apply: {
+        required: requirements.applyRequired,
+        satisfied: requirements.applySatisfied
+      },
+      confirm: {
+        required: requirements.confirmationRequired,
+        satisfied: requirements.confirmationSatisfied
+      }
+    },
+    policy: params.tool.policy ?? null,
+    audit: governance.audit,
+    approval: governance.approval,
+    idempotency: governance.idempotency,
+    ...semantic ? { semantic } : {},
+    normalizedInvoke: {
+      pathParams: { ...params.parsedInput.pathParams },
+      query: toPreviewQueryObject(params.parsedInput.query),
+      body: params.parsedInput.body ?? null,
+      context: params.context,
+      headers
+    },
+    nextInvoke: {
+      headers,
+      body: buildPreflightInvokeBody(params.args, requirements, governance.nextIdempotencyKey)
+    }
+  };
+}
+function createAgentGateway(options) {
+  const config = resolveGatewayConfig(options.config);
+  let catalogSnapshotPromise = null;
+  let latestCatalogSnapshot = null;
+  function normalizeErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error ?? "unknown_error");
+  }
+  function shouldRefreshCatalogForError(error) {
+    const message = normalizeErrorMessage(error);
+    return CATALOG_REFRESH_ERROR_PREFIXES.some((prefix) => message.startsWith(prefix));
+  }
+  function shouldRefreshLocalRuntimeForError(error) {
+    const message = normalizeErrorMessage(error);
+    return LOCAL_RUNTIME_REFRESH_ERROR_PREFIXES.some((prefix) => message.startsWith(prefix));
+  }
+  function invalidateCatalogSnapshot() {
+    catalogSnapshotPromise = null;
+    latestCatalogSnapshot = null;
+    resetToolSchemaValidationCache();
+  }
+  async function getCatalogSnapshot(params = {}) {
+    if (params.forceRefresh) invalidateCatalogSnapshot();
+    if (catalogSnapshotPromise) return catalogSnapshotPromise;
+    const snapshotPromise = buildGatewayCatalogSnapshot({
+      config,
+      configPath: options.configPath
+    }).then((snapshot) => {
+      latestCatalogSnapshot = snapshot;
+      return snapshot;
+    }).catch((error) => {
+      if (catalogSnapshotPromise === snapshotPromise) {
+        catalogSnapshotPromise = null;
+        latestCatalogSnapshot = null;
+      }
+      throw error;
+    });
+    catalogSnapshotPromise = snapshotPromise;
+    return catalogSnapshotPromise;
+  }
+  async function refreshCatalogSnapshot() {
+    return getCatalogSnapshot({ forceRefresh: true });
+  }
+  async function refreshLocalRuntimeSnapshot() {
+    options.registryResetter?.();
+    return refreshCatalogSnapshot();
+  }
+  function getDiagnostics() {
+    return {
+      enabled: config.enabled !== false,
+      snapshotLoaded: latestCatalogSnapshot !== null,
+      loadedAt: latestCatalogSnapshot?.loadedAt,
+      catalogVersion: latestCatalogSnapshot?.catalog.catalogVersion,
+      generatedAt: latestCatalogSnapshot?.catalog.generatedAt,
+      toolCount: latestCatalogSnapshot?.catalog.tools.length ?? 0,
+      errorCount: latestCatalogSnapshot?.errors.length ?? 0
+    };
+  }
+  async function listTools(domain) {
+    if (config.enabled === false) {
+      return { catalogVersion: "1.0.0", generatedAt: (/* @__PURE__ */ new Date()).toISOString(), tools: [], errors: [] };
+    }
+    const snapshot = await getCatalogSnapshot();
+    return buildListResult(snapshot, domain);
+  }
+  async function getToolInputJsonSchema(toolId) {
+    if (config.enabled === false) return null;
+    const normalized = normalizeToolId(toolId);
+    const snapshot = await getCatalogSnapshot();
+    const tool = snapshot.catalog.tools.find((entry) => normalizeToolId(entry.toolId) === normalized);
+    if (!tool) return null;
+    const manifestSchema = findToolInputJsonSchemaInManifests(snapshot, tool);
+    if (manifestSchema) return manifestSchema;
+    const registry = await options.registryResolver();
+    const plugin = registry.get(normalizeDomain(tool.domain));
+    if (!plugin) return null;
+    const route = findDomainRouteByOperation(plugin.manifest.routes, tool.operationId);
+    if (!route) return null;
+    const schema = route.inputJsonSchema;
+    return schema && typeof schema === "object" && !Array.isArray(schema) ? schema : null;
+  }
+  async function invokeLocalSource(snapshot, tool, source, args, invokeOptions) {
+    const registry = await options.registryResolver();
+    const domain = normalizeDomain(tool.domain);
+    const plugin = registry.get(domain);
+    if (!plugin) {
+      throw new Error(`domain_not_registered:${domain}`);
+    }
+    await registry.ensureSetup(domain);
+    const route = findDomainRouteByOperation(plugin.manifest.routes, tool.operationId);
+    if (!route) {
+      throw new Error(`operation_route_not_found:${domain}:${tool.operationId}`);
+    }
+    const parsedInput = normalizeInvokeInputForRoute({
+      parsedInput: parseRouteInvokeInput(args.input),
+      routePattern: route.pattern,
+      routeMethod: route.method,
+      tool,
+      manifests: snapshot.manifests
+    });
+    const context = { ...parsedInput.context, ...args.context ?? {} };
+    const authValidation = validateToolInvokeAuthorization({
+      tool,
+      context
+    });
+    if (!authValidation.ok && args.preview !== true) {
+      throw new Error(authValidation.message);
+    }
+    const scopeValidation = validateToolInvokeScope({
+      tool,
+      context
+    });
+    if (!scopeValidation.ok && args.preview !== true) {
+      throw new Error(scopeValidation.message);
+    }
+    const safetyValidation = validateToolInvokeSafety({
+      tool,
+      apply: args.apply,
+      confirm: args.confirm
+    });
+    if (!safetyValidation.ok && args.preview !== true) {
+      throw new Error(safetyValidation.message);
+    }
+    const contractValidation = validateToolInputByContract({
+      tool,
+      manifests: snapshot.manifests,
+      parsedInput,
+      context
+    });
+    if (!contractValidation.ok) {
+      throw new Error(contractValidation.message);
+    }
+    const schemaValidation = validateToolInputBySchema({
+      tool,
+      manifests: snapshot.manifests,
+      parsedInput
+    });
+    if (!schemaValidation.ok) {
+      throw new Error(schemaValidation.message);
+    }
+    const pathSegments = patternToPathSegments(route.pattern, parsedInput.pathParams);
+    const query = parsedInput.query;
+    const url = new URL(`https://xf-host.local/api/${domain}${pathSegments.length > 0 ? `/${pathSegments.join("/")}` : ""}`);
+    for (const [key, value] of query.entries()) {
+      url.searchParams.append(key, value);
+    }
+    if (args.preview === true) {
+      return buildToolResponse(
+        tool,
+        source,
+        200,
+        buildToolInvokePreviewPayload({
+          tool,
+          source,
+          route,
+          pathSegments,
+          parsedInput,
+          context,
+          args
+        })
+      );
+    }
+    const requestHeaders = new Headers();
+    if (typeof invokeOptions.effectiveIdempotencyKey === "string" && invokeOptions.effectiveIdempotencyKey.length > 0) {
+      requestHeaders.set("x-idempotency-key", invokeOptions.effectiveIdempotencyKey);
+    }
+    const response = await dispatchDomainRequest({
+      registry,
+      request: {
+        method: route.method,
+        domain,
+        path: pathSegments,
+        query,
+        body: parsedInput.body,
+        headers: requestHeaders,
+        url,
+        context
+      }
+    });
+    return buildToolResponse(tool, source, response.status, response.data, response.headers);
+  }
+  async function invokeRemoteSource(snapshot, tool, source, args, invokeOptions) {
+    const remoteSource = config.sources.find(
+      (candidate) => candidate.enabled && candidate.id === source.id && normalizeDomain(candidate.domain) === normalizeDomain(tool.domain)
+    );
+    if (!remoteSource) {
+      throw new Error(`tool_source_not_found:${source.id}`);
+    }
+    const routes = await fetchRemoteRoutes(remoteSource);
+    const route = findRemoteRouteByOperation(routes, tool.operationId);
+    if (!route) {
+      throw new Error(`operation_route_not_found:${tool.domain}:${tool.operationId}`);
+    }
+    const parsedInput = normalizeInvokeInputForRoute({
+      parsedInput: parseRouteInvokeInput(args.input),
+      routePattern: route.pattern,
+      routeMethod: route.method,
+      tool,
+      manifests: snapshot.manifests
+    });
+    const mergedContext = { ...parsedInput.context, ...args.context ?? {} };
+    const authValidation = validateToolInvokeAuthorization({
+      tool,
+      context: mergedContext
+    });
+    if (!authValidation.ok && args.preview !== true) {
+      throw new Error(authValidation.message);
+    }
+    const scopeValidation = validateToolInvokeScope({
+      tool,
+      context: mergedContext
+    });
+    if (!scopeValidation.ok && args.preview !== true) {
+      throw new Error(scopeValidation.message);
+    }
+    const safetyValidation = validateToolInvokeSafety({
+      tool,
+      apply: args.apply,
+      confirm: args.confirm
+    });
+    if (!safetyValidation.ok && args.preview !== true) {
+      throw new Error(safetyValidation.message);
+    }
+    const contractValidation = validateToolInputByContract({
+      tool,
+      manifests: snapshot.manifests,
+      parsedInput,
+      context: mergedContext
+    });
+    if (!contractValidation.ok) {
+      throw new Error(contractValidation.message);
+    }
+    const schemaValidation = validateToolInputBySchema({
+      tool,
+      manifests: snapshot.manifests,
+      parsedInput
+    });
+    if (!schemaValidation.ok) {
+      throw new Error(schemaValidation.message);
+    }
+    const pathSegments = patternToPathSegments(route.pattern, parsedInput.pathParams);
+    const baseUrl = normalizeBaseUrl(remoteSource.baseUrl);
+    const apiBasePath = normalizeApiBasePath(remoteSource.apiBasePath);
+    const requestUrl = new URL(
+      `${baseUrl}${apiBasePath}/${remoteSource.domain}${pathSegments.length > 0 ? `/${pathSegments.join("/")}` : ""}`
+    );
+    for (const [key, value] of parsedInput.query.entries()) {
+      requestUrl.searchParams.append(key, value);
+    }
+    if (args.preview === true) {
+      return buildToolResponse(
+        tool,
+        source,
+        200,
+        buildToolInvokePreviewPayload({
+          tool,
+          source,
+          route,
+          pathSegments,
+          parsedInput,
+          context: mergedContext,
+          args,
+          requestUrl: requestUrl.toString()
+        })
+      );
+    }
+    const headers = resolveSourceHeaders(remoteSource);
+    if (typeof mergedContext.tenantId === "string" && mergedContext.tenantId.trim().length > 0) {
+      headers["x-tenant-id"] = mergedContext.tenantId;
+    }
+    if (typeof mergedContext.locale === "string" && mergedContext.locale.trim().length > 0) {
+      headers["x-locale"] = mergedContext.locale;
+    }
+    if (typeof mergedContext.fallbackLocale === "string" && mergedContext.fallbackLocale.trim().length > 0) {
+      headers["x-fallback-locale"] = mergedContext.fallbackLocale;
+    }
+    if (typeof mergedContext.projectId === "string" && mergedContext.projectId.trim().length > 0) {
+      headers["x-project-id"] = mergedContext.projectId.trim();
+    }
+    if (typeof invokeOptions.effectiveIdempotencyKey === "string" && invokeOptions.effectiveIdempotencyKey.length > 0) {
+      headers["x-idempotency-key"] = invokeOptions.effectiveIdempotencyKey;
+    }
+    const method = route.method.toUpperCase();
+    let bodyPayload;
+    if (method !== "GET" && method !== "HEAD" && parsedInput.body !== void 0) {
+      headers["content-type"] = "application/json";
+      bodyPayload = JSON.stringify(parsedInput.body);
+    }
+    const { controller, cleanup } = createTimeoutController(remoteSource.timeoutMs);
+    try {
+      const response = await fetch(requestUrl, {
+        method,
+        headers,
+        body: bodyPayload,
+        signal: controller.signal
+      });
+      const responseData = await parseFetchBody(response);
+      return buildToolResponse(tool, source, response.status, responseData, pickResponseHeaders(response));
+    } finally {
+      cleanup();
+    }
+  }
+  async function resolveToolFromSnapshot(toolIdRaw) {
+    const toolId = normalizeToolId(toolIdRaw);
+    if (!toolId) throw new Error("tool_id_missing");
+    let snapshot = await getCatalogSnapshot();
+    let tool = snapshot.toolsById.get(toolId);
+    if (tool) {
+      return { snapshot, toolId, tool };
+    }
+    snapshot = await refreshCatalogSnapshot();
+    tool = snapshot.toolsById.get(toolId);
+    if (!tool) {
+      throw new Error(`tool_not_found:${toolIdRaw}`);
+    }
+    return { snapshot, toolId, tool };
+  }
+  async function invokeResolvedTool(snapshot, tool, args, sourceId, options2) {
+    const source = chooseSourceForInvocation(tool, sourceId);
+    if (source.kind === "local-route") {
+      try {
+        return await invokeLocalSource(snapshot, tool, source, args, {
+          effectiveIdempotencyKey: options2.effectiveIdempotencyKey
+        });
+      } catch (error) {
+        if (options2.preferRefreshOnLocalMiss && shouldRefreshLocalRuntimeForError(error)) {
+          throw error;
+        }
+        if (sourceId || !shouldFallbackFromLocalError(error)) {
+          throw error;
+        }
+        const fallbackSource = findFirstRemoteSource(tool);
+        if (!fallbackSource) {
+          throw error;
+        }
+        return invokeRemoteSource(snapshot, tool, fallbackSource, args, {
+          effectiveIdempotencyKey: options2.effectiveIdempotencyKey
+        });
+      }
+    }
+    return invokeRemoteSource(snapshot, tool, source, args, {
+      effectiveIdempotencyKey: options2.effectiveIdempotencyKey
+    });
+  }
+  async function invokeTool(args) {
+    if (config.enabled === false) {
+      throw new Error("agent_gateway_disabled");
+    }
+    const startedAt = Date.now();
+    const { snapshot, toolId, tool } = await resolveToolFromSnapshot(args.toolId);
+    const sourceId = normalizeSourceId(args.sourceId);
+    const requestedSource = chooseSourceForInvocation(tool, sourceId);
+    const semanticRecommendedIdempotencyKey = resolveAgentSemanticIdempotencyKey({
+      domain: tool.domain,
+      operationId: tool.operationId,
+      input: args.input ?? {}
+    });
+    const effectiveIdempotencyKey = typeof args.idempotencyKey === "string" && args.idempotencyKey.trim().length > 0 ? args.idempotencyKey.trim() : semanticRecommendedIdempotencyKey;
+    const reservation = reserveInvokeIdempotency({
+      tool,
+      source: requestedSource,
+      args: {
+        ...args,
+        sourceId: requestedSource.id
+      }
+    }, {
+      recommendedKey: semanticRecommendedIdempotencyKey,
+      effectiveKey: effectiveIdempotencyKey
+    });
+    if (reservation.kind === "resolved") {
+      await writeAgentInvokeAuditEvent({
+        tool,
+        requestedSourceId: requestedSource.id,
+        effectiveSourceId: reservation.result.tool.sourceId,
+        outcome: reservation.idempotencyStatus === "replayed" ? "replayed" : "blocked",
+        status: reservation.result.status,
+        durationMs: Date.now() - startedAt,
+        context: args.context,
+        apply: args.apply,
+        confirm: args.confirm,
+        idempotencyKey: effectiveIdempotencyKey,
+        idempotencyStatus: reservation.idempotencyStatus,
+        preview: args.preview,
+        errorCode: reservation.idempotencyStatus === "replayed" ? void 0 : reservation.idempotencyStatus === "conflict" ? "idempotency_key_conflict" : "idempotency_in_progress"
+      });
+      return reservation.result;
+    }
+    try {
+      let result;
+      try {
+        result = await invokeResolvedTool(snapshot, tool, args, sourceId, {
+          preferRefreshOnLocalMiss: true,
+          effectiveIdempotencyKey
+        });
+      } catch (error) {
+        if (!shouldRefreshCatalogForError(error)) {
+          throw error;
+        }
+        const refreshedSnapshot = shouldRefreshLocalRuntimeForError(error) ? await refreshLocalRuntimeSnapshot() : await refreshCatalogSnapshot();
+        const refreshedTool = refreshedSnapshot.toolsById.get(toolId);
+        if (!refreshedTool) {
+          throw new Error(`tool_not_found:${args.toolId}`);
+        }
+        result = await invokeResolvedTool(refreshedSnapshot, refreshedTool, args, sourceId, {
+          preferRefreshOnLocalMiss: false,
+          effectiveIdempotencyKey
+        });
+      }
+      if (reservation.kind === "active") {
+        reservation.settle(result);
+      }
+      const responseResult = reservation.kind === "active" && effectiveIdempotencyKey ? {
+        ...result,
+        headers: {
+          ...result.headers ?? {},
+          "x-agent-idempotency-status": "fresh",
+          "x-agent-idempotency-key": effectiveIdempotencyKey
+        }
+      } : result;
+      await writeAgentInvokeAuditEvent({
+        tool,
+        requestedSourceId: requestedSource.id,
+        effectiveSourceId: responseResult.tool.sourceId,
+        outcome: args.preview === true ? "preview" : isSuccessfulInvokeResult(responseResult) ? "success" : "failure",
+        status: responseResult.status,
+        durationMs: Date.now() - startedAt,
+        context: args.context,
+        apply: args.apply,
+        confirm: args.confirm,
+        idempotencyKey: effectiveIdempotencyKey,
+        idempotencyStatus: reservation.kind === "active" && effectiveIdempotencyKey ? "fresh" : void 0,
+        preview: args.preview
+      });
+      if (shouldAppendDurableGatewayActivity(tool, args)) {
+        await appendDurableGatewayActivityBestEffort({
+          registry: await options.registryResolver(),
+          tool,
+          args,
+          status: isSuccessfulInvokeResult(responseResult) ? "success" : "error",
+          responseData: responseResult.data
+        });
+      }
+      return responseResult;
+    } catch (error) {
+      if (reservation.kind === "active") {
+        reservation.release();
+      }
+      await writeAgentInvokeAuditEvent({
+        tool,
+        requestedSourceId: requestedSource.id,
+        effectiveSourceId: requestedSource.id,
+        outcome: buildInvokeFailureStatus(error) === 409 ? "blocked" : "failure",
+        status: buildInvokeFailureStatus(error),
+        durationMs: Date.now() - startedAt,
+        context: args.context,
+        apply: args.apply,
+        confirm: args.confirm,
+        idempotencyKey: effectiveIdempotencyKey,
+        preview: args.preview,
+        errorCode: error instanceof Error ? error.message : String(error ?? "unknown_error")
+      });
+      if (shouldAppendDurableGatewayActivity(tool, args)) {
+        await appendDurableGatewayActivityBestEffort({
+          registry: await options.registryResolver(),
+          tool,
+          args,
+          status: "error",
+          errorMessage: error instanceof Error ? error.message : String(error ?? "unknown_error")
+        });
+      }
+      throw error;
+    }
+  }
+  async function getOpenApi(args = {}) {
+    const snapshot = await getCatalogSnapshot();
+    const normalizedDomain = normalizeDomain(args.domain ?? "");
+    const manifests = normalizedDomain.length > 0 ? snapshot.manifests.filter((manifest) => normalizeDomain(manifest.domain?.id ?? "") === normalizedDomain) : snapshot.manifests;
+    const tools = normalizedDomain.length > 0 ? snapshot.catalog.tools.filter((tool) => normalizeDomain(tool.domain) === normalizedDomain) : snapshot.catalog.tools;
+    const catalog = {
+      ...snapshot.catalog,
+      tools
+    };
+    const document = buildAgentGatewayOpenApi({
+      manifests,
+      catalog,
+      serverBaseUrl: args.serverBaseUrl
+    });
+    return normalizeAgentGatewayOpenApiDocument(document);
+  }
+  return {
+    listTools,
+    getToolInputJsonSchema,
+    invokeTool,
+    getOpenApi,
+    getDiagnostics,
+    refreshCatalogSnapshot,
+    invalidateCatalogSnapshot
+  };
+}
+let singleton = null;
+function getAgentGateway() {
+  if (singleton) return singleton;
+  const config = getHostConfig();
+  singleton = createAgentGateway({
+    registryResolver: getHostPluginRegistry,
+    registryResetter: resetHostPluginRegistry,
+    config: config.agentGateway
+  });
+  return singleton;
+}
+function getAgentGatewayDiagnostics() {
+  return singleton?.getDiagnostics() ?? {
+    enabled: getHostConfig().agentGateway?.enabled !== false,
+    snapshotLoaded: false,
+    toolCount: 0,
+    errorCount: 0
+  };
+}
+
+export { normalizeToolId as a, getAgentGatewayDiagnostics as b, getAgentGateway as g, normalizeDomain as n, resolveOperationKind as r };
+//# sourceMappingURL=agent-gateway-runtime-DTZ4SxaC.js.map