@aifabrix/builder 2.50.0 → 2.51.1

package/lib/channels/channel-runtime-resolver.js

@@ -8,8 +8,17 @@
 
 'use strict';
 
+const crypto = require('crypto');
 const { getChannelTarget } = require('./channel-targets');
 const { normalizeSlackAppDescription } = require('./channel-description');
+const {
+  CHATGPT_RUNTIME_SYSTEM_KEY,
+  CHATGPT_RUNTIME_TRANSPORT,
+  CHATGPT_RUNTIME_AUTH_MODE,
+  COPILOT_RUNTIME_SYSTEM_KEY,
+  COPILOT_RUNTIME_TRANSPORT,
+  COPILOT_RUNTIME_AUTH_MODE
+} = require('./chatgpt-runtime-contract');
 
 /** Default Slack slash prefix — matches dataplane `templates/slack/command_catalog.yaml`. */
 const DEFAULT_SLACK_COMMAND_PREFIX = 'af';
@@ -62,13 +71,10 @@ function getEndpointPathSuffixes(channelTarget) {
       botConfigUrl: '/bot-config'
     },
     'microsoft-copilot': {
-      openapiUrl: '/openapi.yaml',
-      actionsBaseUrl: '/actions'
+      mcpUrl: '/mcp'
     },
     chatgpt: {
-      openapiUrl: '/openapi.yaml',
-      mcpUrl: '/mcp',
-      actionsBaseUrl: '/actions'
+      mcpUrl: '/mcp'
     },
     'web-embed': {
       configUrl: '/config'
@@ -78,21 +84,12 @@ function getEndpointPathSuffixes(channelTarget) {
 }
 
 /**
- * Legacy / non-external-system paths (Copilot/ChatGPT until dataplane routes exist).
+ * Legacy / non-external-system paths where fallback is still allowed.
  * @param {string} channelTarget
  * @returns {Record<string, string>}
  */
 function getLegacyApiPaths(channelTarget) {
   const legacy = {
-    'microsoft-copilot': {
-      openapiUrl: '/api/v1/copilot/openapi.yaml',
-      actionsBaseUrl: '/api/v1/copilot/actions'
-    },
-    chatgpt: {
-      openapiUrl: '/api/v1/chatgpt/openapi.yaml',
-      mcpUrl: '/api/v1/chatgpt/mcp',
-      actionsBaseUrl: '/api/v1/chatgpt/actions'
-    },
     'web-embed': {
       configUrl: '/api/v1/web-embed/config'
     }
@@ -120,6 +117,101 @@ function resolveSlackOAuthManifestFields(oauthCallbackUrl) {
   };
 }
 
+/**
+ * @param {Object} resolved
+ * @param {Object} params
+ */
+function applyChatGptRuntimeValues(resolved, params) {
+  resolved.runtimeSystemKey = CHATGPT_RUNTIME_SYSTEM_KEY;
+  resolved.runtimeTransport = CHATGPT_RUNTIME_TRANSPORT;
+  resolved.runtimeAuthMode = CHATGPT_RUNTIME_AUTH_MODE;
+  resolved.layerBToolNames = Array.isArray(params.layerBToolNames) ? [...params.layerBToolNames] : [];
+  resolved.scopes = Array.isArray(params.scopes) ? [...params.scopes] : [];
+  resolved.scopesJson = JSON.stringify(resolved.scopes);
+}
+
+/**
+ * @param {string} seed
+ * @returns {string}
+ */
+function buildDeterministicGuid(seed) {
+  const hex = crypto.createHash('sha256').update(String(seed || ''), 'utf8').digest('hex');
+  const bytes = hex.slice(0, 32).split('');
+  bytes[12] = '4';
+  bytes[16] = 'a';
+  return [
+    bytes.slice(0, 8).join(''),
+    bytes.slice(8, 12).join(''),
+    bytes.slice(12, 16).join(''),
+    bytes.slice(16, 20).join(''),
+    bytes.slice(20, 32).join('')
+  ].join('-');
+}
+
+/**
+ * @param {Object} resolved
+ * @param {Object} params
+ */
+function applyMicrosoftCopilotRuntimeValues(resolved, params) {
+  resolved.runtimeSystemKey = COPILOT_RUNTIME_SYSTEM_KEY;
+  resolved.runtimeTransport = COPILOT_RUNTIME_TRANSPORT;
+  resolved.runtimeAuthMode = COPILOT_RUNTIME_AUTH_MODE;
+  resolved.layerBToolNames = Array.isArray(params.layerBToolNames) ? [...params.layerBToolNames] : [];
+  resolved.scopes = Array.isArray(params.scopes)
+    ? [...params.scopes]
+    : ['openid', 'profile', 'offline_access'];
+  resolved.scopesJson = JSON.stringify(resolved.scopes);
+  resolved.packageVersion = typeof params.packageVersion === 'string' ? params.packageVersion : '1.0.0';
+  resolved.packageAppId = buildDeterministicGuid(
+    `${resolved.channelTarget}:${resolved.baseName}:${resolved.environment}:app`
+  );
+  resolved.pluginId = buildDeterministicGuid(
+    `${resolved.channelTarget}:${resolved.baseName}:${resolved.environment}:plugin`
+  );
+  resolved.runtimeDomain = '';
+  try {
+    resolved.runtimeDomain = new URL(resolved.mcpUrl).hostname;
+  } catch {
+    try {
+      resolved.runtimeDomain = new URL(resolved.dataplaneBaseUrl).hostname;
+    } catch {
+      resolved.runtimeDomain = '';
+    }
+  }
+}
+
+/**
+ * @param {Object} resolved
+ * @param {string} base
+ * @param {string} systemPrefix
+ * @param {Record<string, string>} suffixes
+ * @param {Record<string, string>} legacy
+ */
+function applyResolvedPaths(resolved, base, systemPrefix, suffixes, legacy) {
+  for (const [key, suffix] of Object.entries(suffixes)) {
+    resolved[key] = joinUrl(base, `${systemPrefix}${suffix}`);
+  }
+  for (const [key, legacyPath] of Object.entries(legacy)) {
+    if (!resolved[key]) {
+      resolved[key] = joinUrl(base, legacyPath);
+    }
+  }
+}
+
+/**
+ * @param {Object} resolved
+ * @param {Object} params
+ */
+function applySlackRuntimeValues(resolved, params) {
+  const oauthCallbackUrl = params.oauthCallbackUrl || resolved.oauthCallbackUrl;
+  Object.assign(resolved, resolveSlackOAuthManifestFields(oauthCallbackUrl));
+  const prefix =
+    typeof params.commandPrefix === 'string' && params.commandPrefix.trim()
+      ? params.commandPrefix.trim()
+      : DEFAULT_SLACK_COMMAND_PREFIX;
+  resolved.commandPrefix = prefix;
+}
+
 /**
  * @param {Object} params
  * @param {string} params.dataplaneBaseUrl
@@ -158,24 +250,18 @@ function resolveChannelRuntimeValues(params) {
     scopes: []
   };
 
-  for (const [key, suffix] of Object.entries(suffixes)) {
-    resolved[key] = joinUrl(base, `${systemPrefix}${suffix}`);
+  applyResolvedPaths(resolved, base, systemPrefix, suffixes, legacy);
+
+  if (params.channelTarget === 'slack') {
+    applySlackRuntimeValues(resolved, params);
   }
 
-  for (const [key, legacyPath] of Object.entries(legacy)) {
-    if (!resolved[key]) {
-      resolved[key] = joinUrl(base, legacyPath);
-    }
+  if (params.channelTarget === 'microsoft-copilot') {
+    applyMicrosoftCopilotRuntimeValues(resolved, params);
   }
 
-  if (params.channelTarget === 'slack') {
-    const oauthCallbackUrl = params.oauthCallbackUrl || resolved.oauthCallbackUrl;
-    Object.assign(resolved, resolveSlackOAuthManifestFields(oauthCallbackUrl));
-    const prefix =
-      typeof params.commandPrefix === 'string' && params.commandPrefix.trim()
-        ? params.commandPrefix.trim()
-        : DEFAULT_SLACK_COMMAND_PREFIX;
-    resolved.commandPrefix = prefix;
+  if (params.channelTarget === 'chatgpt') {
+    applyChatGptRuntimeValues(resolved, params);
   }
 
   return resolved;
@@ -186,6 +272,11 @@ module.exports = {
   joinUrl,
   externalSystemsPrefix,
   getEndpointPathSuffixes,
+  buildDeterministicGuid,
+  applyResolvedPaths,
+  applySlackRuntimeValues,
+  applyMicrosoftCopilotRuntimeValues,
+  applyChatGptRuntimeValues,
   resolveSlackOAuthManifestFields,
   resolveChannelRuntimeValues,
   DEFAULT_SLACK_COMMAND_PREFIX

package/lib/channels/channel-status-display.js

@@ -148,6 +148,50 @@ function displayValidationSection(validation) {
   if (validation.inboundVerification) {
     logger.log(formatSuccessLine('Inbound verification configured'));
   }
+  displayProbeTiers(validation.probeTiers);
+  displayRuntimeChecks(validation.runtimeChecks);
+}
+
+/**
+ * @param {Object|null} probeTiers
+ */
+function displayProbeTiers(probeTiers) {
+  if (!probeTiers) return;
+  logger.log('');
+  logger.log(metadata('Probe tiers:'));
+  const rows = [];
+  if (Object.prototype.hasOwnProperty.call(probeTiers, 'builderValidated')) {
+    rows.push(['builderValidated', probeTiers.builderValidated, false]);
+  }
+  if (Object.prototype.hasOwnProperty.call(probeTiers, 'locallyValidated')) {
+    rows.push(['locallyValidated', probeTiers.locallyValidated, false]);
+  }
+  rows.push(['runtimeValidated', probeTiers.runtimeValidated, false]);
+  if (Object.prototype.hasOwnProperty.call(probeTiers, 'requiresMicrosoftAdmin')) {
+    rows.push(['requiresMicrosoftAdmin', probeTiers.requiresMicrosoftAdmin, true]);
+  }
+  if (Object.prototype.hasOwnProperty.call(probeTiers, 'requiresChatGptWorkspaceAdmin')) {
+    rows.push(['requiresChatGptWorkspaceAdmin', probeTiers.requiresChatGptWorkspaceAdmin, true]);
+  }
+  for (const [label, value, isPendingGate] of rows) {
+    if (isPendingGate) {
+      logger.log(value ? formatWarningLine(label) : formatSuccessLine(`${label} (cleared)`));
+      continue;
+    }
+    logger.log(value ? formatSuccessLine(label) : formatWarningLine(`${label} (pending or failed)`));
+  }
+}
+
+/**
+ * @param {Object|null} runtimeChecks
+ */
+function displayRuntimeChecks(runtimeChecks) {
+  if (!runtimeChecks || typeof runtimeChecks !== 'object') return;
+  logger.log('');
+  logger.log(metadata('Runtime checks:'));
+  for (const [key, value] of Object.entries(runtimeChecks)) {
+    logger.log(value ? formatSuccessLine(key) : formatWarningLine(`${key} (failed)`));
+  }
 }
 
 /**

package/lib/channels/channel-targets.js

@@ -8,6 +8,11 @@
 
 'use strict';
 
+const {
+  CHATGPT_RUNTIME_SYSTEM_KEY,
+  COPILOT_RUNTIME_SYSTEM_KEY
+} = require('./chatgpt-runtime-contract');
+
 /** @typedef {'teams-bot'|'slack'|'microsoft-copilot'|'chatgpt'|'web-embed'} ChannelTargetKey */
 
 const DEFAULT_CAPABILITIES = ['chat', 'notify', 'documentApproval'];
@@ -44,6 +49,7 @@ const CHANNEL_TARGETS = {
     artifactFileName: 'channel-microsoft-copilot.json',
     artifactFormat: 'json',
     credentialKey: 'microsoft-copilot-channel',
+    routeSystemKey: COPILOT_RUNTIME_SYSTEM_KEY,
     capabilities: [...DEFAULT_CAPABILITIES, 'enterpriseActions'],
     approvalRequired: true,
     experimental: false
@@ -55,6 +61,7 @@ const CHANNEL_TARGETS = {
     artifactFileName: 'channel-chatgpt.json',
     artifactFormat: 'json',
     credentialKey: 'chatgpt-channel',
+    routeSystemKey: CHATGPT_RUNTIME_SYSTEM_KEY,
     capabilities: ['chat', 'enterpriseActions'],
     approvalRequired: true,
     experimental: false

package/lib/channels/chatgpt-runtime-contract.js

@@ -0,0 +1,29 @@
+/**
+ * ChatGPT custom MCP app runtime contract constants (plan 163).
+ *
+ * @fileoverview Runtime-orchestration MCP contract fields used by chatgpt channel templates and probes
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const RUNTIME_ORCHESTRATION_SYSTEM_KEY = 'runtime-orchestration';
+
+const CHATGPT_RUNTIME_SYSTEM_KEY = RUNTIME_ORCHESTRATION_SYSTEM_KEY;
+const CHATGPT_RUNTIME_TRANSPORT = 'streamable-http';
+const CHATGPT_RUNTIME_AUTH_MODE = 'workspace-managed-oauth-or-api-key';
+
+const COPILOT_RUNTIME_SYSTEM_KEY = RUNTIME_ORCHESTRATION_SYSTEM_KEY;
+const COPILOT_RUNTIME_TRANSPORT = 'streamable-http';
+const COPILOT_RUNTIME_AUTH_MODE = 'microsoft-entra-sso-or-oauth';
+
+module.exports = {
+  RUNTIME_ORCHESTRATION_SYSTEM_KEY,
+  CHATGPT_RUNTIME_SYSTEM_KEY,
+  CHATGPT_RUNTIME_TRANSPORT,
+  CHATGPT_RUNTIME_AUTH_MODE,
+  COPILOT_RUNTIME_SYSTEM_KEY,
+  COPILOT_RUNTIME_TRANSPORT,
+  COPILOT_RUNTIME_AUTH_MODE
+};

package/lib/channels/microsoft-copilot-package.js

@@ -0,0 +1,280 @@
+/**
+ * Microsoft Copilot package artifact generation (plan 164).
+ *
+ * @fileoverview Build source files, package ZIP, and lifecycle summary for microsoft-copilot channel
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const AdmZip = require('adm-zip');
+
+const PLACEHOLDER_ICON_BASE64 =
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2s9WQAAAAASUVORK5CYII=';
+
+/**
+ * @param {string} outputPath
+ * @param {Object} runtimeValues
+ * @returns {Object}
+ */
+function buildCopilotOutputPaths(outputPath, runtimeValues) {
+  const rootDir = path.dirname(outputPath);
+  const sourceDir = path.join(rootDir, 'source');
+  const buildDir = path.join(rootDir, 'build');
+  const installDir = path.join(rootDir, 'install');
+  const environment = String(runtimeValues.environment || 'dev').trim() || 'dev';
+  const zipFileName = `appPackage.${environment}.zip`;
+  return {
+    rootDir,
+    sourceDir,
+    buildDir,
+    installDir,
+    summaryPath: outputPath,
+    zipFileName,
+    zipPath: path.join(buildDir, zipFileName),
+    validationPath: path.join(installDir, 'validation.json'),
+    installPath: path.join(installDir, 'README.md')
+  };
+}
+
+/**
+ * @returns {{ color: Buffer, outline: Buffer }}
+ */
+function getPlaceholderIcons() {
+  const icon = Buffer.from(PLACEHOLDER_ICON_BASE64, 'base64');
+  return { color: icon, outline: icon };
+}
+
+/**
+ * @param {Object} runtimeValues
+ * @param {(templatePath: string, context: Object) => string} renderTemplateFile
+ * @param {string} templatesDir
+ * @returns {{ sourceFiles: Record<string, string>, installText: string }}
+ */
+function renderCopilotTemplates(runtimeValues, renderTemplateFile, templatesDir) {
+  const sourceFiles = {
+    'manifest.json': renderTemplateFile(path.join(templatesDir, 'manifest.template.json.hbs'), runtimeValues),
+    'declarativeAgent.json': renderTemplateFile(
+      path.join(templatesDir, 'declarative-agent.template.json.hbs'),
+      runtimeValues
+    ),
+    'ai-plugin.json': renderTemplateFile(
+      path.join(templatesDir, 'ai-plugin.template.json.hbs'),
+      runtimeValues
+    )
+  };
+  const installText = renderTemplateFile(path.join(templatesDir, 'install.template.md.hbs'), runtimeValues);
+  return { sourceFiles, installText };
+}
+
+/**
+ * @param {Record<string, string>} sourceFiles
+ * @param {(content: string) => void} assertNoSecretsInArtifact
+ */
+function assertNoSecretsInSourceFiles(sourceFiles, assertNoSecretsInArtifact) {
+  for (const content of Object.values(sourceFiles)) {
+    assertNoSecretsInArtifact(content);
+  }
+}
+
+/**
+ * @param {Record<string, string>} sourceFiles
+ * @param {{ color: Buffer, outline: Buffer }} icons
+ * @returns {Buffer}
+ */
+function buildCopilotZipBuffer(sourceFiles, icons) {
+  const zip = new AdmZip();
+  zip.addFile('manifest.json', Buffer.from(sourceFiles['manifest.json'], 'utf8'));
+  zip.addFile('declarativeAgent.json', Buffer.from(sourceFiles['declarativeAgent.json'], 'utf8'));
+  zip.addFile('ai-plugin.json', Buffer.from(sourceFiles['ai-plugin.json'], 'utf8'));
+  zip.addFile('color.png', icons.color);
+  zip.addFile('outline.png', icons.outline);
+  return zip.toBuffer();
+}
+
+/**
+ * @param {Object} runtimeValues
+ * @param {Object} paths
+ * @param {string[]} sourceFileNames
+ * @returns {Object}
+ */
+function buildCopilotValidation(runtimeValues, paths, sourceFileNames) {
+  return {
+    tier: 'builderValidated',
+    environment: runtimeValues.environment,
+    sourceFiles: sourceFileNames,
+    zipFile: paths.zipFileName,
+    runtimeSystemKey: runtimeValues.runtimeSystemKey,
+    runtimeMcpUrl: runtimeValues.mcpUrl,
+    runtimeTransport: runtimeValues.runtimeTransport,
+    expectedLayerBToolNames: runtimeValues.layerBToolNames || [],
+    boundaries: {
+      onePackagePerEnvironment: true,
+      topLevelVendorToolsExposed: false,
+      roleAssistantResolution: 'dynamic-runtime'
+    },
+    requiresMicrosoftAdmin: [
+      'upload-package',
+      'tenant-approval',
+      'assignment-and-consent',
+      'first-copilot-invoke'
+    ]
+  };
+}
+
+/**
+ * @param {Array<string|Buffer>} parts
+ * @returns {string}
+ */
+function computeCopilotArtifactHash(parts) {
+  const hash = crypto.createHash('sha256');
+  for (const part of parts) {
+    if (Buffer.isBuffer(part)) {
+      hash.update(part);
+      continue;
+    }
+    hash.update(String(part), 'utf8');
+  }
+  return hash.digest('hex');
+}
+
+/**
+ * @param {Object} runtimeValues
+ * @param {Object} paths
+ * @param {Object} validation
+ * @param {string} artifactHash
+ * @returns {Object}
+ */
+function buildCopilotSummary(runtimeValues, paths, validation, artifactHash) {
+  return {
+    channelTarget: runtimeValues.channelTarget,
+    name: runtimeValues.appName,
+    baseName: runtimeValues.baseName,
+    description: runtimeValues.appDescription,
+    environment: runtimeValues.environment,
+    runtime: {
+      runtimeSystemKey: runtimeValues.runtimeSystemKey,
+      remoteMcpUrl: runtimeValues.mcpUrl,
+      transport: runtimeValues.runtimeTransport,
+      assistantCatalogUrl: runtimeValues.assistantCatalogUrl,
+      roleAssistantResolution: 'dynamic-runtime',
+      layerBToolNames: runtimeValues.layerBToolNames || []
+    },
+    authentication: {
+      mode: runtimeValues.runtimeAuthMode,
+      credentialKey: runtimeValues.credentialKey,
+      credentialPortalUrl: runtimeValues.credentialPortalUrl,
+      scopes: runtimeValues.scopes || []
+    },
+    package: {
+      appId: runtimeValues.packageAppId,
+      version: runtimeValues.packageVersion,
+      sourceFiles: ['manifest.json', 'declarativeAgent.json', 'ai-plugin.json', 'color.png', 'outline.png'],
+      zipFileName: paths.zipFileName,
+      installGuide: path.relative(paths.rootDir, paths.installPath),
+      validationFile: path.relative(paths.rootDir, paths.validationPath)
+    },
+    probeTiers: {
+      builderValidated: true,
+      runtimeValidated: false,
+      requiresMicrosoftAdmin: true
+    },
+    artifact: {
+      format: 'microsoft-365-copilot-package',
+      hash: artifactHash,
+      generatedAt: new Date().toISOString()
+    },
+    validation
+  };
+}
+
+/**
+ * @param {Object} params
+ */
+function writeCopilotArtifacts(params) {
+  const { paths, sourceFiles, icons, zipBuffer, installText, validationText, summaryText } = params;
+  fs.mkdirSync(paths.sourceDir, { recursive: true });
+  fs.mkdirSync(paths.buildDir, { recursive: true });
+  fs.mkdirSync(paths.installDir, { recursive: true });
+  fs.writeFileSync(path.join(paths.sourceDir, 'manifest.json'), sourceFiles['manifest.json'], 'utf8');
+  fs.writeFileSync(
+    path.join(paths.sourceDir, 'declarativeAgent.json'),
+    sourceFiles['declarativeAgent.json'],
+    'utf8'
+  );
+  fs.writeFileSync(path.join(paths.sourceDir, 'ai-plugin.json'), sourceFiles['ai-plugin.json'], 'utf8');
+  fs.writeFileSync(path.join(paths.sourceDir, 'color.png'), icons.color);
+  fs.writeFileSync(path.join(paths.sourceDir, 'outline.png'), icons.outline);
+  fs.writeFileSync(paths.zipPath, zipBuffer);
+  fs.writeFileSync(paths.installPath, installText, 'utf8');
+  fs.writeFileSync(paths.validationPath, validationText, 'utf8');
+  fs.writeFileSync(paths.summaryPath, summaryText, 'utf8');
+}
+
+/**
+ * @param {Object} params
+ * @param {Object} params.runtimeValues
+ * @param {string} params.templatesDir
+ * @param {string} params.outputPath
+ * @param {boolean} [params.dryRun]
+ * @param {(content: string) => void} params.assertNoSecretsInArtifact
+ * @param {(templatePath: string, context: Object) => string} params.renderTemplateFile
+ * @returns {{ outputPath: string, artifactHash: string, content: string, installPath: string }}
+ */
+function generateMicrosoftCopilotPackage(params) {
+  const runtimeValues = params.runtimeValues || {};
+  const paths = buildCopilotOutputPaths(params.outputPath, runtimeValues);
+  const icons = getPlaceholderIcons();
+  const { sourceFiles, installText } = renderCopilotTemplates(
+    runtimeValues,
+    params.renderTemplateFile,
+    params.templatesDir
+  );
+  assertNoSecretsInSourceFiles(sourceFiles, params.assertNoSecretsInArtifact);
+  params.assertNoSecretsInArtifact(installText);
+  const zipBuffer = buildCopilotZipBuffer(sourceFiles, icons);
+  const validation = buildCopilotValidation(runtimeValues, paths, Object.keys(sourceFiles));
+  const validationText = JSON.stringify(validation, null, 2);
+  const artifactHash = computeCopilotArtifactHash([
+    sourceFiles['manifest.json'],
+    sourceFiles['declarativeAgent.json'],
+    sourceFiles['ai-plugin.json'],
+    installText,
+    validationText,
+    zipBuffer
+  ]);
+  const summary = buildCopilotSummary(runtimeValues, paths, validation, artifactHash);
+  const summaryText = JSON.stringify(summary, null, 2);
+  params.assertNoSecretsInArtifact(summaryText);
+  if (!params.dryRun) {
+    writeCopilotArtifacts({
+      paths,
+      sourceFiles,
+      icons,
+      zipBuffer,
+      installText,
+      validationText,
+      summaryText
+    });
+  }
+  return {
+    outputPath: paths.summaryPath,
+    artifactHash,
+    content: summaryText,
+    installPath: paths.installPath
+  };
+}
+
+module.exports = {
+  generateMicrosoftCopilotPackage,
+  buildCopilotOutputPaths,
+  renderCopilotTemplates,
+  buildCopilotZipBuffer,
+  buildCopilotValidation,
+  buildCopilotSummary,
+  computeCopilotArtifactHash
+};