execute_procedure

Execute SQL Server stored procedures with parameters to perform database operations while maintaining security against SQL injection and destructive actions.

Instructions

Executes a stored procedure with parameters

Input Schema

TableJSON Schema

Name	Required	Description	Default
`parameters`	No	Procedure parameters
`procedureName`	Yes	Name of the stored procedure to execute
`schemaName`	No	Schema name (default: dbo)	dbo

Implementation Reference

src/tools/execute-procedure.ts:6-56 (handler)

Core handler function implementing the execute_procedure tool logic: executes SQL Server stored procedure with optional parameters, sanitizes inputs, handles results and errors.

export async function executeProcedure(
  db: DatabaseConnection,
  procedureName: string,
  parameters?: Record<string, unknown>,
  schemaName: string = 'dbo'
): Promise<CallToolResult> {
  try {
    const pool = db.getPool()
    const request = pool.request()

    if (parameters) {
      const sanitizedParams = sanitizeParameters(parameters)

      for (const [key, value] of Object.entries(sanitizedParams)) {
        request.input(key, value)
      }
    }

    const result = await request.execute(`${schemaName}.${procedureName}`)

    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(
            {
              procedure: `${schemaName}.${procedureName}`,
              recordsets: result.recordsets,
              recordset: result.recordset,
              output: result.output || {},
              returnValue: result.returnValue,
              rowsAffected: result.rowsAffected,
            },
            null,
            2
          ),
        },
      ],
    }
  } catch (error) {
    return {
      content: [
        {
          type: 'text',
          text: `Erro: ${error instanceof Error ? error.message : 'Erro desconhecido'}`,
        },
      ],
      isError: true,
    }
  }
}

src/services/SqlServerMCPService.ts:78-81 (registration)

MCP service registration of the execute_procedure tool handler, which delegates to the core executeProcedure function.

handlers.set('execute_procedure', async (database, args) => {
  const { procedureName, parameters } = args as ExecuteProcedureInput
  return await executeProcedure(database, procedureName, parameters ?? {})
})

src/schemas.ts:55-62 (schema)

Zod input schema validation for the execute_procedure tool.

export const executeProcedureInput = z.object({
  procedureName: z.string().describe('Name of the stored procedure to execute'),
  parameters: z
    .record(z.string(), z.unknown())
    .optional()
    .describe('Procedure parameters'),
  schemaName: z.string().default('dbo').describe('Schema name (default: dbo)'),
})

src/tools/index.ts:70-73 (registration)

Tool list registration providing name, description, and JSON schema for execute_procedure.

  name: 'execute_procedure',
  description: 'Executes a stored procedure with parameters',
  inputSchema: zodToJsonSchema(executeProcedureInput),
},

src/schemas.ts:84-84 (schema)
TypeScript type derived from the executeProcedureInput Zod schema.
```
export type ExecuteProcedureInput = z.infer<typeof executeProcedureInput>
```

SQL Server MCP Service