@aifabrix/builder 2.50.0 → 2.51.1

package/lib/app/show.js

@@ -347,7 +347,7 @@ async function getShowAuthToken(controllerUrl, config) {
   }
 
   const formatted = formatAuthenticationError({
-    controllerUrl: controllerUrl || undefined,
+    controllerUrl: undefined,
     message: 'No valid authentication found'
   });
   logger.error(formatted);
@@ -477,7 +477,7 @@ function resolveExternalSystemMeta(res, config, system, application, appKey) {
 
 function buildBaseExternalResult(configData, appKey, openapiFiles, openapiEndpoints, res) {
   const system = configData.system || configData;
-  const dataSources = configData.dataSources || configData.dataSources || [];
+  const dataSources = configData.dataSources || [];
   const application = configData.application || configData.app || {};
   const config = res && res.config && typeof res.config === 'object' ? res.config : {};
   const meta = resolveExternalSystemMeta(res, config, system, application, appKey);

package/lib/certification/merge-certification-from-artifact.js

@@ -13,7 +13,7 @@
 function certificateIdToString(id) {
   if (id === undefined || id === null) return '';
   if (typeof id === 'string') return id.trim();
-  if (typeof id === 'object' && id !== null && typeof id.id === 'string') return String(id.id).trim();
+  if (typeof id === 'object' && typeof id.id === 'string') return String(id.id).trim();
   return String(id).trim();
 }
 

package/lib/channels/add-channel.js

@@ -12,6 +12,7 @@ const { getChannelTarget, getDefaultChannelDescription } = require('./channel-ta
 const { resolveAppDescription } = require('./channel-description');
 const { resolveChannelRuntimeValues } = require('./channel-runtime-resolver');
 const { generateChannelArtifact } = require('./channel-artifact-generator');
+const { fetchRuntimeLayerBToolNames } = require('./runtime-tool-catalog');
 const {
   getExistingChannelExtension,
   buildChannelExtensionBlock,
@@ -66,7 +67,9 @@ function toValidationDisplay(validation) {
     callbackReachable: validation.callbackReachable,
     credentialValid: validation.credentialValid,
     assistantCatalogReachable: validation.assistantCatalogReachable,
-    inboundVerification: Object.values(validation.inboundVerification).every(Boolean)
+    inboundVerification: Object.values(validation.inboundVerification).every(Boolean),
+    probeTiers: validation.probeTiers || null,
+    runtimeChecks: validation.runtimeChecks || null
   };
 }
 
@@ -156,7 +159,13 @@ async function patchConfigWithAudit(ctx, channelTarget, channelBlock, status, ar
 async function maybeRunProbe(ctx, channelBlock, channelTarget, probe) {
   if (!probe) return null;
   const validation = await runChannelProbe(
-    { dataplaneUrl: ctx.dataplaneUrl, authConfig: ctx.authConfig },
+    {
+      dataplaneUrl: ctx.dataplaneUrl,
+      authConfig: ctx.authConfig,
+      environment: ctx.environment,
+      controllerUrl: ctx.controllerUrl,
+      channelTarget
+    },
     channelBlock
   );
   if (validation.passed) {
@@ -268,6 +277,42 @@ function finishDryRunInstall(params) {
   return { dryRun: true, channelBlock: params.channelBlock, artifact: params.artifact };
 }
 
+/**
+ * @param {Object} params
+ * @returns {Promise<{ artifact: Object, channelBlock: Object, status: string }>}
+ */
+async function buildInstallArtifacts(params) {
+  const { channelTarget, options, target, existing, name, baseName, description, ctx } = params;
+  const runtimeToolNames =
+    channelTarget === 'chatgpt' || channelTarget === 'microsoft-copilot'
+      ? await fetchRuntimeLayerBToolNames(ctx.dataplaneUrl, ctx.authConfig, channelTarget)
+      : [];
+  const runtimeValues = resolveChannelRuntimeValues({
+    dataplaneBaseUrl: ctx.dataplaneUrl,
+    channelTarget,
+    appName: name,
+    baseName,
+    environment: ctx.environment,
+    appDescription: description,
+    icon: options.icon,
+    commandPrefix: options.commandPrefix,
+    layerBToolNames: runtimeToolNames
+  });
+  const projectRoot = options.projectRoot || process.cwd();
+  const artifact = generateArtifactWithAudit(channelTarget, {
+    projectRoot,
+    channelTarget,
+    runtimeValues,
+    dryRun: options.dryRun === true
+  });
+  const status = resolveInstallStatus(target, existing, options.dryRun === true);
+  const channelBlock = buildChannelExtensionBlock(
+    { name, baseName, description, artifactHash: artifact.artifactHash, status },
+    target
+  );
+  return { artifact, channelBlock, status };
+}
+
 /**
  * @param {string} channelTarget
  * @param {Object} options
@@ -289,31 +334,17 @@ async function runAddChannel(channelTarget, options = {}) {
   });
   if (skipped) return skipped;
 
-  const runtimeValues = resolveChannelRuntimeValues({
-    dataplaneBaseUrl: ctx.dataplaneUrl,
+  const { artifact, channelBlock, status } = await buildInstallArtifacts({
     channelTarget,
-    appName: name,
+    options,
+    target,
+    existing,
+    name,
     baseName,
-    environment: ctx.environment,
-    appDescription: description,
-    icon: options.icon,
-    commandPrefix: options.commandPrefix
-  });
-
-  const projectRoot = options.projectRoot || process.cwd();
-  const artifact = generateArtifactWithAudit(channelTarget, {
-    projectRoot,
-    channelTarget,
-    runtimeValues,
-    dryRun: options.dryRun === true
+    description,
+    ctx
   });
 
-  const status = resolveInstallStatus(target, existing, options.dryRun === true);
-  const channelBlock = buildChannelExtensionBlock(
-    { name, baseName, description, artifactHash: artifact.artifactHash, status },
-    target
-  );
-
   if (options.dryRun) {
     return finishDryRunInstall({ channelTarget, name, baseName, target, artifact, channelBlock });
   }

package/lib/channels/approval-guides/chatgpt.js

@@ -19,13 +19,14 @@ function buildChatGptApprovalGuide(ctx) {
     portalUrl: 'https://platform.openai.com/',
     steps: [
       'Sign in to OpenAI Platform (https://platform.openai.com/) or your ChatGPT Enterprise workspace admin console.',
-      'Create a custom GPT, workspace connector, or MCP integration using the generated manifest (path shown below).',
-      'Configure the OpenAPI specification URL and MCP endpoint from INSTALL.md (dataplane ChatGPT routes).',
-      'Complete OAuth or API key setup as required by your ChatGPT deployment model.',
-      formatCredentialPortalStep(ctx, 'the API key or OAuth client credentials'),
-      'Publish the connector to your workspace and complete admin approval if your org requires it.',
-      `After ChatGPT lists the connector as active, re-run: ${ctx.resumeCommand}`,
-      'Optional: add --probe when dataplane ChatGPT runtime routes are live on your environment.'
+      'Enable Developer mode / custom MCP app creation for the workspace (if policy requires admin allow-listing).',
+      'Create a custom MCP app using the generated channel-chatgpt.json reference artifact (path shown below).',
+      'Configure the Runtime MCP endpoint from INSTALL.md and verify Runtime Layer B tool discovery.',
+      'Complete workspace authentication setup for the custom MCP app.',
+      formatCredentialPortalStep(ctx, 'workspace credential references used by the ChatGPT channel'),
+      'Publish the app to your workspace and configure end-user access controls.',
+      `After ChatGPT lists the app as active, re-run: ${ctx.resumeCommand}`,
+      'Optional: use --probe for AI Fabrix-side runtime checks; OpenAI-side publication remains a manual admin responsibility.'
     ]
   };
 }

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

@@ -19,14 +19,13 @@ function buildMicrosoftCopilotApprovalGuide(ctx) {
     portalUrl: 'https://admin.cloud.microsoft.com/',
     steps: [
       'Sign in to Microsoft 365 admin (https://admin.cloud.microsoft.com/) or Copilot Studio as a tenant admin.',
-      'Create or open a Copilot extensibility project (declarative agent or API plugin).',
-      'Import or configure using the generated manifest artifact (path shown below).',
-      'Point the OpenAPI / action endpoints to the URLs in INSTALL.md (dataplane Copilot routes).',
-      'Register OAuth client credentials for the API provider connection if the platform prompts for them.',
-      formatCredentialPortalStep(ctx, 'the OAuth client ID and client secret'),
-      'Submit for M365 admin approval and publish to your organization when review completes.',
-      `After Copilot shows the extension as available, re-run: ${ctx.resumeCommand}`,
-      'Optional: add --probe when dataplane Copilot runtime routes are live on your environment.'
+      'Upload or sideload the generated appPackage.<env>.zip package artifact.',
+      'Review declarative agent + Remote MCP plugin details and approve tenant distribution.',
+      'Configure Entra/OAuth consent and user assignment for target groups.',
+      formatCredentialPortalStep(ctx, 'Copilot channel credential references (no secrets in package files)'),
+      'Verify Runtime MCP endpoint and Layer B tool visibility using INSTALL.md guidance.',
+      `After Copilot shows the package as available, re-run: ${ctx.resumeCommand}`,
+      'Optional: use --probe for AI Fabrix-side checks; tenant upload/approval remains Microsoft-admin responsibility.'
     ]
   };
 }

package/lib/channels/channel-artifact-generator.js

@@ -14,8 +14,10 @@ const path = require('path');
 const Handlebars = require('handlebars');
 const { getChannelTarget } = require('./channel-targets');
 const { BUILDER_ROOT } = require('./channel-integration-template');
+const { generateMicrosoftCopilotPackage } = require('./microsoft-copilot-package');
 
 const SECRET_PATTERNS = [/xoxb-/i, /xoxp-/i, /client_secret/i, /signing_secret/i, /Bearer\s+/i];
+const PLACEHOLDER_DOMAIN_RE = /\byour-domain\.com\b/i;
 
 /**
  * @param {string} content
@@ -27,7 +29,7 @@ function assertNoSecretsInArtifact(content) {
       throw new Error('Generated artifact must not contain secret-like values');
     }
   }
-  if (content.includes('your-domain.com')) {
+  if (PLACEHOLDER_DOMAIN_RE.test(content)) {
     throw new Error('Generated artifact still contains placeholder domain your-domain.com');
   }
 }
@@ -114,11 +116,22 @@ function renderInstallGuideIfPresent(templatesDir, runtimeValues, outputDir, dry
  */
 function generateChannelArtifact(params) {
   const templatesDir = getChannelTemplatesDir(params.channelTarget);
+  const outputPath = getArtifactOutputPath(params.projectRoot, params.channelTarget);
+
+  if (params.channelTarget === 'microsoft-copilot') {
+    return generateMicrosoftCopilotPackage({
+      runtimeValues: params.runtimeValues,
+      templatesDir,
+      outputPath,
+      dryRun: params.dryRun === true,
+      assertNoSecretsInArtifact,
+      renderTemplateFile
+    });
+  }
+
   const manifestTemplate = path.join(templatesDir, 'manifest.template.json.hbs');
   const content = renderTemplateFile(manifestTemplate, params.runtimeValues);
   assertNoSecretsInArtifact(content);
-
-  const outputPath = getArtifactOutputPath(params.projectRoot, params.channelTarget);
   const artifactHash = crypto.createHash('sha256').update(content, 'utf8').digest('hex');
   const outputDir = path.dirname(outputPath);
 

package/lib/channels/channel-credential.js

@@ -48,8 +48,10 @@ const CREDENTIAL_SPECS = {
     method: 'oauth2',
     credentialConfig: {
       type: 'oauth2',
-      grantType: 'client_credentials',
+      grantType: 'authorization_code',
+      authorizationUrl: 'https://login.microsoftonline.com/common/oauth2/v2.0/authorize',
       tokenUrl: 'https://login.microsoftonline.com/common/oauth2/v2.0/token',
+      scope: 'openid profile offline_access',
       clientId: 'pending-channel-install',
       clientSecret: 'pending-channel-install'
     }

package/lib/channels/channel-probe-evidence.js

@@ -0,0 +1,79 @@
+/**
+ * Probe BTA Evidence authoring reachability for channel installs (plan 163 T7).
+ *
+ * @fileoverview Evidence metadata/download live checks without mutating activate/upload
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const {
+  getEvidenceMetadata,
+  downloadEvidence
+} = require('../api/evidence-authoring.api');
+
+const EVIDENCE_AUTHORING_CAPABILITY_KEYS = Object.freeze([
+  'evidence.metadata',
+  'evidence.download',
+  'evidence.upload',
+  'evidence.activate'
+]);
+
+/**
+ * Prefer Business Transformation when present; otherwise first catalog role key.
+ *
+ * @param {Object[]} catalogItems
+ * @returns {string}
+ */
+function pickEvidenceRoleKey(catalogItems) {
+  const keys = (Array.isArray(catalogItems) ? catalogItems : [])
+    .map((item) => String(item?.key || item?.roleKey || item?.roleRef || '').trim())
+    .filter(Boolean);
+  const preferred = keys.find((key) => key.includes('business-transformation'));
+  return preferred || keys[0] || '';
+}
+
+/**
+ * Live metadata + download prove Evidence path; upload/activate remain contract keys.
+ *
+ * @async
+ * @param {Object} ctx
+ * @param {Object[]} catalogItems
+ * @returns {Promise<{ reachable: boolean, roleKey: string, capabilityKeys: string[] }>}
+ */
+async function probeEvidenceAuthoringReachable(ctx, catalogItems) {
+  const roleKey = pickEvidenceRoleKey(catalogItems);
+  const capabilityKeys = [...EVIDENCE_AUTHORING_CAPABILITY_KEYS];
+  if (!roleKey || !ctx?.dataplaneUrl || !ctx?.authConfig || !ctx?.controllerUrl) {
+    return { reachable: false, roleKey, capabilityKeys };
+  }
+  try {
+    const options = { controllerUrl: ctx.controllerUrl };
+    const metadata = await getEvidenceMetadata(
+      ctx.dataplaneUrl,
+      ctx.authConfig,
+      roleKey,
+      options
+    );
+    const downloaded = await downloadEvidence(
+      ctx.dataplaneUrl,
+      ctx.authConfig,
+      { roleKey, pageSize: 1 },
+      options
+    );
+    const reachable =
+      Boolean(metadata?.roleKey) &&
+      Array.isArray(metadata?.evidenceKinds) &&
+      Array.isArray(downloaded?.data);
+    return { reachable, roleKey, capabilityKeys };
+  } catch {
+    return { reachable: false, roleKey, capabilityKeys };
+  }
+}
+
+module.exports = {
+  EVIDENCE_AUTHORING_CAPABILITY_KEYS,
+  pickEvidenceRoleKey,
+  probeEvidenceAuthoringReachable
+};

package/lib/channels/channel-probe.js

@@ -8,8 +8,15 @@
 
 'use strict';
 
-const { ApiClient } = require('../api/index');
+const { ApiClient, createDataplaneApiClient } = require('../api/index');
 const { fetchDataplaneGeneralHealth } = require('../api/dataplane-health.api');
+const { resolveChannelRuntimeValues } = require('./channel-runtime-resolver');
+const {
+  fetchRuntimeLayerBToolNames,
+  isRuntimeMcpGatewayReachable
+} = require('./runtime-tool-catalog');
+const { probeEvidenceAuthoringReachable } = require('./channel-probe-evidence');
+const { RUNTIME_ORCHESTRATION_SYSTEM_KEY } = require('./chatgpt-runtime-contract');
 
 /**
  * @async
@@ -35,12 +42,48 @@ async function isUrlReachable(url) {
  * @returns {Promise<boolean>}
  */
 async function isAssistantCatalogReachable(dataplaneUrl, authConfig) {
-  const client = require('../api/index').createDataplaneApiClient(dataplaneUrl, authConfig);
+  const summary = await fetchAssistantCatalogSummary(dataplaneUrl, authConfig);
+  return summary.reachable;
+}
+
+/**
+ * @param {Object} response
+ * @returns {Object[]}
+ */
+function extractAssistantCatalogItems(response) {
+  const body = response?.data ?? response;
+  const data = body?.data ?? body;
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (Array.isArray(data?.items)) {
+    return data.items;
+  }
+  if (Array.isArray(data?.workers)) {
+    return data.workers;
+  }
+  if (Array.isArray(data?.assistants)) {
+    return data.assistants;
+  }
+  return [];
+}
+
+/**
+ * @async
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @returns {Promise<{ reachable: boolean, items: Object[] }>}
+ */
+async function fetchAssistantCatalogSummary(dataplaneUrl, authConfig) {
+  const client = createDataplaneApiClient(dataplaneUrl, authConfig);
   try {
     const res = await client.get('/api/v1/workers/available', { timeoutMs: 10000 });
-    return res && res.success !== false;
+    return {
+      reachable: Boolean(res && res.success !== false),
+      items: extractAssistantCatalogItems(res)
+    };
   } catch {
-    return false;
+    return { reachable: false, items: [] };
   }
 }
 
@@ -59,31 +102,240 @@ function evaluateInboundVerification(channelExt) {
 }
 
 /**
- * @async
  * @param {Object} ctx
  * @param {Object|null} channelExt
- * @returns {Promise<Object>}
+ * @param {boolean} catalogOk
+ * @param {string[]} layerBToolNames
+ * @param {Object[]} [catalogItems]
+ * @returns {Promise<{ probeTiers: Object, runtimeChecks: Object, evidenceCapabilityKeys?: string[] }>}
  */
-async function runChannelProbe(ctx, channelExt) {
-  const health = await fetchDataplaneGeneralHealth(ctx.dataplaneUrl, { timeoutMs: 8000 });
-  const catalogOk = await isAssistantCatalogReachable(ctx.dataplaneUrl, ctx.authConfig);
-  const callbackOk = health?.status === 'healthy' || health?.status === 'ok';
+/**
+ * @param {Object|null} channelExt
+ * @param {Object} runtime
+ * @param {Object} runtimeChecks
+ * @param {Object} evidence
+ * @returns {Object}
+ */
+function buildChatGptProbePayload(channelExt, runtime, runtimeChecks, evidence) {
+  return {
+    probeTiers: {
+      locallyValidated: Boolean(
+        channelExt?.credentialKey &&
+          channelExt?.artifactHash &&
+          runtime.mcpUrl &&
+          !runtime.mcpUrl.includes('/api/v1/chatgpt/')
+      ),
+      runtimeValidated: Object.values(runtimeChecks).every(Boolean),
+      requiresChatGptWorkspaceAdmin: true
+    },
+    runtimeChecks,
+    evidenceCapabilityKeys: evidence.capabilityKeys,
+    evidenceRoleKey: evidence.roleKey
+  };
+}
 
-  const inbound = evaluateInboundVerification(channelExt);
+/**
+ * @param {Object} ctx
+ * @param {Object|null} channelExt
+ * @param {boolean} catalogOk
+ * @param {string[]} layerBToolNames
+ * @param {Object[]} [catalogItems]
+ * @returns {Promise<{ probeTiers: Object, runtimeChecks: Object, evidenceCapabilityKeys?: string[] }>}
+ */
+async function buildChatGptProbeDetails(
+  ctx,
+  channelExt,
+  catalogOk,
+  layerBToolNames,
+  catalogItems = []
+) {
+  const runtime = resolveChannelRuntimeValues({
+    dataplaneBaseUrl: ctx.dataplaneUrl,
+    channelTarget: 'chatgpt',
+    appName: channelExt?.name || 'chatgpt',
+    baseName: channelExt?.baseName || channelExt?.name || 'chatgpt',
+    appDescription: channelExt?.description || 'ChatGPT custom MCP app',
+    layerBToolNames
+  });
+  const mcpHandshakeReachable = await isRuntimeMcpGatewayReachable(
+    ctx.dataplaneUrl,
+    ctx.authConfig,
+    RUNTIME_ORCHESTRATION_SYSTEM_KEY
+  );
+  const evidence = await probeEvidenceAuthoringReachable(ctx, catalogItems);
+  const runtimeChecks = {
+    mcpHandshakeReachable,
+    layerBToolNamesDiscovered: Array.isArray(layerBToolNames) && layerBToolNames.length > 0,
+    roleAssistantResolutionReachable: catalogOk,
+    tenantEnvironmentBoundaryConfirmed: Boolean(ctx.environment || channelExt?.name),
+    evidenceAuthoringReachable: evidence.reachable
+  };
+  return buildChatGptProbePayload(channelExt, runtime, runtimeChecks, evidence);
+}
 
+/**
+ * @param {Object} ctx
+ * @param {Object|null} channelExt
+ * @param {boolean} catalogOk
+ * @param {string[]} layerBToolNames
+ * @returns {Promise<{ probeTiers: Object, runtimeChecks: Object }>}
+ */
+async function buildMicrosoftCopilotProbeDetails(ctx, channelExt, catalogOk, layerBToolNames) {
+  const runtime = resolveChannelRuntimeValues({
+    dataplaneBaseUrl: ctx.dataplaneUrl,
+    channelTarget: 'microsoft-copilot',
+    appName: channelExt?.name || 'microsoft-copilot',
+    baseName: channelExt?.baseName || channelExt?.name || 'microsoft-copilot',
+    appDescription: channelExt?.description || 'Microsoft Copilot package channel',
+    layerBToolNames
+  });
+  const mcpHandshakeReachable = await isRuntimeMcpGatewayReachable(
+    ctx.dataplaneUrl,
+    ctx.authConfig,
+    RUNTIME_ORCHESTRATION_SYSTEM_KEY
+  );
+  const runtimeChecks = {
+    mcpHandshakeReachable,
+    layerBToolNamesDiscovered: Array.isArray(layerBToolNames) && layerBToolNames.length > 0,
+    authMetadataConfigured: Boolean(runtime.runtimeAuthMode && channelExt?.credentialKey),
+    roleAssistantResolutionReachable: catalogOk,
+    tenantEnvironmentBoundaryConfirmed: Boolean(ctx.environment || channelExt?.name)
+  };
+  return {
+    probeTiers: {
+      builderValidated: Boolean(
+        channelExt?.credentialKey &&
+          channelExt?.artifactHash &&
+          runtime.mcpUrl &&
+          !runtime.mcpUrl.includes('/api/v1/copilot/')
+      ),
+      runtimeValidated: Object.values(runtimeChecks).every(Boolean),
+      requiresMicrosoftAdmin: true
+    },
+    runtimeChecks
+  };
+}
+
+/**
+ * @param {Object} health
+ * @param {boolean} callbackOk
+ * @param {boolean} catalogOk
+ * @param {Object|null} channelExt
+ * @param {Object} inbound
+ * @returns {Object}
+ */
+function buildBaseProbeResult(health, callbackOk, catalogOk, channelExt, inbound) {
   return {
     dataplaneHealth: health?.status || 'unknown',
     callbackReachable: callbackOk,
     assistantCatalogReachable: catalogOk,
     credentialValid: Boolean(channelExt?.credentialKey),
-    inboundVerification: inbound,
-    passed: callbackOk && catalogOk && Boolean(channelExt?.credentialKey)
+    inboundVerification: inbound
   };
 }
 
+/**
+ * @param {Object} base
+ * @param {Object} probe
+ * @param {Object|null} channelExt
+ * @returns {Object}
+ */
+function buildCopilotProbeResult(base, probe, channelExt) {
+  return {
+    ...base,
+    ...probe,
+    expectedLayerBToolNames: [...(probe.discoveredLayerBToolNames || [])],
+    passed:
+      probe.probeTiers.builderValidated &&
+      probe.probeTiers.runtimeValidated &&
+      Boolean(channelExt?.credentialKey)
+  };
+}
+
+/**
+ * @param {Object} base
+ * @param {Object} probe
+ * @param {Object|null} channelExt
+ * @returns {Object}
+ */
+function buildChatGptProbeResult(base, probe, channelExt) {
+  return {
+    ...base,
+    ...probe,
+    expectedLayerBToolNames: [...(probe.discoveredLayerBToolNames || [])],
+    passed:
+      probe.probeTiers.locallyValidated &&
+      probe.probeTiers.runtimeValidated &&
+      Boolean(channelExt?.credentialKey)
+  };
+}
+
+/**
+ * @async
+ * @param {Object} ctx
+ * @param {Object|null} channelExt
+ * @returns {Promise<Object>}
+ */
+async function runChannelProbe(ctx, channelExt) {
+  const health = await fetchDataplaneGeneralHealth(ctx.dataplaneUrl, { timeoutMs: 8000 });
+  const catalog = await fetchAssistantCatalogSummary(ctx.dataplaneUrl, ctx.authConfig);
+  const catalogOk = catalog.reachable;
+  const callbackOk = health?.status === 'healthy' || health?.status === 'ok';
+  const inbound = evaluateInboundVerification(channelExt);
+  const base = buildBaseProbeResult(health, callbackOk, catalogOk, channelExt, inbound);
+
+  if (channelExt?.type !== 'chatgpt' && channelExt?.type !== 'microsoftCopilot') {
+    return {
+      ...base,
+      passed: callbackOk && catalogOk && Boolean(channelExt?.credentialKey)
+    };
+  }
+
+  const channelTarget = channelExt?.type === 'chatgpt' ? 'chatgpt' : 'microsoft-copilot';
+  const layerBToolNames = await fetchRuntimeLayerBToolNames(
+    ctx.dataplaneUrl,
+    ctx.authConfig,
+    channelTarget
+  );
+
+  if (channelExt?.type === 'microsoftCopilot') {
+    const copilotProbe = await buildMicrosoftCopilotProbeDetails(
+      ctx,
+      channelExt,
+      catalogOk,
+      layerBToolNames
+    );
+    return buildCopilotProbeResult(
+      base,
+      { ...copilotProbe, discoveredLayerBToolNames: layerBToolNames },
+      channelExt
+    );
+  }
+
+  const chatgptProbe = await buildChatGptProbeDetails(
+    ctx,
+    channelExt,
+    catalogOk,
+    layerBToolNames,
+    catalog.items
+  );
+  return buildChatGptProbeResult(
+    base,
+    { ...chatgptProbe, discoveredLayerBToolNames: layerBToolNames },
+    channelExt
+  );
+}
+
 module.exports = {
   isUrlReachable,
   isAssistantCatalogReachable,
+  extractAssistantCatalogItems,
+  fetchAssistantCatalogSummary,
   evaluateInboundVerification,
+  buildChatGptProbeDetails,
+  buildMicrosoftCopilotProbeDetails,
+  buildBaseProbeResult,
+  buildCopilotProbeResult,
+  buildChatGptProbeResult,
   runChannelProbe
 };