gong-mcp

Instructions

Implementation Reference

• src/index.ts:90-99 (registration)

  Registration of the 'getv2users' tool in the toolDefinitionMap. Includes name, description, input schema for optional 'cursor' parameter, GET method, path '/v2/users', query parameter mapping, and basicAuth security.

  ["getv2users", {
    name: "getv2users",
    description: `List Gong users (100-row pages)`,
    inputSchema: {"type":"object","properties":{"cursor":{"type":"string"}}},
    method: "get",
    pathTemplate: "/v2/users",
    executionParameters: [{"name":"cursor","in":"query"}],
    requestBodyContentType: undefined,
    securityRequirements: [{"basicAuth":[]}]
  }],

• src/index.ts:93-93 (schema)

  Input schema for 'getv2users' tool: an object with optional 'cursor' string property.

  inputSchema: {"type":"object","properties":{"cursor":{"type":"string"}}},

• src/index.ts:273-382 (handler)

  Generic handler function that implements the logic for all tools, including 'getv2users'. Parses input schema to Zod for validation, constructs API URL (https://api.gong.io/v2/users?cursor=...), authenticates with Basic Auth, calls Gong API via axios, and returns the JSON response.

  async function executeApiTool(
      toolName: string,
      definition: McpToolDefinition,
      toolArgs: JsonObject,
      allSecuritySchemes: Record<string, any>
  ): Promise<CallToolResult> {
      try {
          // Validate input arguments using Zod
          const zodSchema = getZodSchemaFromJsonSchema(definition.inputSchema, toolName);
          const validatedArgs = zodSchema.parse(toolArgs);
  
          // Build the request URL
          let url = API_BASE_URL + definition.pathTemplate;
          
          // Replace path parameters
          for (const param of definition.executionParameters) {
              if (param.in === 'path') {
                  const value = validatedArgs[param.name];
                  if (value !== undefined) {
                      url = url.replace(`{${param.name}}`, encodeURIComponent(value));
                  }
              }
          }
  
          // Build query parameters
          const queryParams: Record<string, string> = {};
          for (const param of definition.executionParameters) {
              if (param.in === 'query') {
                  const value = validatedArgs[param.name];
                  if (value !== undefined) {
                      queryParams[param.name] = value;
                  }
              }
          }
          
          if (Object.keys(queryParams).length > 0) {
              url += '?' + new URLSearchParams(queryParams).toString();
          }
  
          // Debug logging (safe)
          console.error('Debug - Making API request to:', url);
          
          // Get credentials from environment
          const accessKey = process.env.GONG_ACCESS_KEY || '';
          const secret = process.env.GONG_SECRET || '';
          
          if (!accessKey || !secret) {
              throw new Error('Missing Gong credentials in environment');
          }
          
          // Create authorization header
          const authHeader = `Basic ${Buffer.from(`${accessKey}:${secret}`).toString('base64')}`;
          
          // Build request config
          const config: AxiosRequestConfig = {
              method: definition.method,
              url,
              headers: {
                  'Accept': 'application/json',
                  'Authorization': authHeader
              }
          };
  
          // Add request body if needed
          if (definition.requestBodyContentType) {
              config.headers!['Content-Type'] = definition.requestBodyContentType;
              if (validatedArgs.requestBody) {
                  config.data = validatedArgs.requestBody;
              }
          }
  
          // Make the request
          const response = await axios(config);
          
          return {
              content: [
                  {
                      type: 'text',
                      text: JSON.stringify(response.data, null, 2)
                  }
              ]
          };
  
      } catch (error: any) {
          if (error instanceof ZodError) {
              return {
                  content: [{
                      type: 'text',
                      text: `Validation error: ${error.message}`
                  }]
              };
          }
          
          if (axios.isAxiosError(error)) {
              return {
                  content: [{
                      type: 'text',
                      text: formatApiError(error)
                  }]
              };
          }
  
          return {
              content: [{
                  type: 'text',
                  text: `Unexpected error: ${error.message}`
              }]
          };
      }
  }

• src/index.ts:142-151 (handler)

  MCP server request handler for tool calls. Retrieves tool definition by name ('getv2users') and dispatches to executeApiTool.

  server.setRequestHandler(CallToolRequestSchema, async (request: CallToolRequest): Promise<CallToolResult> => {
    const { name: toolName, arguments: toolArgs } = request.params;
    const toolDefinition = toolDefinitionMap.get(toolName);
    if (!toolDefinition) {
      console.error(`Error: Unknown tool requested: ${toolName}`);
      return { content: [{ type: "text", text: `Error: Unknown tool requested: ${toolName}` }] };
    }
    return await executeApiTool(toolName, toolDefinition, toolArgs ?? {}, securitySchemes);
  });

• src/index.ts:462-477 (helper)

  Helper function to convert the tool's JSON inputSchema to a Zod schema for runtime validation in the handler.

  function getZodSchemaFromJsonSchema(jsonSchema: any, toolName: string): z.ZodTypeAny {
      if (typeof jsonSchema !== 'object' || jsonSchema === null) { 
          return z.object({}).passthrough(); 
      }
      try {
          const zodSchemaString = jsonSchemaToZod(jsonSchema);
          const zodSchema = eval(zodSchemaString);
          if (typeof zodSchema?.parse !== 'function') { 
              throw new Error('Eval did not produce a valid Zod schema.'); 
          }
          return zodSchema as z.ZodTypeAny;
      } catch (err: any) {
          console.error(`Failed to generate/evaluate Zod schema for '${toolName}':`, err);
          return z.object({}).passthrough();
      }
  }