@aopslabs/aops-server 0.2.18 → 0.2.19

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

@@ -0,0 +1,924 @@
+import { dispatchDomainRequest } from '@aopslabs/host-core';
+import { b as buildInternalDomainRequest } from './domain-dispatch.js-DUR9TD3Q.js';
+import { buildAgentGatewayOpenApi, buildFederatedToolCatalog, validateManifest } from '@aopslabs/manifest';
+import { g as getHostConfig, a as getKernelRuntimeSnapshot, b as getHostPluginRegistry, c as checkHostDomainAdmission, r as resetHostPluginRegistry } from './registry.js-W6rrS4yl.js';
+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';
+
+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 normalizeToolId$1(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+function shouldAppendActivity(tool, args) {
+  const normalizedToolId = normalizeToolId$1(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(normalizeToolId$1(tool.operationId));
+}
+function describeActivityAppendFailure(tool, status, error) {
+  return {
+    toolId: normalizeToolId$1(tool.toolId) || "unknown_tool",
+    status,
+    message: error instanceof Error ? error.message : String(error ?? "unknown_error")
+  };
+}
+function reportActivityAppendFailure(tool, status, error, warn = (message, detail) => console.warn(message, detail)) {
+  warn("[agent-gateway] durable activity append failed", describeActivityAppendFailure(tool, status, error));
+}
+function buildActivityInvokeArgs(toolId, envelope, context) {
+  return {
+    toolId,
+    ...envelope.sourceId === void 0 ? {} : { sourceId: envelope.sourceId },
+    input: envelope.input,
+    ...envelope.preview === void 0 ? {} : { preview: envelope.preview },
+    ...envelope.apply === void 0 ? {} : { apply: envelope.apply },
+    ...envelope.confirm === void 0 ? {} : { confirm: envelope.confirm },
+    ...envelope.idempotencyKey === void 0 ? {} : { idempotencyKey: envelope.idempotencyKey },
+    ...context === void 0 ? {} : { context }
+  };
+}
+function createLedgerSilenceWatch(options) {
+  const threshold = Math.max(1, 1);
+  const warn = ((message, detail) => console.warn(message, detail));
+  const now = (() => (/* @__PURE__ */ new Date()).toISOString());
+  let mutatingInvokes = 0;
+  let appendAttempts = 0;
+  let appendFailures = 0;
+  let lastAppendAt = null;
+  let lastAppendStatus = null;
+  let warned = false;
+  const isSilent = () => appendAttempts === 0 && mutatingInvokes >= threshold;
+  const snapshot = () => ({
+    mutatingInvokes,
+    appendAttempts,
+    appendFailures,
+    lastAppendAt,
+    lastAppendStatus,
+    silent: isSilent(),
+    warned
+  });
+  return {
+    recordMutatingInvoke() {
+      if (!warned && appendAttempts === 0 && mutatingInvokes >= threshold) {
+        warned = true;
+        warn(
+          `[agent-gateway] activity ledger silent: ${String(mutatingInvokes)} mutating invokes, zero append attempts`,
+          snapshot()
+        );
+      }
+      mutatingInvokes += 1;
+    },
+    recordAppendAttempt(status, at) {
+      appendAttempts += 1;
+      lastAppendStatus = status;
+      lastAppendAt = at ?? now();
+    },
+    recordAppendFailure() {
+      appendFailures += 1;
+    },
+    snapshot
+  };
+}
+function isRecord$2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeDomain(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+function normalizeToolId(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+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$2(payload) || !hasInputEnvelope(payload)) return payload;
+  const envelopeParts = [payload.context, payload.query, payload.body, payload.params, payload.pathParams];
+  if (envelopeParts.some((part) => part !== void 0 && !isRecord$2(part))) return payload;
+  const flattened = Object.assign(
+    {},
+    ...envelopeParts.filter((part) => isRecord$2(part))
+  );
+  return Object.keys(flattened).length > 0 ? flattened : 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 hasInputEnvelope(input) {
+  const envelopeKeys = /* @__PURE__ */ new Set(["pathParams", "params", "query", "body", "context"]);
+  const keys = Object.keys(input);
+  if (keys.length === 0 || keys.some((key) => !envelopeKeys.has(key))) return false;
+  if (isRecord$2(input.pathParams) || isRecord$2(input.params) || isRecord$2(input.context)) return true;
+  if (isRecord$2(input.query)) return true;
+  return Object.prototype.hasOwnProperty.call(input, "body");
+}
+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;
+}
+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 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;
+      if (!checkHostDomainAdmission(provider.domain).allowed) 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;
+    if (!checkHostDomainAdmission(source.domain).allowed) continue;
+    domains.add(normalizeDomain(source.domain));
+  }
+  const sources = config.sources.filter((source) => source.enabled && checkHostDomainAdmission(source.domain).allowed).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)).filter(
+      (tool) => checkHostDomainAdmission(tool.domain, tool.operationId).allowed
+    )
+  };
+  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$1(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isEnvelopeOnlyInvokeSchema(schema) {
+  if (!isRecord$1(schema)) return false;
+  if (Array.isArray(schema.oneOf)) return false;
+  if (schema.type !== "object") return false;
+  const properties = isRecord$1(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$1(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$1(document.paths) ? document.paths : null;
+  if (!paths) return document;
+  let changed = false;
+  const normalizedPaths = {};
+  for (const [pathKey, pathValue] of Object.entries(paths)) {
+    if (!isRecord$1(pathValue) || !isRecord$1(pathValue.post)) {
+      normalizedPaths[pathKey] = pathValue;
+      continue;
+    }
+    const post = pathValue.post;
+    const requestBody = isRecord$1(post.requestBody) ? post.requestBody : null;
+    const content = requestBody && isRecord$1(requestBody.content) ? requestBody.content : null;
+    const jsonContent = content && isRecord$1(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 schemaCacheByDomain = /* @__PURE__ */ new Map();
+function resetToolSchemaValidationCache(domain) {
+  const normalizedDomain = normalizeDomain("");
+  if (normalizedDomain) {
+    schemaCacheByDomain.delete(normalizedDomain);
+    return;
+  }
+  schemaCacheByDomain.clear();
+}
+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) {
+  return shouldAppendActivity(
+    { toolId: tool.toolId, ...tool.operationId === void 0 ? {} : { operationId: String(tool.operationId) } },
+    { ...args.preview === void 0 ? {} : { preview: args.preview }, ...args.apply === void 0 ? {} : { apply: args.apply }, ...args.confirm === void 0 ? {} : { confirm: args.confirm } }
+  );
+}
+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;
+}
+async function appendDurableGatewayActivityBestEffort(params) {
+  const scopeId = normalizeNonEmpty(params.args.context?.scopeId);
+  const projectId = normalizeNonEmpty(params.args.context?.projectId);
+  const resolvedScopeId = scopeId || projectId;
+  if (!resolvedScopeId) return;
+  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 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: buildInternalDomainRequest({
+        method: "POST",
+        domain: "agentspace",
+        path: ["operations", "activity-item", "add-activity-item"],
+        scopeId: resolvedScopeId,
+        // The tenant header travelled with this call before it went through
+        // the shared builder, and dropping it would have been a silent change
+        // of who the append is attributed to.
+        headers: Object.fromEntries(requestHeaders.entries()),
+        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)
+          }
+        },
+        context: {
+          ...params.args.context ?? {},
+          ...projectId ? { projectId } : {}
+        }
+      })
+    });
+  } catch (error) {
+    reportActivityAppendFailure({ toolId: params.tool.toolId }, params.status, error);
+  }
+}
+function createAgentGateway(options) {
+  const config = resolveGatewayConfig(options.config);
+  let catalogSnapshotPromise = null;
+  let latestCatalogSnapshot = null;
+  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 });
+  }
+  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 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,
+    getOpenApi,
+    getDiagnostics,
+    refreshCatalogSnapshot,
+    invalidateCatalogSnapshot
+  };
+}
+let singleton = null;
+const ledgerWatch = createLedgerSilenceWatch();
+function getAgentGateway() {
+  if (singleton) return singleton;
+  const config = getHostConfig();
+  singleton = createAgentGateway({
+    registryResolver: getHostPluginRegistry,
+    registryResetter: resetHostPluginRegistry,
+    config: config.agentGateway
+  });
+  return singleton;
+}
+function getAgentGatewayDiagnostics() {
+  const base = singleton?.getDiagnostics() ?? {
+    enabled: getHostConfig().agentGateway?.enabled !== false,
+    snapshotLoaded: false,
+    toolCount: 0,
+    errorCount: 0
+  };
+  return { ...base, activityLedger: ledgerWatch.snapshot() };
+}
+function normalize(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+async function appendActivityForKernelInvoke(params) {
+  if (!params.owed) return;
+  ledgerWatch.recordAppendAttempt(params.status);
+  await appendDurableGatewayActivityBestEffort({
+    registry: await getHostPluginRegistry(),
+    tool: params.tool,
+    args: params.invokeArgs,
+    status: params.status,
+    ...params.responseData === void 0 ? {} : { responseData: params.responseData },
+    ...params.errorMessage === void 0 ? {} : { errorMessage: params.errorMessage }
+  });
+}
+async function invokeKernelAgentTool(args) {
+  const catalogGateway = getAgentGateway();
+  const catalog = await catalogGateway.listTools();
+  const catalogTool = catalog.tools.find((tool) => normalize(tool.toolId) === normalize(args.toolId));
+  if (!catalogTool) throw new Error(`tool_not_found:${args.toolId}`);
+  const snapshot = await getKernelRuntimeSnapshot();
+  const plugin = snapshot.registry.get(normalize(catalogTool.domain));
+  if (!plugin) throw new Error(`domain_not_registered:${catalogTool.domain}`);
+  const route = plugin.manifest.routes.find(
+    (candidate) => normalize(candidate.operation) === normalize(catalogTool.operationId)
+  );
+  if (!route) {
+    throw new Error(`operation_route_not_found:${catalogTool.domain}:${catalogTool.operationId}`);
+  }
+  const routeId = normalize(route.id);
+  const kernelToolId = routeId.startsWith(`${normalize(catalogTool.domain)}.`) ? routeId : `${normalize(catalogTool.domain)}.${routeId}`;
+  const invokeArgs = buildActivityInvokeArgs(args.toolId, args.envelope, args.context);
+  const owesActivityRecord = shouldAppendDurableGatewayActivity(catalogTool, invokeArgs);
+  if (owesActivityRecord) ledgerWatch.recordMutatingInvoke();
+  let result;
+  try {
+    result = await snapshot.gateway.invokeTool({
+      toolId: kernelToolId,
+      envelope: args.envelope,
+      context: args.context,
+      ...args.requestHeaders ? { requestHeaders: args.requestHeaders } : {}
+    });
+  } catch (error) {
+    await appendActivityForKernelInvoke({
+      tool: catalogTool,
+      invokeArgs,
+      owed: owesActivityRecord,
+      status: "error",
+      errorMessage: error instanceof Error ? error.message : String(error ?? "unknown_error")
+    });
+    throw error;
+  }
+  const succeeded = result.status < 400 && result.data?.ok !== false;
+  await appendActivityForKernelInvoke({
+    tool: catalogTool,
+    invokeArgs,
+    owed: owesActivityRecord,
+    status: succeeded ? "success" : "error",
+    responseData: result.data,
+    ...succeeded ? {} : { errorMessage: `invoke_status_${String(result.status)}` }
+  });
+  return {
+    tool: {
+      ...catalogTool,
+      sourceId: result.tool.sourceId,
+      sourceKind: "local-route"
+    },
+    status: result.status,
+    data: result.data,
+    ...result.headers ? { headers: result.headers } : {}
+  };
+}
+
+export { normalizeToolId as a, getAgentGatewayDiagnostics as b, getAgentGateway as g, invokeKernelAgentTool as i, normalizeDomain as n, resolveOperationKind as r };