postv2callsextensive

Instructions

Implementation Reference

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

  Generic handler function that executes all API tools, including 'postv2callsextensive'. Validates tool arguments using a Zod schema derived from the tool's inputSchema, constructs the API request URL for POST /v2/calls/extensive, adds Basic Auth header using GONG_ACCESS_KEY and GONG_SECRET environment variables, sends the requestBody as JSON, and returns the API response as formatted JSON text.

  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:70-79 (registration)

  Tool registration in the toolDefinitionMap. Specifies the tool name, description, input JSON schema (requiring requestBody with filter, contentSelector, cursor), POST method, path template "/v2/calls/extensive", JSON request body, and basicAuth security.

  ["postv2callsextensive", {
    name: "postv2callsextensive",
    description: `Filtered call list with rich payload`,
    inputSchema: {"type":"object","properties":{"requestBody":{"type":"object","required":["filter"],"properties":{"filter":{"type":"object","properties":{"fromDateTime":{"type":"string","format":"date-time"},"toDateTime":{"type":"string","format":"date-time"},"callIds":{"type":"array","items":{"type":"string"}},"primaryUserIds":{"type":"array","items":{"type":"string"}},"participantsEmails":{"type":"array","items":{"type":"string","format":"email"}}}},"contentSelector":{"type":"object","properties":{"context":{"type":"string","enum":["None","Extended"]},"contextTiming":{"type":"array","items":{"type":"string","enum":["Now","TimeOfCall"]}},"exposedFields":{"type":"object","additionalProperties":{"type":"object"}}}},"cursor":{"type":"string"}},"description":"The JSON request body."}},"required":["requestBody"]},
    method: "post",
    pathTemplate: "/v2/calls/extensive",
    executionParameters: [],
    requestBodyContentType: "application/json",
    securityRequirements: [{"basicAuth":[]}]
  }],

• src/index.ts:73-79 (schema)

  JSON input schema for the tool, defining the structure of the requestBody parameter (with filter for date range, call/participant IDs/emails, contentSelector for context and fields, and cursor for pagination).

    inputSchema: {"type":"object","properties":{"requestBody":{"type":"object","required":["filter"],"properties":{"filter":{"type":"object","properties":{"fromDateTime":{"type":"string","format":"date-time"},"toDateTime":{"type":"string","format":"date-time"},"callIds":{"type":"array","items":{"type":"string"}},"primaryUserIds":{"type":"array","items":{"type":"string"}},"participantsEmails":{"type":"array","items":{"type":"string","format":"email"}}}},"contentSelector":{"type":"object","properties":{"context":{"type":"string","enum":["None","Extended"]},"contextTiming":{"type":"array","items":{"type":"string","enum":["Now","TimeOfCall"]}},"exposedFields":{"type":"object","additionalProperties":{"type":"object"}}}},"cursor":{"type":"string"}},"description":"The JSON request body."}},"required":["requestBody"]},
    method: "post",
    pathTemplate: "/v2/calls/extensive",
    executionParameters: [],
    requestBodyContentType: "application/json",
    securityRequirements: [{"basicAuth":[]}]
  }],

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

  Helper function that converts the tool's JSON inputSchema to a runtime Zod schema using json-schema-to-zod library and eval, used for input 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();
      }
  }

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

  MCP server dispatcher for tool calls: retrieves tool definition from map by name and delegates 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);
  });