get_team_schedule

Instructions

Implementation Reference

• src/index.js:83-97 (schema)

  Tool definition with inputSchema (type, properties: sport, slug, limit) and paramMap for the 'get_team_schedule' tool. Maps to endpoint /api/widget/team/.

  {
    name: "get_team_schedule",
    description:
      "Get a team's past and upcoming fixtures by team slug (e.g. 'barcelona', 'manchester-united', 'los-angeles-lakers').",
    inputSchema: {
      type: "object",
      properties: {
        sport: sportSchema,
        slug: { type: "string", description: "Team slug." },
        limit: { type: "integer", minimum: 1, maximum: 30, default: 10 },
      },
      required: ["sport", "slug"],
    },
    path: "/api/widget/team/",
    paramMap: (args) => ({ sport: args.sport, slug: args.slug, limit: args.limit ?? 10 }),

• src/index.js:183-183 (registration)

  Tool lookup map (TOOL_BY_NAME) built from the TOOLS array, enabling dispatch by tool name including 'get_team_schedule'.

  const TOOL_BY_NAME = new Map(TOOLS.map((t) => [t.name, t]));

• src/index.js:228-270 (handler)

  The generic CallToolRequestSchema handler that dispatches all tools. When 'get_team_schedule' is called, it looks up the tool definition from TOOL_BY_NAME, calls tool.paramMap(args) to build query params, then calls callApi('/api/widget/team/', params) to fetch data from the SportScore API.

  server.setRequestHandler(CallToolRequestSchema, async (req) => {
    const { name, arguments: rawArgs } = req.params;
    const tool = TOOL_BY_NAME.get(name);
    if (!tool) {
      return {
        isError: true,
        content: [{ type: "text", text: `Unknown tool: ${name}` }],
      };
    }
    const args = rawArgs ?? {};
    if (args.sport && !SPORTS.includes(args.sport)) {
      return {
        isError: true,
        content: [
          { type: "text", text: `Invalid sport '${args.sport}'. Must be one of: ${SPORTS.join(", ")}.` },
        ],
      };
    }
  
    const params = tool.paramMap(args);
    let result;
    try {
      result = await callApi(tool.path, params);
    } catch (err) {
      return {
        isError: true,
        content: [{ type: "text", text: `Network error calling SportScore API: ${err.message}` }],
      };
    }
  
    const envelope = {
      tool: name,
      request_url: result.url,
      http_status: result.status,
      data: result.body,
      ...attributionFooter(),
    };
  
    return {
      content: [{ type: "text", text: JSON.stringify(envelope, null, 2) }],
      isError: result.status >= 400,
    };
  });

• src/index.js:187-203 (helper)

  Generic HTTP fetch utility (callApi) used by all tools. For 'get_team_schedule', it calls API_BASE + '/api/widget/team/' with the params from paramMap.

  async function callApi(path, params) {
    const url = new URL(API_BASE + path);
    for (const [k, v] of Object.entries(params)) {
      if (v !== undefined && v !== null && v !== "") url.searchParams.set(k, String(v));
    }
    const res = await fetch(url, {
      headers: { "Accept": "application/json", "User-Agent": UA },
    });
    const text = await res.text();
    let body;
    try {
      body = JSON.parse(text);
    } catch {
      body = { raw: text, _parse_error: "response was not valid JSON" };
    }
    return { status: res.status, url: url.toString(), body };
  }

• src/index.js:224-226 (registration)

  ListToolsRequestSchema handler — exposes all tools (including 'get_team_schedule') to the MCP host by returning name, description, and inputSchema for each.

  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })),
  }));