BBQ MCP Server

Instructions

Implementation Reference

• src/index.ts:357-429 (handler)

  Primary handler function for bbq_get_target_temperature tool, registers the tool and implements logic using getTargetTemperature helper with JSON/markdown output support

    "bbq_get_target_temperature",
    {
      title: "Get Target Temperature",
      description: `Get the target internal temperature for a specific protein and doneness level.
  
  Returns both the target serving temperature and the pull temperature (when to remove from heat) accounting for carryover cooking.
  
  Args:
    - protein_type: Type of protein
    - doneness: Desired doneness level (optional, uses recommended if not specified)
    - include_pull_temp: Whether to include pull temperature (default: true)
    - response_format: 'markdown' or 'json'
  
  Examples:
    - "What temp for medium-rare ribeye?" -> protein_type='beef_ribeye', doneness='medium_rare'
    - "When is chicken done?" -> protein_type='chicken_whole'`,
      inputSchema: GetTargetTemperatureSchema,
      annotations: {
        readOnlyHint: true,
        destructiveHint: false,
        idempotentHint: true,
        openWorldHint: false,
      },
    },
    async (params: GetTargetTemperatureInput) => {
      try {
        const profile = getProteinProfile(params.protein_type);
        const { targetTemp, pullTemp, doneness } = getTargetTemperature(
          params.protein_type,
          params.doneness
        );
  
        if (params.response_format === "json") {
          const output = {
            proteinType: params.protein_type,
            displayName: profile.displayName,
            doneness: {
              level: doneness,
              displayName: DONENESS_INFO[doneness].displayName,
              description: DONENESS_INFO[doneness].description,
            },
            temperatures: {
              target: targetTemp,
              pull: params.include_pull_temp ? pullTemp : undefined,
              carryover: profile.carryoverDegrees,
              usdaSafeMin: profile.usdaSafeTemp,
            },
            allDonenessOptions: Object.entries(profile.donenessTemps).map(([level, temp]) => ({
              level,
              displayName: DONENESS_INFO[level as DonenessLevel]?.displayName || level,
              temperature: temp,
            })),
          };
  
          return {
            content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
            structuredContent: output,
          };
        }
  
        const markdown = formatTargetTempMarkdown(profile, targetTemp, pullTemp, doneness);
        return {
          content: [{ type: "text", text: markdown }],
        };
      } catch (error) {
        const message = error instanceof Error ? error.message : "Unknown error occurred";
        return {
          isError: true,
          content: [{ type: "text", text: `Error getting target temperature: ${message}` }],
        };
      }
    }
  );

• src/smithery.ts:157-178 (handler)

  Smithery-specific handler for bbq_get_target_temperature tool using inline Zod schema and markdown output

  server.tool(
    "bbq_get_target_temperature",
    "Get target and pull temps for a protein",
    {
      protein_type: z.string().describe("Type of protein"),
      doneness: z.string().optional().describe("Desired doneness"),
    },
    async ({ protein_type, doneness }) => {
      try {
        const { targetTemp, pullTemp, doneness: actualDoneness } = getTargetTemperature(
          protein_type as ProteinType,
          doneness as DonenessLevel | undefined
        );
        const profile = getProteinProfile(protein_type as ProteinType);
        const text = `## ${profile.displayName}\n\n**Target:** ${targetTemp}°F\n**Pull At:** ${pullTemp}°F\n**Doneness:** ${DONENESS_INFO[actualDoneness]?.displayName || actualDoneness}`;
        return { content: [{ type: "text", text }] };
      } catch (error) {
        const message = error instanceof Error ? error.message : "Unknown error";
        return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
      }
    }
  );

• src/schemas/index.ts:126-138 (schema)

  Zod input schema for bbq_get_target_temperature tool parameters including protein_type, doneness, include_pull_temp, and response_format

  export const GetTargetTemperatureSchema = z
    .object({
      protein_type: ProteinTypeSchema.describe("Type of protein"),
      doneness: DonenessLevelSchema.optional().describe("Desired doneness level"),
      include_pull_temp: z
        .boolean()
        .default(true)
        .describe("Whether to include pull temperature (accounting for carryover)"),
      response_format: ResponseFormatSchema.describe("Output format"),
    })
    .strict();
  
  export type GetTargetTemperatureInput = z.infer<typeof GetTargetTemperatureSchema>;

• src/services/cooking.ts:30-52 (helper)

  Core helper function that implements the temperature calculation logic based on protein profiles and doneness levels, used by both handlers

   * Get the target temperature for a protein at a specific doneness
   */
  export function getTargetTemperature(
    proteinType: ProteinType,
    doneness?: DonenessLevel
  ): { targetTemp: number; pullTemp: number; doneness: DonenessLevel } {
    const profile = getProteinProfile(proteinType);
  
    // Determine the doneness to use
    let actualDoneness: DonenessLevel;
    if (doneness && profile.donenessTemps[doneness] !== undefined) {
      actualDoneness = doneness;
    } else {
      // Use the first available doneness (most common/recommended)
      const availableDoneness = Object.keys(profile.donenessTemps) as DonenessLevel[];
      actualDoneness = availableDoneness[0];
    }
  
    const targetTemp = profile.donenessTemps[actualDoneness] ?? profile.usdaSafeTemp;
    const pullTemp = targetTemp - profile.carryoverDegrees;
  
    return { targetTemp, pullTemp, doneness: actualDoneness };
  }