feat(standard): Hide Code Interpreter toggle in Standard agent loop behind FF (#8894)

* hide behind ff

* test: Add unit tests for Code Interpreter Standard feature flag and manifest

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: Elaina-Lee

libs/designer-v2/src/lib/core/utils/experimentation.ts

@@ -1,4 +1,4 @@
-import { enableAPIMGatewayConnection, enableCodeInterpreterConsumption } from '@microsoft/logic-apps-shared';
+import { enableAPIMGatewayConnection, enableCodeInterpreterConsumption, enableCodeInterpreterStandard } from '@microsoft/logic-apps-shared';
 import { useEffect, useState } from 'react';
 
 export function useShouldEnableAPIMGatewayConnection(): boolean | null {
@@ -28,3 +28,17 @@ export function useShouldEnableCodeInterpreterConsumption(): boolean | null {
 
   return enabled;
 }
+
+export function useShouldEnableCodeInterpreterStandard(): boolean | null {
+  const [enabled, setEnabled] = useState<boolean | null>(null);
+
+  useEffect(() => {
+    const check = async () => {
+      const result = await enableCodeInterpreterStandard();
+      setEnabled(result);
+    };
+    check();
+  }, []);
+
+  return enabled;
+}

libs/logic-apps-shared/src/designer-client-services/lib/__test__/experimentationFlags.spec.ts

@@ -0,0 +1,65 @@
+import { describe, vi, beforeEach, it, expect } from 'vitest';
+import { InitExperimentationServiceService } from '../experimentation';
+import {
+  enableAPIMGatewayConnection,
+  enableCodeInterpreterConsumption,
+  enableCodeInterpreterStandard,
+  EXP_FLAGS,
+} from '../experimentationFlags';
+
+describe('lib/designer-client-services/experimentationFlags', () => {
+  let mockIsFeatureEnabled: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    mockIsFeatureEnabled = vi.fn();
+    InitExperimentationServiceService({
+      isFeatureEnabled: mockIsFeatureEnabled,
+      getFeatureValue: vi.fn(),
+    });
+  });
+
+  describe('enableAPIMGatewayConnection', () => {
+    it('should return true when feature flag is enabled', async () => {
+      mockIsFeatureEnabled.mockResolvedValue(true);
+      const result = await enableAPIMGatewayConnection();
+      expect(result).toBe(true);
+      expect(mockIsFeatureEnabled).toHaveBeenCalledWith(EXP_FLAGS.ENABLE_APIM_GEN_AI_GATEWAY);
+    });
+
+    it('should return false when feature flag is disabled', async () => {
+      mockIsFeatureEnabled.mockResolvedValue(false);
+      const result = await enableAPIMGatewayConnection();
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('enableCodeInterpreterConsumption', () => {
+    it('should return true when feature flag is enabled', async () => {
+      mockIsFeatureEnabled.mockResolvedValue(true);
+      const result = await enableCodeInterpreterConsumption();
+      expect(result).toBe(true);
+      expect(mockIsFeatureEnabled).toHaveBeenCalledWith(EXP_FLAGS.ENABLE_CODE_INTERPRETER_CONSUMPTION);
+    });
+
+    it('should return false when feature flag is disabled', async () => {
+      mockIsFeatureEnabled.mockResolvedValue(false);
+      const result = await enableCodeInterpreterConsumption();
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('enableCodeInterpreterStandard', () => {
+    it('should return true when feature flag is enabled', async () => {
+      mockIsFeatureEnabled.mockResolvedValue(true);
+      const result = await enableCodeInterpreterStandard();
+      expect(result).toBe(true);
+      expect(mockIsFeatureEnabled).toHaveBeenCalledWith(EXP_FLAGS.ENABLE_CODE_INTERPRETER_STANDARD);
+    });
+
+    it('should return false when feature flag is disabled', async () => {
+      mockIsFeatureEnabled.mockResolvedValue(false);
+      const result = await enableCodeInterpreterStandard();
+      expect(result).toBe(false);
+    });
+  });
+});

libs/logic-apps-shared/src/designer-client-services/lib/__test__/standardOperationManifest.spec.ts

@@ -0,0 +1,59 @@
+import { describe, vi, beforeEach, it, expect } from 'vitest';
+import { InitExperimentationServiceService } from '../experimentation';
+import { StandardOperationManifestService } from '../standard/operationmanifest';
+import { agentType, supportedBaseManifestObjects } from '../base/operationmanifest';
+
+describe('StandardOperationManifestService', () => {
+  let mockIsFeatureEnabled: ReturnType<typeof vi.fn>;
+  let service: StandardOperationManifestService;
+
+  beforeEach(() => {
+    mockIsFeatureEnabled = vi.fn();
+    InitExperimentationServiceService({
+      isFeatureEnabled: mockIsFeatureEnabled,
+      getFeatureValue: vi.fn(),
+    });
+    service = new StandardOperationManifestService({
+      apiVersion: '2024-02-01',
+      baseUrl: 'https://test.azure.com',
+      httpClient: { get: vi.fn(), post: vi.fn(), put: vi.fn(), delete: vi.fn() } as any,
+    });
+  });
+
+  describe('getOperationManifest for agent type', () => {
+    it('should return manifest without builtinTools when code interpreter flag is disabled', async () => {
+      mockIsFeatureEnabled.mockResolvedValue(false);
+
+      const manifest = await service.getOperationManifest('connectorId', agentType);
+
+      const agentChatCompletionSettings = (manifest.properties?.inputs?.properties as any)?.agentModelSettings?.properties
+        ?.agentChatCompletionSettings?.properties;
+
+      expect(agentChatCompletionSettings?.builtinTools).toBeUndefined();
+    });
+
+    it('should return manifest with builtinTools when code interpreter flag is enabled', async () => {
+      mockIsFeatureEnabled.mockResolvedValue(true);
+
+      const manifest = await service.getOperationManifest('connectorId', agentType);
+
+      const agentChatCompletionSettings = (manifest.properties?.inputs?.properties as any)?.agentModelSettings?.properties
+        ?.agentChatCompletionSettings?.properties;
+
+      expect(agentChatCompletionSettings?.builtinTools).toBeDefined();
+    });
+
+    it('should not mutate the original manifest when stripping builtinTools', async () => {
+      mockIsFeatureEnabled.mockResolvedValue(false);
+
+      await service.getOperationManifest('connectorId', agentType);
+
+      // Verify the original manifest in supportedBaseManifestObjects is untouched
+      const originalManifest = supportedBaseManifestObjects.get(agentType);
+      const originalBuiltinTools = (originalManifest?.properties?.inputs?.properties as any)?.agentModelSettings?.properties
+        ?.agentChatCompletionSettings?.properties?.builtinTools;
+
+      expect(originalBuiltinTools).toBeDefined();
+    });
+  });
+});

libs/logic-apps-shared/src/designer-client-services/lib/experimentationFlags.ts

@@ -3,6 +3,7 @@ import { ExperimentationService } from './experimentation';
 export const EXP_FLAGS = {
   ENABLE_APIM_GEN_AI_GATEWAY: 'enable-apim-gen-ai-gateway',
   ENABLE_CODE_INTERPRETER_CONSUMPTION: 'enable-code-interpreter-consumption',
+  ENABLE_CODE_INTERPRETER_STANDARD: 'enable-code-interpreter-standard',
 };
 
 export async function enableAPIMGatewayConnection(): Promise<boolean> {
@@ -12,3 +13,7 @@ export async function enableAPIMGatewayConnection(): Promise<boolean> {
 export async function enableCodeInterpreterConsumption(): Promise<boolean> {
   return ExperimentationService().isFeatureEnabled(EXP_FLAGS.ENABLE_CODE_INTERPRETER_CONSUMPTION);
 }
+
+export async function enableCodeInterpreterStandard(): Promise<boolean> {
+  return ExperimentationService().isFeatureEnabled(EXP_FLAGS.ENABLE_CODE_INTERPRETER_STANDARD);
+}

libs/logic-apps-shared/src/designer-client-services/lib/standard/operationmanifest.ts

@@ -1,8 +1,15 @@
 import type { Connector, OperationInfo, OperationManifest } from '../../../utils/src';
 import { ConnectionType, equals } from '../../../utils/src';
+import { enableCodeInterpreterStandard } from '../experimentationFlags';
 import { BaseOperationManifestService } from '../base';
 import type { BaseOperationManifestServiceOptions } from '../base/operationmanifest';
-import { getBuiltInOperationInfo, isBuiltInOperation, mcpclientConnectorId, supportedBaseManifestObjects } from '../base/operationmanifest';
+import {
+  agentType,
+  getBuiltInOperationInfo,
+  isBuiltInOperation,
+  mcpclientConnectorId,
+  supportedBaseManifestObjects,
+} from '../base/operationmanifest';
 import { getHybridAppBaseRelativeUrl, hybridApiVersion, isHybridLogicApp } from './hybrid';
 import { getClientBuiltInConnectors } from '../base/search';
 import { aiOperationsGroup } from './operations/operationgroups';
@@ -154,6 +161,15 @@ export class StandardOperationManifestService extends BaseOperationManifestServi
   override async getOperationManifest(connectorId: string, operationId: string): Promise<OperationManifest> {
     const supportedManifest = supportedBaseManifestObjects.get(operationId);
     if (supportedManifest) {
+      if (operationId === agentType) {
+        const isCodeInterpreterEnabled = await enableCodeInterpreterStandard();
+        if (!isCodeInterpreterEnabled) {
+          const manifest: OperationManifest = JSON.parse(JSON.stringify(supportedManifest));
+          delete (manifest.properties?.inputs?.properties as any)?.agentModelSettings?.properties?.agentChatCompletionSettings?.properties
+            ?.builtinTools;
+          return manifest;
+        }
+      }
       return supportedManifest;
     }