getv2callsbyid

Instructions

Implementation Reference

• src/index.ts:60-69 (registration)

  Registration of the 'getv2callsbyid' tool definition, including name, description, input schema, HTTP method (GET), path template (/v2/calls/{id}), parameters, and security (basicAuth).

  ["getv2callsbyid", {
    name: "getv2callsbyid",
    description: `Retrieve a single call`,
    inputSchema: {"type":"object","properties":{"id":{"type":"string"}},"required":["id"]},
    method: "get",
    pathTemplate: "/v2/calls/{id}",
    executionParameters: [{"name":"id","in":"path"}],
    requestBodyContentType: undefined,
    securityRequirements: [{"basicAuth":[]}]
  }],

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

  Generic handler that implements the tool logic for ALL tools (including 'getv2callsbyid') by validating inputs with Zod, constructing the API URL/path/query/body based on tool definition, adding Basic Auth credentials from environment variables, proxying the request to Gong API via axios, and returning 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:63-63 (schema)

  Input schema definition for 'getv2callsbyid': an object requiring a single 'id' property of type string (used for path parameter). Converted to Zod schema at runtime for validation.

  inputSchema: {"type":"object","properties":{"id":{"type":"string"}},"required":["id"]},

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

  Helper function to convert the tool's JSON inputSchema to a Zod schema for runtime validation before executing the API call.

  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();
      }
  }

• src/index.ts:143-151 (registration)

  MCP server request handler registration for tool calls (CallToolRequestSchema). Looks up tool by name from toolDefinitionMap 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);
  });