search_functions

Instructions

Implementation Reference

• src/index.ts:90-133 (registration)

  Registration of the 'search_functions' tool via server.registerTool, with inputSchema and handler callback.

  // Register tool: search_functions
  server.registerTool(
    "search_functions",
    {
      description:
        "Primary discovery tool. Search MTA:SA functions and events by name or keyword before coding. Returns canonical function names with side/category so LLMs can reliably chain into docs tools.",
      inputSchema: {
        query: z.string().describe("Function name or partial name to search for"),
        side: z
          .enum(["client", "server", "shared"])
          .optional()
          .describe("Filter by client-side, server-side, or shared functions"),
        limit: z
          .number()
          .int()
          .min(1)
          .max(200)
          .optional()
          .default(30)
          .describe("Maximum number of results"),
      },
    },
    async ({ query, side, limit }): Promise<CallToolResult> => {
      const results = searchFunctions(query, side, limit);
      const formatted =
        results.length > 0
          ? results.map((f) => `${f.name} [${f.side}] - ${f.category}`).join("\n")
          : "No entries found.";
  
      const nextSteps =
        results.length > 0
          ? "\n\nNext: call `get_function_docs` for one entry or `get_multiple_function_docs` for several results from this list."
          : "\n\nTip: try broader keywords (e.g., database, gui, dx, event, vehicle) or use `find_functions_for_task`.";
  
      return {
        content: [
          {
            type: "text",
            text: `Found ${results.length} MTA:SA functions/events:\n\n${formatted}${nextSteps}`,
          },
        ],
      };
    },
  );

• src/index.ts:112-132 (handler)

  Handler logic for search_functions: calls searchFunctions() from queries, formats results, returns text response with next steps.

  async ({ query, side, limit }): Promise<CallToolResult> => {
    const results = searchFunctions(query, side, limit);
    const formatted =
      results.length > 0
        ? results.map((f) => `${f.name} [${f.side}] - ${f.category}`).join("\n")
        : "No entries found.";
  
    const nextSteps =
      results.length > 0
        ? "\n\nNext: call `get_function_docs` for one entry or `get_multiple_function_docs` for several results from this list."
        : "\n\nTip: try broader keywords (e.g., database, gui, dx, event, vehicle) or use `find_functions_for_task`.";
  
    return {
      content: [
        {
          type: "text",
          text: `Found ${results.length} MTA:SA functions/events:\n\n${formatted}${nextSteps}`,
        },
      ],
    };
  },

• src/database/queries.ts:120-133 (helper)

  Helper function searchFunctions() that executes the SQL query via queries.searchMetadata() with LIKE pattern matching and side filter.

  // Helper to execute metadata search
  export const searchFunctions = (
    query: string,
    side?: MtasaSide,
    limit: number = 30,
  ): MtasaFunction[] => {
    const safeLimit = clampLimit(limit, 30, 200);
    const trimmedQuery = query.trim();
    const searchPattern = `%${trimmedQuery}%`;
    const rows = queries
      .searchMetadata()
      .all(searchPattern, side || null, side || null, safeLimit);
    return rows as MtasaFunction[];
  };

• src/database/queries.ts:61-68 (schema)

  SQL query definition for metadata search (searchMetadata): SELECT with LIKE, side filtering, and case-insensitive ordering.

  searchMetadata: () =>
    db.prepare(`
    SELECT * FROM function_metadata 
    WHERE name LIKE ? 
    AND (? IS NULL OR side = ? OR side = 'shared')
    ORDER BY name COLLATE NOCASE
    LIMIT ?
  `),

• src/types/interfaces.ts:1-8 (schema)

  Type definitions: MtasaSide enum and MtasaFunction interface returned by search_functions.

  export type MtasaSide = "client" | "server" | "shared";
  
  export interface MtasaFunction {
    name: string;
    type: number;
    category: string;
    side: MtasaSide;
  }