get_authors_by_name

Instructions

Implementation Reference

• src/tools/get-authors-by-name/index.ts:19-97 (handler)

  The handler function that executes the tool: validates input with Zod, queries Open Library /search/authors.json API with author name, processes docs into AuthorInfo array, returns JSON string or error.

  const handleGetAuthorsByName = async (
    args: unknown,
    axiosInstance: AxiosInstance,
  ): Promise<CallToolResult> => {
    const parseResult = GetAuthorsByNameArgsSchema.safeParse(args);
  
    if (!parseResult.success) {
      const errorMessages = parseResult.error.errors
        .map((e) => `${e.path.join(".")}: ${e.message}`)
        .join(", ");
      throw new McpError(
        ErrorCode.InvalidParams,
        `Invalid arguments for get_authors_by_name: ${errorMessages}`,
      );
    }
  
    const authorName = parseResult.data.name;
  
    try {
      const response = await axiosInstance.get<OpenLibraryAuthorSearchResponse>(
        "/search/authors.json", // Use the author search endpoint
        {
          params: { q: authorName }, // Use 'q' parameter for author search
        },
      );
  
      if (
        !response.data ||
        !response.data.docs ||
        response.data.docs.length === 0
      ) {
        return {
          content: [
            {
              type: "text",
              text: `No authors found matching name: "${authorName}"`,
            },
          ],
        };
      }
  
      const authorResults: AuthorInfo[] = response.data.docs.map((doc) => ({
        key: doc.key,
        name: doc.name,
        alternate_names: doc.alternate_names,
        birth_date: doc.birth_date,
        top_work: doc.top_work,
        work_count: doc.work_count,
      }));
  
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(authorResults, null, 2),
          },
        ],
      };
    } catch (error) {
      let errorMessage = "Failed to fetch author data from Open Library.";
      if (axios.isAxiosError(error)) {
        errorMessage = `Open Library API error: ${
          error.response?.statusText ?? error.message
        }`;
      } else if (error instanceof Error) {
        errorMessage = `Error processing request: ${error.message}`;
      }
      console.error("Error in get_authors_by_name:", error);
      return {
        content: [
          {
            type: "text",
            text: errorMessage,
          },
        ],
        isError: true,
      };
    }
  };

• src/tools/get-authors-by-name/index.ts:11-14 (schema)

  Zod schema for input validation: requires a non-empty 'name' string.

  // Schema for the get_authors_by_name tool arguments
  export const GetAuthorsByNameArgsSchema = z.object({
    name: z.string().min(1, { message: "Author name cannot be empty" }),
  });

• src/index.ts:70-82 (registration)

  Tool registration in MCP ListTools handler: defines name, description, and JSON schema matching the Zod schema.

    name: "get_authors_by_name",
    description: "Search for author information on Open Library.",
    inputSchema: {
      type: "object",
      properties: {
        name: {
          type: "string",
          description: "The name of the author to search for.",
        },
      },
      required: ["name"],
    },
  },

• src/index.ts:172-173 (registration)

  Dispatches tool calls to the handler in MCP CallToolRequestHandler switch statement.

  case "get_authors_by_name":
    return handleGetAuthorsByName(args, this.axiosInstance);

• src/tools/get-authors-by-name/types.ts:1-27 (helper)

  Type definitions for API response structures and processed author information used by the handler.

  export interface OpenLibraryAuthorDoc {
    key: string;
    type: string;
    name: string;
    alternate_names?: string[];
    birth_date?: string;
    top_work?: string;
    work_count: number;
    top_subjects?: string[];
    _version_?: number;
  }
  
  export interface OpenLibraryAuthorSearchResponse {
    numFound: number;
    start: number;
    numFoundExact: boolean;
    docs: OpenLibraryAuthorDoc[];
  }
  
  export interface AuthorInfo {
    key: string;
    name: string;
    alternate_names?: string[];
    birth_date?: string;
    top_work?: string;
    work_count: number;
  }