ActivateFunctionGroup

Instructions

Implementation Reference

• src/handlers/function/low/handleActivateFunctionGroup.ts:65-179 (handler)

  Main handler function for ActivateFunctionGroup MCP tool. Takes a function_group_name, optional session_id/session_state, creates an ADT client, calls activate() on the function group, parses the activation response, and returns success/error info with messages.

  export async function handleActivateFunctionGroup(
    context: HandlerContext,
    args: ActivateFunctionGroupArgs,
  ) {
    const { connection, logger } = context;
    try {
      const { function_group_name, session_id, session_state } =
        args as ActivateFunctionGroupArgs;
  
      // Validation
      if (!function_group_name) {
        return return_error(new Error('function_group_name is required'));
      }
  
      const client = createAdtClient(connection, logger);
      // Restore session state if provided
      if (session_id && session_state) {
        await restoreSessionInConnection(connection, session_id, session_state);
      } else {
        // Ensure connection is established
      }
  
      const functionGroupName = function_group_name.toUpperCase();
  
      logger?.info(`Starting function group activation: ${functionGroupName}`);
  
      try {
        // Activate function group
        const activateState = await client.getFunctionGroup().activate({
          functionGroupName: functionGroupName,
        });
        const response = activateState.activateResult;
  
        if (!response) {
          throw new Error(
            `Activation did not return a response for function group ${functionGroupName}`,
          );
        }
  
        // Parse activation response
        const activationResult = parseActivationResponse(response.data);
        const success = activationResult.activated && activationResult.checked;
  
        // Get updated session state after activation
  
        logger?.info(`✅ ActivateFunctionGroup completed: ${functionGroupName}`);
        logger?.debug(
          `Activated: ${activationResult.activated}, Checked: ${activationResult.checked}, Messages: ${activationResult.messages.length}`,
        );
  
        return return_response({
          data: JSON.stringify(
            {
              success,
              function_group_name: functionGroupName,
              activation: {
                activated: activationResult.activated,
                checked: activationResult.checked,
                generated: activationResult.generated,
              },
              messages: activationResult.messages,
              warnings: activationResult.messages.filter(
                (m) => m.type === 'warning' || m.type === 'W',
              ),
              errors: activationResult.messages.filter(
                (m) => m.type === 'error' || m.type === 'E',
              ),
              session_id: session_id || null,
              session_state: null, // Session state management is now handled by auth-broker,
              message: success
                ? `Function group ${functionGroupName} activated successfully`
                : `Function group ${functionGroupName} activation completed with ${activationResult.messages.length} message(s)`,
            },
            null,
            2,
          ),
        } as AxiosResponse);
      } catch (error: any) {
        logger?.error(
          `Error activating function group ${functionGroupName}: ${error?.message || error}`,
        );
  
        // Parse error message
        let errorMessage = `Failed to activate function group: ${error.message || String(error)}`;
  
        if (error.response?.status === 404) {
          errorMessage = `Function group ${functionGroupName} not found.`;
        } else if (
          error.response?.data &&
          typeof error.response.data === 'string'
        ) {
          try {
            const { XMLParser } = require('fast-xml-parser');
            const parser = new XMLParser({
              ignoreAttributes: false,
              attributeNamePrefix: '@_',
            });
            const errorData = parser.parse(error.response.data);
            const errorMsg =
              errorData['exc:exception']?.message?.['#text'] ||
              errorData['exc:exception']?.message;
            if (errorMsg) {
              errorMessage = `SAP Error: ${errorMsg}`;
            }
          } catch (_parseError) {
            // Ignore parse errors
          }
        }
  
        return return_error(new Error(errorMessage));
      }
    } catch (error: any) {
      return return_error(error);
    }
  }

• src/handlers/function/low/handleActivateFunctionGroup.ts:18-48 (schema)

  Low-level tool definition (input schema) for ActivateFunctionGroup. Defines the tool name as 'ActivateFunctionGroupLow' with input parameters including function_group_name (required), session_id (optional), and session_state (optional).

  export const TOOL_DEFINITION = {
    name: 'ActivateFunctionGroupLow',
    available_in: ['onprem', 'cloud', 'legacy'] as const,
    description:
      '[low-level] Activate an ABAP function group. Returns activation status and any warnings/errors. Can use session_id and session_state from GetSession to maintain the same session.',
    inputSchema: {
      type: 'object',
      properties: {
        function_group_name: {
          type: 'string',
          description: 'Function group name (e.g., Z_FG_TEST).',
        },
        session_id: {
          type: 'string',
          description:
            'Session ID from GetSession. If not provided, a new session will be created.',
        },
        session_state: {
          type: 'object',
          description:
            'Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.',
          properties: {
            cookies: { type: 'string' },
            csrf_token: { type: 'string' },
            cookie_store: { type: 'object' },
          },
        },
      },
      required: ['function_group_name'],
    },
  } as const;

• src/handlers/function/low/handleActivateFunctionGroup.ts:50-58 (schema)

  TypeScript interface for ActivateFunctionGroup arguments, mirroring the inputSchema with typed fields for function_group_name, session_id, and session_state.

  interface ActivateFunctionGroupArgs {
    function_group_name: string;
    session_id?: string;
    session_state?: {
      cookies?: string;
      csrf_token?: string;
      cookie_store?: Record<string, string>;
    };
  }

• src/lib/handlers/groups/HighLevelHandlersGroup.ts:584-592 (registration)

  Registration of the ActivateFunctionGroup tool within the HighLevelHandlersGroup. The low-level TOOL_DEFINITION is spread (renamed from 'ActivateFunctionGroupLow' to 'ActivateFunctionGroup') and the handler is wrapped with withContext().

  {
    toolDefinition: {
      ...ActivateFunctionGroup_Tool,
      name: 'ActivateFunctionGroup',
      description:
        'Activate an ABAP function group. Use after CreateFunctionGroup or UpdateFunctionGroup if the object remains inactive.',
    },
    handler: withContext(handleActivateFunctionGroup),
  },

• src/lib/handlers/groups/HighLevelHandlersGroup.ts:206-209 (registration)

  Import statement bringing in the low-level tool definition (aliased as ActivateFunctionGroup_Tool) and the handleActivateFunctionGroup handler from the implementation file.

  import {
    TOOL_DEFINITION as ActivateFunctionGroup_Tool,
    handleActivateFunctionGroup,
  } from '../../../handlers/function/low/handleActivateFunctionGroup';